30006c80 <CPU_usage_Per_thread_handler>: static void CPU_usage_Per_thread_handler( Thread_Control *the_thread ) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used );
30006c80: e3a03000 mov r3, #0 <== NOT EXECUTED 30006c84: e5803084 str r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30006c88: e5803088 str r3, [r0, #136] ; 0x88 <== NOT EXECUTED
#else
the_thread->cpu_time_used = 0;
#endif
}
30006c8c: e12fff1e bx lr <== NOT EXECUTED
3000d8ec <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
3000d8ec: e5903000 ldr r3, [r0]
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000d8f0: e5902010 ldr r2, [r0, #16]
switch( node->type ) {
3000d8f4: e593304c ldr r3, [r3, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
3000d8f8: e5922034 ldr r2, [r2, #52] ; 0x34
switch( node->type ) {
3000d8fc: e2433001 sub r3, r3, #1 3000d900: e3530006 cmp r3, #6 3000d904: 979ff103 ldrls pc, [pc, r3, lsl #2]
3000d908: ea000008 b 3000d930 <IMFS_Set_handlers+0x44> <== NOT EXECUTED 3000d90c: 3000d958 .word 0x3000d958 <== NOT EXECUTED 3000d910: 3000d968 .word 0x3000d968 <== NOT EXECUTED 3000d914: 3000d948 .word 0x3000d948 <== NOT EXECUTED 3000d918: 3000d948 .word 0x3000d948 <== NOT EXECUTED 3000d91c: 3000d938 .word 0x3000d938 <== NOT EXECUTED 3000d920: 3000d938 .word 0x3000d938 <== NOT EXECUTED 3000d924: 3000d928 .word 0x3000d928 <== NOT EXECUTED
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
3000d928: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED 3000d92c: e5803008 str r3, [r0, #8] <== NOT EXECUTED
break;
}
return 0;
}
3000d930: e3a00000 mov r0, #0 <== NOT EXECUTED 3000d934: e12fff1e bx lr <== NOT EXECUTED
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
3000d938: e5923008 ldr r3, [r2, #8] 3000d93c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000d940: e3a00000 mov r0, #0 3000d944: e12fff1e bx lr
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
3000d948: e59f3028 ldr r3, [pc, #40] ; 3000d978 <IMFS_Set_handlers+0x8c> 3000d94c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000d950: e3a00000 mov r0, #0 3000d954: e12fff1e bx lr
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
3000d958: e592300c ldr r3, [r2, #12] 3000d95c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000d960: e3a00000 mov r0, #0 3000d964: e12fff1e bx lr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
3000d968: e59f300c ldr r3, [pc, #12] ; 3000d97c <IMFS_Set_handlers+0x90> 3000d96c: e5803008 str r3, [r0, #8]
loc->handlers = fs_info->fifo_handlers;
break;
}
return 0;
}
3000d970: e3a00000 mov r0, #0 3000d974: e12fff1e bx lr
3000d6ac <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000d6ac: e92d4010 push {r4, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
3000d6b0: e5904000 ldr r4, [r0] <== NOT EXECUTED
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
3000d6b4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
3000d6b8: e1c413bc strh r1, [r4, #60] ; 0x3c <== NOT EXECUTED
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000d6bc: e1a0000d mov r0, sp <== NOT EXECUTED
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
rtems_set_errno_and_return_minus_one( EPERM );
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
3000d6c0: e1c423be strh r2, [r4, #62] ; 0x3e <== NOT EXECUTED
IMFS_update_ctime( jnode );
3000d6c4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000d6c8: ebffe39b bl 3000653c <gettimeofday> <== NOT EXECUTED 3000d6cc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
3000d6d0: e3a00000 mov r0, #0 <== NOT EXECUTED
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
3000d6d4: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
3000d6d8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000d6dc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000d75c <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
3000d75c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
3000d760: e3500000 cmp r0, #0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
3000d764: e1a04001 mov r4, r1 3000d768: e59d7018 ldr r7, [sp, #24]
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
3000d76c: 01a08000 moveq r8, r0
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
3000d770: 0a00002b beq 3000d824 <IMFS_create_node+0xc8>
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
3000d774: e5901010 ldr r1, [r0, #16]
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d778: e3540007 cmp r4, #7
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
3000d77c: e5906000 ldr r6, [r0]
fs_info = parent_loc->mt_entry->fs_info;
3000d780: e5915034 ldr r5, [r1, #52] ; 0x34
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d784: 0a000028 beq 3000d82c <IMFS_create_node+0xd0>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
3000d788: e59f1114 ldr r1, [pc, #276] ; 3000d8a4 <IMFS_create_node+0x148> 3000d78c: e1a00004 mov r0, r4 3000d790: e591c000 ldr ip, [r1] 3000d794: e1a01002 mov r1, r2 3000d798: e59c202c ldr r2, [ip, #44] ; 0x2c 3000d79c: e1c32002 bic r2, r3, r2 3000d7a0: ebffffce bl 3000d6e0 <IMFS_allocate_node>
if ( !node )
3000d7a4: e2508000 subs r8, r0, #0
3000d7a8: 0a00001d beq 3000d824 <IMFS_create_node+0xc8>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
3000d7ac: e3540001 cmp r4, #1
3000d7b0: 0a00000d beq 3000d7ec <IMFS_create_node+0x90>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
3000d7b4: e3540003 cmp r4, #3
3000d7b8: 0a000026 beq 3000d858 <IMFS_create_node+0xfc>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
3000d7bc: e3540004 cmp r4, #4
3000d7c0: 0a000024 beq 3000d858 <IMFS_create_node+0xfc>
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
3000d7c4: e3540002 cmp r4, #2
3000d7c8: 0a00001e beq 3000d848 <IMFS_create_node+0xec>
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
3000d7cc: e3540006 cmp r4, #6
3000d7d0: 0a000023 beq 3000d864 <IMFS_create_node+0x108>
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
3000d7d4: e3540005 cmp r4, #5
3000d7d8: 0a000028 beq 3000d880 <IMFS_create_node+0x124>
node->info.file.size = 0;
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
} else if ( type == IMFS_FIFO ) {
3000d7dc: e3540007 cmp r4, #7 <== NOT EXECUTED
node->info.fifo.pipe = NULL;
3000d7e0: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000d7e4: 05883050 streq r3, [r8, #80] ; 0x50 <== NOT EXECUTED 3000d7e8: ea000005 b 3000d804 <IMFS_create_node+0xa8> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000d7ec: e2882054 add r2, r8, #84 ; 0x54
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000d7f0: e2883050 add r3, r8, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000d7f4: e5882050 str r2, [r8, #80] ; 0x50
head->previous = NULL;
3000d7f8: e3a02000 mov r2, #0 3000d7fc: e5882054 str r2, [r8, #84] ; 0x54
tail->previous = head;
3000d800: e5883058 str r3, [r8, #88] ; 0x58
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
3000d804: e5953004 ldr r3, [r5, #4] 3000d808: e2860050 add r0, r6, #80 ; 0x50 3000d80c: e2833001 add r3, r3, #1
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
3000d810: e5886008 str r6, [r8, #8] 3000d814: e1a01008 mov r1, r8
node->st_ino = ++fs_info->ino_count;
3000d818: e5853004 str r3, [r5, #4] 3000d81c: e5883038 str r3, [r8, #56] ; 0x38 3000d820: ebfff32b bl 3000a4d4 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
3000d824: e1a00008 mov r0, r8
3000d828: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d82c: e5950010 ldr r0, [r5, #16] 3000d830: e59f1070 ldr r1, [pc, #112] ; 3000d8a8 <IMFS_create_node+0x14c> 3000d834: e1500001 cmp r0, r1
fs_info->fifo_handlers == &rtems_filesystem_handlers_default )
return NULL;
3000d838: 03a08000 moveq r8, #0
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
3000d83c: 1affffd1 bne 3000d788 <IMFS_create_node+0x2c>
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
3000d840: e1a00008 mov r0, r8
3000d844: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
3000d848: e897000c ldm r7, {r2, r3}
3000d84c: e5882050 str r2, [r8, #80] ; 0x50
node->info.device.minor = info->device.minor;
3000d850: e5883054 str r3, [r8, #84] ; 0x54 3000d854: eaffffea b 3000d804 <IMFS_create_node+0xa8>
if ( type == IMFS_DIRECTORY ) {
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
node->info.sym_link.name = info->sym_link.name;
3000d858: e5973000 ldr r3, [r7] 3000d85c: e5883050 str r3, [r8, #80] ; 0x50 3000d860: eaffffe7 b 3000d804 <IMFS_create_node+0xa8>
} else if ( type == IMFS_DEVICE ) {
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
3000d864: e3a03000 mov r3, #0 3000d868: e3a04000 mov r4, #0 3000d86c: e5883050 str r3, [r8, #80] ; 0x50 3000d870: e5884054 str r4, [r8, #84] ; 0x54
node->info.linearfile.direct = 0;
3000d874: e3a03000 mov r3, #0 3000d878: e5883058 str r3, [r8, #88] ; 0x58 3000d87c: eaffffe0 b 3000d804 <IMFS_create_node+0xa8>
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
node->info.file.indirect = 0;
3000d880: e3a03000 mov r3, #0
node->info.device.minor = info->device.minor;
} else if ( type == IMFS_LINEAR_FILE ) {
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
} else if ( type == IMFS_MEMORY_FILE ) {
node->info.file.size = 0;
3000d884: e3a01000 mov r1, #0 3000d888: e3a02000 mov r2, #0 3000d88c: e5881050 str r1, [r8, #80] ; 0x50 3000d890: e5882054 str r2, [r8, #84] ; 0x54
node->info.file.indirect = 0;
3000d894: e5883058 str r3, [r8, #88] ; 0x58
node->info.file.doubly_indirect = 0;
3000d898: e588305c str r3, [r8, #92] ; 0x5c
node->info.file.triply_indirect = 0;
3000d89c: e5883060 str r3, [r8, #96] ; 0x60 3000d8a0: eaffffd7 b 3000d804 <IMFS_create_node+0xa8>
3000da0c <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000da0c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
3000da10: e3d25007 bics r5, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
3000da14: e24dd040 sub sp, sp, #64 ; 0x40 3000da18: e58d2000 str r2, [sp] 3000da1c: e1a0a000 mov sl, r0 3000da20: e1a04001 mov r4, r1 3000da24: e1a07003 mov r7, r3
char token[ IMFS_NAME_MAX + 1 ];
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
3000da28: 1a000081 bne 3000dc34 <IMFS_eval_path+0x228>
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000da2c: e5936000 ldr r6, [r3] 3000da30: e28d8004 add r8, sp, #4 3000da34: e28d903c add r9, sp, #60 ; 0x3c
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
3000da38: e1a02008 mov r2, r8 3000da3c: e1a03009 mov r3, r9 3000da40: e08a0005 add r0, sl, r5 3000da44: e1a01004 mov r1, r4 3000da48: eb0001df bl 3000e1cc <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000da4c: e5973000 ldr r3, [r7]
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
3000da50: e1a0b000 mov fp, r0
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
3000da54: e3530000 cmp r3, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
3000da58: e59d203c ldr r2, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000da5c: 0a00004e beq 3000db9c <IMFS_eval_path+0x190>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000da60: e3500000 cmp r0, #0
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
3000da64: e0624004 rsb r4, r2, r4
i += len;
3000da68: e0855002 add r5, r5, r2
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000da6c: 1a00000f bne 3000dab0 <IMFS_eval_path+0xa4>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
3000da70: e593204c ldr r2, [r3, #76] ; 0x4c 3000da74: e3520001 cmp r2, #1
3000da78: 0a000068 beq 3000dc20 <IMFS_eval_path+0x214>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000da7c: e1a00007 mov r0, r7 3000da80: ebffff99 bl 3000d8ec <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000da84: e59d1000 ldr r1, [sp]
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
3000da88: e1a06000 mov r6, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
3000da8c: e1a00007 mov r0, r7 3000da90: ebffffba bl 3000d980 <IMFS_evaluate_permission> 3000da94: e3500000 cmp r0, #0
3000da98: 1a000036 bne 3000db78 <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( EACCES );
3000da9c: eb000da1 bl 30011128 <__errno> <== NOT EXECUTED 3000daa0: e3a0300d mov r3, #13 <== NOT EXECUTED 3000daa4: e5803000 str r3, [r0] <== NOT EXECUTED 3000daa8: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000daac: ea000031 b 3000db78 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
3000dab0: e596104c ldr r1, [r6, #76] ; 0x4c 3000dab4: e3510001 cmp r1, #1
3000dab8: 0a000031 beq 3000db84 <IMFS_eval_path+0x178>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
3000dabc: e35b0003 cmp fp, #3
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000dac0: e1a06003 mov r6, r3
switch( type ) {
3000dac4: 0a000006 beq 3000dae4 <IMFS_eval_path+0xd8>
3000dac8: e35b0004 cmp fp, #4
3000dacc: 0a000025 beq 3000db68 <IMFS_eval_path+0x15c>
3000dad0: e35b0002 cmp fp, #2
3000dad4: 0a000013 beq 3000db28 <IMFS_eval_path+0x11c>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
3000dad8: e35b0004 cmp fp, #4
3000dadc: 1affffd5 bne 3000da38 <IMFS_eval_path+0x2c>
3000dae0: eaffffe2 b 3000da70 <IMFS_eval_path+0x64> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
3000dae4: e593304c ldr r3, [r3, #76] ; 0x4c 3000dae8: e3530003 cmp r3, #3
3000daec: 0a00002f beq 3000dbb0 <IMFS_eval_path+0x1a4>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
3000daf0: e3530004 cmp r3, #4
3000daf4: 0a000058 beq 3000dc5c <IMFS_eval_path+0x250>
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000daf8: e3530001 cmp r3, #1
3000dafc: 1a000051 bne 3000dc48 <IMFS_eval_path+0x23c>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
3000db00: e596e05c ldr lr, [r6, #92] ; 0x5c 3000db04: e35e0000 cmp lr, #0
3000db08: 1a000047 bne 3000dc2c <IMFS_eval_path+0x220>
}
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000db0c: e1a00006 mov r0, r6 3000db10: e1a01008 mov r1, r8 3000db14: eb00018b bl 3000e148 <IMFS_find_match_in_dir>
if ( !node )
3000db18: e2506000 subs r6, r0, #0
3000db1c: 0a00001e beq 3000db9c <IMFS_eval_path+0x190>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
3000db20: e5876000 str r6, [r7] 3000db24: eaffffc3 b 3000da38 <IMFS_eval_path+0x2c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000db28: e59f1154 ldr r1, [pc, #340] ; 3000dc84 <IMFS_eval_path+0x278> 3000db2c: e5912000 ldr r2, [r1] 3000db30: e5922018 ldr r2, [r2, #24] 3000db34: e1520003 cmp r2, r3
3000db38: 0affffbe beq 3000da38 <IMFS_eval_path+0x2c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
3000db3c: e597e010 ldr lr, [r7, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
3000db40: e59e201c ldr r2, [lr, #28] 3000db44: e1520003 cmp r2, r3
3000db48: 0a00001e beq 3000dbc8 <IMFS_eval_path+0x1bc>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
3000db4c: e5936008 ldr r6, [r3, #8] 3000db50: e3560000 cmp r6, #0
3000db54: 1afffff1 bne 3000db20 <IMFS_eval_path+0x114>
rtems_set_errno_and_return_minus_one( ENOENT );
3000db58: eb000d72 bl 30011128 <__errno> <== NOT EXECUTED 3000db5c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000db60: e580b000 str fp, [r0] <== NOT EXECUTED 3000db64: ea000003 b 3000db78 <IMFS_eval_path+0x16c> <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000db68: eb000d6e bl 30011128 <__errno> <== NOT EXECUTED 3000db6c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000db70: e5803000 str r3, [r0] <== NOT EXECUTED 3000db74: e3e06000 mvn r6, #0 <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000db78: e1a00006 mov r0, r6
3000db7c: e28dd040 add sp, sp, #64 ; 0x40
3000db80: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000db84: e1a00007 mov r0, r7 3000db88: ebffff7c bl 3000d980 <IMFS_evaluate_permission> 3000db8c: e3500000 cmp r0, #0
3000db90: 0affffc1 beq 3000da9c <IMFS_eval_path+0x90>
3000db94: e5973000 ldr r3, [r7] 3000db98: eaffffc7 b 3000dabc <IMFS_eval_path+0xb0>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
3000db9c: eb000d61 bl 30011128 <__errno> 3000dba0: e3a03002 mov r3, #2 3000dba4: e5803000 str r3, [r0] 3000dba8: e3e06000 mvn r6, #0 3000dbac: eafffff1 b 3000db78 <IMFS_eval_path+0x16c>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
3000dbb0: e1a00007 mov r0, r7 <== NOT EXECUTED 3000dbb4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000dbb8: ebffff80 bl 3000d9c0 <IMFS_evaluate_hard_link> <== NOT EXECUTED
node = pathloc->node_access;
3000dbbc: e5976000 ldr r6, [r7] <== NOT EXECUTED 3000dbc0: e596304c ldr r3, [r6, #76] ; 0x4c <== NOT EXECUTED 3000dbc4: eaffffcb b 3000daf8 <IMFS_eval_path+0xec> <== NOT EXECUTED
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000dbc8: e28ee008 add lr, lr, #8
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dbcc: e28d6028 add r6, sp, #40 ; 0x28
3000dbd0: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dbd4: e8a6000f stmia r6!, {r0, r1, r2, r3}
*pathloc = newloc;
3000dbd8: e28dc028 add ip, sp, #40 ; 0x28
3000dbdc: e8bc000f ldm ip!, {r0, r1, r2, r3}
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dbe0: e59ec000 ldr ip, [lr]
*pathloc = newloc;
3000dbe4: e1a0e007 mov lr, r7
3000dbe8: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dbec: e59d103c ldr r1, [sp, #60] ; 0x3c
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
3000dbf0: e58ec000 str ip, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dbf4: e0610005 rsb r0, r1, r5
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dbf8: e586c000 str ip, [r6]
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
3000dbfc: e08a0000 add r0, sl, r0 3000dc00: e597c00c ldr ip, [r7, #12] 3000dc04: e0841001 add r1, r4, r1 3000dc08: e59d2000 ldr r2, [sp] 3000dc0c: e1a03007 mov r3, r7 3000dc10: e1a0e00f mov lr, pc 3000dc14: e59cf000 ldr pc, [ip] 3000dc18: e1a06000 mov r6, r0 3000dc1c: eaffffd5 b 3000db78 <IMFS_eval_path+0x16c>
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
3000dc20: e593e05c ldr lr, [r3, #92] ; 0x5c 3000dc24: e35e0000 cmp lr, #0
3000dc28: 0affff93 beq 3000da7c <IMFS_eval_path+0x70>
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dc2c: e28ee01c add lr, lr, #28 3000dc30: eaffffe5 b 3000dbcc <IMFS_eval_path+0x1c0>
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
rtems_set_errno_and_return_minus_one( EIO );
3000dc34: eb000d3b bl 30011128 <__errno> <== NOT EXECUTED 3000dc38: e3a03005 mov r3, #5 <== NOT EXECUTED 3000dc3c: e5803000 str r3, [r0] <== NOT EXECUTED 3000dc40: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000dc44: eaffffcb b 3000db78 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000dc48: eb000d36 bl 30011128 <__errno> <== NOT EXECUTED 3000dc4c: e3a03014 mov r3, #20 <== NOT EXECUTED 3000dc50: e5803000 str r3, [r0] <== NOT EXECUTED 3000dc54: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000dc58: eaffffc6 b 3000db78 <IMFS_eval_path+0x16c> <== NOT EXECUTED
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000dc5c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000dc60: e3a01000 mov r1, #0 <== NOT EXECUTED 3000dc64: eb000007 bl 3000dc88 <IMFS_evaluate_sym_link> <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
3000dc68: e3700001 cmn r0, #1 <== NOT EXECUTED
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
3000dc6c: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
3000dc70: e5973000 ldr r3, [r7] <== NOT EXECUTED
if ( result == -1 )
3000dc74: 0affffbf beq 3000db78 <IMFS_eval_path+0x16c> <== NOT EXECUTED
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
3000dc78: e1a06003 mov r6, r3 <== NOT EXECUTED 3000dc7c: e593304c ldr r3, [r3, #76] ; 0x4c <== NOT EXECUTED 3000dc80: eaffff9c b 3000daf8 <IMFS_eval_path+0xec> <== NOT EXECUTED
3000ddf0 <IMFS_evaluate_for_make>:
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
3000ddf0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000ddf4: e24dd040 sub sp, sp, #64 ; 0x40
3000ddf8: e1a06001 mov r6, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
3000ddfc: e5915000 ldr r5, [r1]
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
3000de00: e1a0a000 mov sl, r0 3000de04: e58d2000 str r2, [sp]
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000de08: eb0010b0 bl 300120d0 <strlen>
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
int i = 0;
3000de0c: e3a07000 mov r7, #0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
3000de10: e1a04000 mov r4, r0 3000de14: e28d8004 add r8, sp, #4
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
3000de18: e1a01004 mov r1, r4 3000de1c: e28d303c add r3, sp, #60 ; 0x3c 3000de20: e08a0007 add r0, sl, r7 3000de24: e1a02008 mov r2, r8 3000de28: eb0000e7 bl 3000e1cc <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
3000de2c: e5963000 ldr r3, [r6]
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
3000de30: e59db03c ldr fp, [sp, #60] ; 0x3c
i += len;
if ( !pathloc->node_access )
3000de34: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
3000de38: e1a09000 mov r9, r0
pathlen -= len;
3000de3c: e06b4004 rsb r4, fp, r4
i += len;
if ( !pathloc->node_access )
3000de40: 0a000035 beq 3000df1c <IMFS_evaluate_for_make+0x12c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
3000de44: e3500000 cmp r0, #0
3000de48: 1a000006 bne 3000de68 <IMFS_evaluate_for_make+0x78>
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
3000de4c: eb000cb5 bl 30011128 <__errno> 3000de50: e3a03011 mov r3, #17 3000de54: e5803000 str r3, [r0] 3000de58: e3e05000 mvn r5, #0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000de5c: e1a00005 mov r0, r5
3000de60: e28dd040 add sp, sp, #64 ; 0x40
3000de64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
3000de68: e595104c ldr r1, [r5, #76] ; 0x4c 3000de6c: e3510001 cmp r1, #1
3000de70: 0a000044 beq 3000df88 <IMFS_evaluate_for_make+0x198>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
3000de74: e087700b add r7, r7, fp
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
3000de78: e1a05003 mov r5, r3
switch( type ) {
3000de7c: e3590004 cmp r9, #4 3000de80: 979ff109 ldrls pc, [pc, r9, lsl #2]
3000de84: eaffffe3 b 3000de18 <IMFS_evaluate_for_make+0x28> <== NOT EXECUTED 3000de88: 3000de4c .word 0x3000de4c <== NOT EXECUTED 3000de8c: 3000de18 .word 0x3000de18 <== NOT EXECUTED 3000de90: 3000deec .word 0x3000deec <== NOT EXECUTED 3000de94: 3000de9c .word 0x3000de9c <== NOT EXECUTED 3000de98: 3000df30 .word 0x3000df30 <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
3000de9c: e593304c ldr r3, [r3, #76] ; 0x4c 3000dea0: e3530003 cmp r3, #3
3000dea4: 0a00006a beq 3000e054 <IMFS_evaluate_for_make+0x264>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
3000dea8: e3530004 cmp r3, #4
3000deac: 0a000068 beq 3000e054 <IMFS_evaluate_for_make+0x264>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
3000deb0: e3550000 cmp r5, #0
3000deb4: 0a00005f beq 3000e038 <IMFS_evaluate_for_make+0x248>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
3000deb8: e595304c ldr r3, [r5, #76] ; 0x4c 3000debc: e3530001 cmp r3, #1
3000dec0: 1a00005c bne 3000e038 <IMFS_evaluate_for_make+0x248>
/*
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
3000dec4: e595c05c ldr ip, [r5, #92] ; 0x5c 3000dec8: e35c0000 cmp ip, #0
3000decc: 1a00005e bne 3000e04c <IMFS_evaluate_for_make+0x25c>
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
3000ded0: e1a00005 mov r0, r5 3000ded4: e1a01008 mov r1, r8 3000ded8: eb00009a bl 3000e148 <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
3000dedc: e2505000 subs r5, r0, #0
3000dee0: 0a000017 beq 3000df44 <IMFS_evaluate_for_make+0x154>
done = true;
else
pathloc->node_access = node;
3000dee4: e5865000 str r5, [r6] 3000dee8: eaffffca b 3000de18 <IMFS_evaluate_for_make+0x28>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
3000deec: e59f1180 ldr r1, [pc, #384] ; 3000e074 <IMFS_evaluate_for_make+0x284> 3000def0: e5912000 ldr r2, [r1] 3000def4: e5922018 ldr r2, [r2, #24] 3000def8: e1530002 cmp r3, r2
3000defc: 0affffc5 beq 3000de18 <IMFS_evaluate_for_make+0x28>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
3000df00: e596c010 ldr ip, [r6, #16] 3000df04: e59c201c ldr r2, [ip, #28] 3000df08: e1530002 cmp r3, r2
3000df0c: 0a000023 beq 3000dfa0 <IMFS_evaluate_for_make+0x1b0>
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
3000df10: e5935008 ldr r5, [r3, #8] 3000df14: e3550000 cmp r5, #0
3000df18: 1afffff1 bne 3000dee4 <IMFS_evaluate_for_make+0xf4>
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
rtems_set_errno_and_return_minus_one( ENOENT );
3000df1c: eb000c81 bl 30011128 <__errno> <== NOT EXECUTED 3000df20: e3a03002 mov r3, #2 <== NOT EXECUTED 3000df24: e5803000 str r3, [r0] <== NOT EXECUTED 3000df28: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000df2c: eaffffca b 3000de5c <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
3000df30: eb000c7c bl 30011128 <__errno> <== NOT EXECUTED 3000df34: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 3000df38: e5803000 str r3, [r0] <== NOT EXECUTED 3000df3c: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000df40: eaffffc5 b 3000de5c <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
3000df44: e59d303c ldr r3, [sp, #60] ; 0x3c 3000df48: e59d1000 ldr r1, [sp] 3000df4c: e0633007 rsb r3, r3, r7 3000df50: e08a3003 add r3, sl, r3 3000df54: e5813000 str r3, [r1]
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
3000df58: e7da0007 ldrb r0, [sl, r7] 3000df5c: e08a4007 add r4, sl, r7 3000df60: e3500000 cmp r0, #0
3000df64: 1a000003 bne 3000df78 <IMFS_evaluate_for_make+0x188>
3000df68: ea000021 b 3000dff4 <IMFS_evaluate_for_make+0x204>
3000df6c: e5f40001 ldrb r0, [r4, #1]! <== NOT EXECUTED 3000df70: e3500000 cmp r0, #0 <== NOT EXECUTED 3000df74: 0a00001e beq 3000dff4 <IMFS_evaluate_for_make+0x204> <== NOT EXECUTED
if ( !IMFS_is_separator( path[ i ] ) )
3000df78: ebffe507 bl 3000739c <rtems_filesystem_is_separator> <== NOT EXECUTED 3000df7c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000df80: 1afffff9 bne 3000df6c <IMFS_evaluate_for_make+0x17c> <== NOT EXECUTED 3000df84: eaffffe4 b 3000df1c <IMFS_evaluate_for_make+0x12c> <== NOT EXECUTED
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
3000df88: e1a00006 mov r0, r6 3000df8c: ebfffe7b bl 3000d980 <IMFS_evaluate_permission> 3000df90: e3500000 cmp r0, #0
3000df94: 0a000022 beq 3000e024 <IMFS_evaluate_for_make+0x234>
3000df98: e5963000 ldr r3, [r6] 3000df9c: eaffffb4 b 3000de74 <IMFS_evaluate_for_make+0x84>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
3000dfa0: e28cc008 add ip, ip, #8
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dfa4: e28d4028 add r4, sp, #40 ; 0x28
3000dfa8: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000dfac: e8a4000f stmia r4!, {r0, r1, r2, r3}
*pathloc = newloc;
3000dfb0: e28de028 add lr, sp, #40 ; 0x28
3000dfb4: e8be000f ldm lr!, {r0, r1, r2, r3}
3000dfb8: e1a0e006 mov lr, r6
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dfbc: e59cc000 ldr ip, [ip]
*pathloc = newloc;
3000dfc0: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000dfc4: e59d003c ldr r0, [sp, #60] ; 0x3c
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
3000dfc8: e58ec000 str ip, [lr]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000dfcc: e0600007 rsb r0, r0, r7
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000dfd0: e584c000 str ip, [r4]
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
3000dfd4: e596300c ldr r3, [r6, #12] 3000dfd8: e08a0000 add r0, sl, r0 3000dfdc: e1a01006 mov r1, r6 3000dfe0: e59d2000 ldr r2, [sp] 3000dfe4: e1a0e00f mov lr, pc 3000dfe8: e593f004 ldr pc, [r3, #4] 3000dfec: e1a05000 mov r5, r0 3000dff0: eaffff99 b 3000de5c <IMFS_evaluate_for_make+0x6c>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000dff4: e1a00006 mov r0, r6 3000dff8: ebfffe3b bl 3000d8ec <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000dffc: e5963000 ldr r3, [r6]
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
3000e000: e1a05000 mov r5, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
3000e004: e593304c ldr r3, [r3, #76] ; 0x4c 3000e008: e3530001 cmp r3, #1
3000e00c: 1a000009 bne 3000e038 <IMFS_evaluate_for_make+0x248>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
3000e010: e1a00006 mov r0, r6 3000e014: e3a01003 mov r1, #3 3000e018: ebfffe58 bl 3000d980 <IMFS_evaluate_permission> 3000e01c: e3500000 cmp r0, #0
3000e020: 1affff8d bne 3000de5c <IMFS_evaluate_for_make+0x6c>
rtems_set_errno_and_return_minus_one( EACCES );
3000e024: eb000c3f bl 30011128 <__errno> 3000e028: e3a0300d mov r3, #13 3000e02c: e5803000 str r3, [r0] 3000e030: e3e05000 mvn r5, #0 3000e034: eaffff88 b 3000de5c <IMFS_evaluate_for_make+0x6c>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000e038: eb000c3a bl 30011128 <__errno> <== NOT EXECUTED 3000e03c: e3a03014 mov r3, #20 <== NOT EXECUTED 3000e040: e5803000 str r3, [r0] <== NOT EXECUTED 3000e044: e3e05000 mvn r5, #0 <== NOT EXECUTED 3000e048: eaffff83 b 3000de5c <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
3000e04c: e28cc01c add ip, ip, #28 3000e050: eaffffd3 b 3000dfa4 <IMFS_evaluate_for_make+0x1b4>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000e054: e1a00006 mov r0, r6 <== NOT EXECUTED 3000e058: e3a01000 mov r1, #0 <== NOT EXECUTED 3000e05c: ebffff2e bl 3000dd1c <IMFS_evaluate_link> <== NOT EXECUTED
if ( result == -1 )
3000e060: e3700001 cmn r0, #1 <== NOT EXECUTED
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
3000e064: e1a05000 mov r5, r0 <== NOT EXECUTED
if ( result == -1 )
3000e068: 0affff7b beq 3000de5c <IMFS_evaluate_for_make+0x6c> <== NOT EXECUTED 3000e06c: e5965000 ldr r5, [r6] <== NOT EXECUTED 3000e070: eaffff8e b 3000deb0 <IMFS_evaluate_for_make+0xc0> <== NOT EXECUTED
3000d9c0 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d9c0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000d9c4: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d9c8: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000d9cc: e5933050 ldr r3, [r3, #80] ; 0x50 <== NOT EXECUTED
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000d9d0: e1a05001 mov r5, r1 <== NOT EXECUTED
IMFS_assert( jnode->type == IMFS_HARD_LINK );
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
3000d9d4: e5803000 str r3, [r0] <== NOT EXECUTED
IMFS_Set_handlers( node );
3000d9d8: ebffffc3 bl 3000d8ec <IMFS_Set_handlers> <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000d9dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d9e0: e1a01005 mov r1, r5 <== NOT EXECUTED 3000d9e4: ebffffe5 bl 3000d980 <IMFS_evaluate_permission> <== NOT EXECUTED 3000d9e8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000d9ec: 0a000001 beq 3000d9f8 <IMFS_evaluate_hard_link+0x38> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
3000d9f0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3000d9f4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
3000d9f8: eb000dca bl 30011128 <__errno> <== NOT EXECUTED
3000d9fc: e3a0300d mov r3, #13 <== NOT EXECUTED
3000da00: e5803000 str r3, [r0] <== NOT EXECUTED
3000da04: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000da08: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000dd1c <IMFS_evaluate_link>:
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dd1c: e92d40f0 push {r4, r5, r6, r7, lr}
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
3000dd20: e59f60c4 ldr r6, [pc, #196] ; 3000ddec <IMFS_evaluate_link+0xd0>
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dd24: e1a05000 mov r5, r0
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
3000dd28: e5963000 ldr r3, [r6]
*/
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dd2c: e1a07001 mov r7, r1 3000dd30: ea000004 b 3000dd48 <IMFS_evaluate_link+0x2c>
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
3000dd34: e3520004 cmp r2, #4
3000dd38: 0a00001b beq 3000ddac <IMFS_evaluate_link+0x90>
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
3000dd3c: e2422003 sub r2, r2, #3 3000dd40: e3520001 cmp r2, #1
3000dd44: 8a000014 bhi 3000dd9c <IMFS_evaluate_link+0x80>
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000dd48: e1d323b0 ldrh r2, [r3, #48] ; 0x30
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
3000dd4c: e5954000 ldr r4, [r5]
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000dd50: e2822001 add r2, r2, #1 3000dd54: e1a02802 lsl r2, r2, #16 3000dd58: e1a02822 lsr r2, r2, #16
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000dd5c: e3520005 cmp r2, #5
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
3000dd60: e1c323b0 strh r2, [r3, #48] ; 0x30
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
3000dd64: 8a000019 bhi 3000ddd0 <IMFS_evaluate_link+0xb4>
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
3000dd68: e594204c ldr r2, [r4, #76] ; 0x4c 3000dd6c: e3520003 cmp r2, #3
3000dd70: 1affffef bne 3000dd34 <IMFS_evaluate_link+0x18>
result = IMFS_evaluate_hard_link( node, flags );
3000dd74: e1a00005 mov r0, r5 <== NOT EXECUTED 3000dd78: e1a01007 mov r1, r7 <== NOT EXECUTED 3000dd7c: ebffff0f bl 3000d9c0 <IMFS_evaluate_hard_link> <== NOT EXECUTED
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000dd80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000dd84: 1a00000d bne 3000ddc0 <IMFS_evaluate_link+0xa4> <== NOT EXECUTED
3000dd88: e594204c ldr r2, [r4, #76] ; 0x4c 3000dd8c: e5963000 ldr r3, [r6]
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
3000dd90: e2422003 sub r2, r2, #3 3000dd94: e3520001 cmp r2, #1
3000dd98: 9affffea bls 3000dd48 <IMFS_evaluate_link+0x2c>
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000dd9c: e3a02000 mov r2, #0
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
3000dda0: e3a00000 mov r0, #0
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000dda4: e1c323b0 strh r2, [r3, #48] ; 0x30
return result;
}
3000dda8: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
3000ddac: e1a00005 mov r0, r5 3000ddb0: e1a01007 mov r1, r7 3000ddb4: ebffffb3 bl 3000dc88 <IMFS_evaluate_sym_link>
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
3000ddb8: e3500000 cmp r0, #0
3000ddbc: 0afffff1 beq 3000dd88 <IMFS_evaluate_link+0x6c>
3000ddc0: e5963000 ldr r3, [r6] <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
3000ddc4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ddc8: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
return result;
}
3000ddcc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
3000ddd0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000ddd4: e1c323b0 strh r2, [r3, #48] ; 0x30 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ELOOP );
3000ddd8: eb000cd2 bl 30011128 <__errno> <== NOT EXECUTED
3000dddc: e3a0305c mov r3, #92 ; 0x5c <== NOT EXECUTED
3000dde0: e5803000 str r3, [r0] <== NOT EXECUTED
3000dde4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000dde8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000d980 <IMFS_evaluate_permission>:
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000d980: e3d13007 bics r3, r1, #7
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
3000d984: e52de004 push {lr} ; (str lr, [sp, #-4]!)
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
3000d988: 1a000007 bne 3000d9ac <IMFS_evaluate_permission+0x2c>
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
3000d98c: e5903000 ldr r3, [r0]
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
3000d990: e1a01301 lsl r1, r1, #6
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
3000d994: e5930030 ldr r0, [r3, #48] ; 0x30 3000d998: e0010000 and r0, r1, r0
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000d99c: e1510000 cmp r1, r0 3000d9a0: 13a00000 movne r0, #0 3000d9a4: 03a00001 moveq r0, #1
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
3000d9a8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000d9ac: eb000ddd bl 30011128 <__errno> <== NOT EXECUTED
3000d9b0: e3a03001 mov r3, #1 <== NOT EXECUTED
3000d9b4: e5803000 str r3, [r0] <== NOT EXECUTED
3000d9b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d9bc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000dc88 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dc88: e92d4070 push {r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
3000dc8c: e5906000 ldr r6, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dc90: e24dd004 sub sp, sp, #4
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
3000dc94: e5963008 ldr r3, [r6, #8]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dc98: e1a04000 mov r4, r0
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
3000dc9c: e5803000 str r3, [r0]
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
3000dca0: e1a05001 mov r5, r1
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
rtems_filesystem_get_sym_start_loc(
3000dca4: e5960050 ldr r0, [r6, #80] ; 0x50 3000dca8: e1a0100d mov r1, sp 3000dcac: e1a02004 mov r2, r4 3000dcb0: eb0003ab bl 3000eb64 <rtems_filesystem_get_sym_start_loc>
);
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
3000dcb4: e59d3000 ldr r3, [sp] 3000dcb8: e5966050 ldr r6, [r6, #80] ; 0x50 3000dcbc: e0866003 add r6, r6, r3 3000dcc0: e1a00006 mov r0, r6 3000dcc4: eb001101 bl 300120d0 <strlen> 3000dcc8: e1a02005 mov r2, r5 3000dccc: e1a01000 mov r1, r0 3000dcd0: e1a03004 mov r3, r4 3000dcd4: e1a00006 mov r0, r6 3000dcd8: ebffff4b bl 3000da0c <IMFS_eval_path> 3000dcdc: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
3000dce0: e1a00004 mov r0, r4 3000dce4: ebffff00 bl 3000d8ec <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
3000dce8: e1a00004 mov r0, r4 3000dcec: e1a01005 mov r1, r5 3000dcf0: ebffff22 bl 3000d980 <IMFS_evaluate_permission> 3000dcf4: e3500000 cmp r0, #0
3000dcf8: 0a000002 beq 3000dd08 <IMFS_evaluate_sym_link+0x80>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
3000dcfc: e1a00006 mov r0, r6
3000dd00: e28dd004 add sp, sp, #4
3000dd04: e8bd8070 pop {r4, r5, r6, pc}
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
3000dd08: eb000d06 bl 30011128 <__errno> <== NOT EXECUTED 3000dd0c: e3a0300d mov r3, #13 <== NOT EXECUTED 3000dd10: e5803000 str r3, [r0] <== NOT EXECUTED 3000dd14: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000dd18: eafffff7 b 3000dcfc <IMFS_evaluate_sym_link+0x74> <== NOT EXECUTED
30010b78 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
30010b78: e92d4010 push {r4, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
30010b7c: e5904000 ldr r4, [r0] <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30010b80: e1a01a01 lsl r1, r1, #20 <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30010b84: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
30010b88: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30010b8c: e3c33eff bic r3, r3, #4080 ; 0xff0 <== NOT EXECUTED 30010b90: e3c3300f bic r3, r3, #15 <== NOT EXECUTED
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
30010b94: e1831a21 orr r1, r3, r1, lsr #20 <== NOT EXECUTED 30010b98: e5841030 str r1, [r4, #48] ; 0x30 <== NOT EXECUTED
IMFS_update_ctime( jnode );
30010b9c: e1a0000d mov r0, sp <== NOT EXECUTED 30010ba0: e3a01000 mov r1, #0 <== NOT EXECUTED 30010ba4: ebffd664 bl 3000653c <gettimeofday> <== NOT EXECUTED 30010ba8: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
30010bac: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
30010bb0: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30010bb4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010bb8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30010bbc <IMFS_fdatasync>:
int IMFS_fdatasync(
rtems_libio_t *iop
)
{
return 0;
}
30010bbc: e3a00000 mov r0, #0 <== NOT EXECUTED 30010bc0: e12fff1e bx lr <== NOT EXECUTED
30007180 <IMFS_fifo_close>:
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
30007180: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int err = 0; IMFS_jnode_t *jnode = iop->pathinfo.node_access;
30007184: e5905018 ldr r5, [r0, #24] <== NOT EXECUTED
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
30007188: e1a04000 mov r4, r0 <== NOT EXECUTED
int err = 0;
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
pipe_release(&JNODE2PIPE(jnode), iop);
3000718c: e1a01000 mov r1, r0 <== NOT EXECUTED 30007190: e2850050 add r0, r5, #80 ; 0x50 <== NOT EXECUTED 30007194: eb002500 bl 3001059c <pipe_release> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_OPEN;
30007198: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
IMFS_check_node_remove(jnode);
3000719c: e1a00005 mov r0, r5 <== NOT EXECUTED
int err = 0;
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
pipe_release(&JNODE2PIPE(jnode), iop);
iop->flags &= ~LIBIO_FLAGS_OPEN;
300071a0: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 300071a4: e5843014 str r3, [r4, #20] <== NOT EXECUTED
IMFS_check_node_remove(jnode);
300071a8: eb00018b bl 300077dc <IMFS_check_node_remove> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
}
300071ac: e3a00000 mov r0, #0 <== NOT EXECUTED
300071b0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007044 <IMFS_fifo_ioctl>:
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30007044: e1a03000 mov r3, r0 <== NOT EXECUTED
int err;
if (command == FIONBIO) {
30007048: e59f0070 ldr r0, [pc, #112] ; 300070c0 <IMFS_fifo_ioctl+0x7c><== NOT EXECUTED
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
3000704c: e92d4010 push {r4, lr} <== NOT EXECUTED
int err;
if (command == FIONBIO) {
30007050: e1510000 cmp r1, r0 <== NOT EXECUTED 30007054: 0a000007 beq 30007078 <IMFS_fifo_ioctl+0x34> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
30007058: e5930018 ldr r0, [r3, #24] <== NOT EXECUTED 3000705c: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED 30007060: eb002781 bl 30010e6c <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007064: e2502000 subs r2, r0, #0 <== NOT EXECUTED 30007068: b2624000 rsblt r4, r2, #0 <== NOT EXECUTED 3000706c: ba00000f blt 300070b0 <IMFS_fifo_ioctl+0x6c> <== NOT EXECUTED
}
30007070: e1a00002 mov r0, r2 <== NOT EXECUTED
30007074: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
30007078: e3520000 cmp r2, #0 <== NOT EXECUTED 3000707c: 0a00000a beq 300070ac <IMFS_fifo_ioctl+0x68> <== NOT EXECUTED
err = -EFAULT;
else {
if (*(int *)buffer)
30007080: e5922000 ldr r2, [r2] <== NOT EXECUTED 30007084: e3520000 cmp r2, #0 <== NOT EXECUTED
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30007088: 15931014 ldrne r1, [r3, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000708c: 05931014 ldreq r1, [r3, #20] <== NOT EXECUTED
return 0;
30007090: 13a02000 movne r2, #0 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
30007094: 13811001 orrne r1, r1, #1 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
30007098: 03c11001 biceq r1, r1, #1 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
3000709c: 15831014 strne r1, [r3, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
300070a0: 05831014 streq r1, [r3, #20] <== NOT EXECUTED
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
}
300070a4: e1a00002 mov r0, r2 <== NOT EXECUTED
300070a8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
300070ac: e3a0400e mov r4, #14 <== NOT EXECUTED
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
IMFS_FIFO_RETURN(err);
300070b0: eb002fcb bl 30012fe4 <__errno> <== NOT EXECUTED 300070b4: e3e02000 mvn r2, #0 <== NOT EXECUTED 300070b8: e5804000 str r4, [r0] <== NOT EXECUTED 300070bc: eaffffeb b 30007070 <IMFS_fifo_ioctl+0x2c> <== NOT EXECUTED
30006fe4 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30006fe4: e92d4010 push {r4, lr} <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30006fe8: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30006fec: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
30006ff0: e59cc050 ldr ip, [ip, #80] ; 0x50 <== NOT EXECUTED 30006ff4: e58d0000 str r0, [sp] <== NOT EXECUTED 30006ff8: e1a0000c mov r0, ip <== NOT EXECUTED 30006ffc: eb0027b3 bl 30010ed0 <pipe_lseek> <== NOT EXECUTED 30007000: e1a02000 mov r2, r0 <== NOT EXECUTED 30007004: e1a03fc2 asr r3, r2, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007008: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
3000700c: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
30007010: a1a04003 movge r4, r3 <== NOT EXECUTED 30007014: a1a03002 movge r3, r2 <== NOT EXECUTED 30007018: ba000003 blt 3000702c <IMFS_fifo_lseek+0x48> <== NOT EXECUTED
}
3000701c: e1a00003 mov r0, r3 <== NOT EXECUTED
30007020: e1a01004 mov r1, r4 <== NOT EXECUTED
30007024: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007028: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
3000702c: eb002fec bl 30012fe4 <__errno> <== NOT EXECUTED 30007030: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 30007034: e5804000 str r4, [r0] <== NOT EXECUTED 30007038: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000703c: e3e04000 mvn r4, #0 <== NOT EXECUTED 30007040: eafffff5 b 3000701c <IMFS_fifo_lseek+0x38> <== NOT EXECUTED
300071b4 <IMFS_fifo_open>:
uint32_t mode
)
{
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
300071b4: e5903018 ldr r3, [r0, #24] <== NOT EXECUTED
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
300071b8: e92d4010 push {r4, lr} <== NOT EXECUTED
300071bc: e1a01000 mov r1, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
300071c0: e2830050 add r0, r3, #80 ; 0x50 <== NOT EXECUTED 300071c4: eb00252a bl 30010674 <fifo_open> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
300071c8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 300071cc: ba000001 blt 300071d8 <IMFS_fifo_open+0x24> <== NOT EXECUTED
}
300071d0: e1a00004 mov r0, r4 <== NOT EXECUTED
300071d4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = fifo_open(&JNODE2PIPE(jnode), iop);
IMFS_FIFO_RETURN(err);
300071d8: eb002f81 bl 30012fe4 <__errno> <== NOT EXECUTED 300071dc: e2644000 rsb r4, r4, #0 <== NOT EXECUTED 300071e0: e5804000 str r4, [r0] <== NOT EXECUTED 300071e4: e3e04000 mvn r4, #0 <== NOT EXECUTED 300071e8: eafffff8 b 300071d0 <IMFS_fifo_open+0x1c> <== NOT EXECUTED
30007124 <IMFS_fifo_read>:
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30007124: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
30007128: e5904018 ldr r4, [r0, #24] <== NOT EXECUTED
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
3000712c: e1a03000 mov r3, r0 <== NOT EXECUTED 30007130: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
30007134: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED 30007138: eb00265e bl 30010ab8 <pipe_read> <== NOT EXECUTED
if (err > 0)
3000713c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30007140: da000007 ble 30007164 <IMFS_fifo_read+0x40> <== NOT EXECUTED
IMFS_update_atime(jnode);
30007144: e1a0000d mov r0, sp <== NOT EXECUTED 30007148: e3a01000 mov r1, #0 <== NOT EXECUTED 3000714c: eb0003fa bl 3000813c <gettimeofday> <== NOT EXECUTED 30007150: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30007154: e1a00005 mov r0, r5 <== NOT EXECUTED 30007158: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
}
3000715c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007160: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0)
IMFS_update_atime(jnode);
IMFS_FIFO_RETURN(err);
30007164: 01a00005 moveq r0, r5 <== NOT EXECUTED 30007168: 0afffffb beq 3000715c <IMFS_fifo_read+0x38> <== NOT EXECUTED 3000716c: eb002f9c bl 30012fe4 <__errno> <== NOT EXECUTED 30007170: e2655000 rsb r5, r5, #0 <== NOT EXECUTED 30007174: e5805000 str r5, [r0] <== NOT EXECUTED 30007178: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000717c: eafffff6 b 3000715c <IMFS_fifo_read+0x38> <== NOT EXECUTED
300070c4 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
300070c4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
300070c8: e5904018 ldr r4, [r0, #24] <== NOT EXECUTED
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
300070cc: e1a03000 mov r3, r0 <== NOT EXECUTED 300070d0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
300070d4: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED 300070d8: eb0026e3 bl 30010c6c <pipe_write> <== NOT EXECUTED
if (err > 0) {
300070dc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 300070e0: da000008 ble 30007108 <IMFS_fifo_write+0x44> <== NOT EXECUTED
IMFS_mtime_ctime_update(jnode);
300070e4: e1a0000d mov r0, sp <== NOT EXECUTED 300070e8: e3a01000 mov r1, #0 <== NOT EXECUTED 300070ec: eb000412 bl 3000813c <gettimeofday> <== NOT EXECUTED 300070f0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300070f4: e1a00005 mov r0, r5 <== NOT EXECUTED 300070f8: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED 300070fc: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
}
30007100: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007104: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
30007108: 01a00005 moveq r0, r5 <== NOT EXECUTED 3000710c: 0afffffb beq 30007100 <IMFS_fifo_write+0x3c> <== NOT EXECUTED 30007110: eb002fb3 bl 30012fe4 <__errno> <== NOT EXECUTED 30007114: e2655000 rsb r5, r5, #0 <== NOT EXECUTED 30007118: e5805000 str r5, [r0] <== NOT EXECUTED 3000711c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007120: eafffff6 b 30007100 <IMFS_fifo_write+0x3c> <== NOT EXECUTED
3000e078 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000e078: e92d4070 push {r4, r5, r6, lr}
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
3000e07c: e1a0c000 mov ip, r0
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000e080: e24dd014 sub sp, sp, #20
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
3000e084: e5bc401c ldr r4, [ip, #28]!
loc = temp_mt_entry->mt_fs_root;
3000e088: e1a0600d mov r6, sp
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
3000e08c: e1a0e000 mov lr, r0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
3000e090: e8bc000f ldm ip!, {r0, r1, r2, r3}
3000e094: e8a6000f stmia r6!, {r0, r1, r2, r3}
3000e098: e59c2000 ldr r2, [ip]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000e09c: e3a03000 mov r3, #0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
3000e0a0: e1a0500d mov r5, sp 3000e0a4: e5862000 str r2, [r6]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
3000e0a8: e58e301c str r3, [lr, #28]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
3000e0ac: e1a0000d mov r0, sp
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
3000e0b0: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
3000e0b4: e58d4000 str r4, [sp]
IMFS_Set_handlers( &loc );
3000e0b8: ebfffe0b bl 3000d8ec <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
3000e0bc: e594304c ldr r3, [r4, #76] ; 0x4c
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000e0c0: e2842054 add r2, r4, #84 ; 0x54 3000e0c4: e3530001 cmp r3, #1
3000e0c8: 1a000010 bne 3000e110 <IMFS_fsunmount+0x98>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
3000e0cc: e5943050 ldr r3, [r4, #80] ; 0x50 3000e0d0: e1530002 cmp r3, r2
3000e0d4: 0a000014 beq 3000e12c <IMFS_fsunmount+0xb4>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
3000e0d8: e3540000 cmp r4, #0
3000e0dc: 0a000008 beq 3000e104 <IMFS_fsunmount+0x8c>
if ( jnode->type == IMFS_DIRECTORY ) {
3000e0e0: e594304c ldr r3, [r4, #76] ; 0x4c 3000e0e4: e3530001 cmp r3, #1
3000e0e8: 1affffef bne 3000e0ac <IMFS_fsunmount+0x34>
}
}
} while (jnode != NULL);
return 0;
}
3000e0ec: e5943050 ldr r3, [r4, #80] ; 0x50 3000e0f0: e2842054 add r2, r4, #84 ; 0x54
return -1;
jnode = next;
}
if ( jnode != NULL ) {
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
3000e0f4: e1530002 cmp r3, r2
3000e0f8: 0affffeb beq 3000e0ac <IMFS_fsunmount+0x34>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
3000e0fc: e2534000 subs r4, r3, #0
3000e100: 1affffe9 bne 3000e0ac <IMFS_fsunmount+0x34>
return 0;
3000e104: e1a00004 mov r0, r4
}
3000e108: e28dd014 add sp, sp, #20
3000e10c: e8bd8070 pop {r4, r5, r6, pc}
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( jnode->type != IMFS_DIRECTORY ) {
result = IMFS_unlink( NULL, &loc );
3000e110: e1a0100d mov r1, sp 3000e114: e3a00000 mov r0, #0 3000e118: ebffdfa2 bl 30005fa8 <IMFS_unlink>
if (result != 0)
3000e11c: e3500000 cmp r0, #0
3000e120: 1a000006 bne 3000e140 <IMFS_fsunmount+0xc8>
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
3000e124: e1a04006 mov r4, r6 3000e128: eaffffea b 3000e0d8 <IMFS_fsunmount+0x60>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
3000e12c: e3a00000 mov r0, #0 3000e130: e1a0100d mov r1, sp 3000e134: ebffdf9b bl 30005fa8 <IMFS_unlink>
if (result != 0)
3000e138: e3500000 cmp r0, #0
3000e13c: 0afffff8 beq 3000e124 <IMFS_fsunmount+0xac>
return -1;
3000e140: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e144: eaffffef b 3000e108 <IMFS_fsunmount+0x90> <== NOT EXECUTED
3000e1cc <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
3000e1cc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000e1d0: e1a05001 mov r5, r1
3000e1d4: e1a04002 mov r4, r2
3000e1d8: e1a0a003 mov sl, r3
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
3000e1dc: e5d07000 ldrb r7, [r0] 3000e1e0: e1a08000 mov r8, r0
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
3000e1e4: e3a06000 mov r6, #0
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
3000e1e8: ea000006 b 3000e208 <IMFS_get_token+0x3c> 3000e1ec: e1560005 cmp r6, r5
3000e1f0: aa000008 bge 3000e218 <IMFS_get_token+0x4c>
token[i] = c;
if ( i == IMFS_NAME_MAX )
3000e1f4: e3560020 cmp r6, #32
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
3000e1f8: e7c47006 strb r7, [r4, r6]
if ( i == IMFS_NAME_MAX )
3000e1fc: 0a00001b beq 3000e270 <IMFS_get_token+0xa4>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
3000e200: e5f87001 ldrb r7, [r8, #1]! 3000e204: e2866001 add r6, r6, #1
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
3000e208: e1a00007 mov r0, r7 3000e20c: ebffe462 bl 3000739c <rtems_filesystem_is_separator> 3000e210: e3500000 cmp r0, #0
3000e214: 0afffff4 beq 3000e1ec <IMFS_get_token+0x20>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
3000e218: e3560000 cmp r6, #0
3000e21c: 1a000006 bne 3000e23c <IMFS_get_token+0x70>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
3000e220: e3570000 cmp r7, #0 3000e224: 13550000 cmpne r5, #0
i++;
type = IMFS_CURRENT_DIR;
3000e228: 13a06001 movne r6, #1
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
3000e22c: e5c47000 strb r7, [r4]
if ( (token[i] != '\0') && pathlen ) {
i++;
3000e230: e1a00006 mov r0, r6
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000e234: e58a6000 str r6, [sl]
3000e238: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000e23c: e0843006 add r3, r4, r6 3000e240: e5533001 ldrb r3, [r3, #-1]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
3000e244: e1a00004 mov r0, r4
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
3000e248: e3530000 cmp r3, #0
token[i] = '\0';
3000e24c: 13a03000 movne r3, #0 3000e250: 17c43006 strbne r3, [r4, r6]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
3000e254: e59f1038 ldr r1, [pc, #56] ; 3000e294 <IMFS_get_token+0xc8>
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
3000e258: e58a6000 str r6, [sl]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
3000e25c: eb000ebf bl 30011d60 <strcmp> 3000e260: e3500000 cmp r0, #0
3000e264: 1a000003 bne 3000e278 <IMFS_get_token+0xac>
type = IMFS_UP_DIR;
3000e268: e3a00002 mov r0, #2
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
3000e26c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
3000e270: e3a00004 mov r0, #4 <== NOT EXECUTED
3000e274: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
3000e278: e1a00004 mov r0, r4
3000e27c: e59f1014 ldr r1, [pc, #20] ; 3000e298 <IMFS_get_token+0xcc>
3000e280: eb000eb6 bl 30011d60 <strcmp>
3000e284: e3500000 cmp r0, #0
3000e288: 03a00001 moveq r0, #1
3000e28c: 13a00003 movne r0, #3
3000e290: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30005b90 <IMFS_initialize_support>:
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005b90: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30005b94: e1a04000 mov r4, r0
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005b98: e59f00e0 ldr r0, [pc, #224] ; 30005c80 <IMFS_initialize_support+0xf0>
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005b9c: e1a08001 mov r8, r1
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
30005ba0: e5900000 ldr r0, [r0]
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005ba4: e1a0a002 mov sl, r2
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005ba8: e3500010 cmp r0, #16
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers,
const rtems_filesystem_file_handlers_r *fifo_handlers
)
{
30005bac: e1a07003 mov r7, r3
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005bb0: 0a00000a beq 30005be0 <IMFS_initialize_support+0x50>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
30005bb4: e350000f cmp r0, #15 30005bb8: c3a02005 movgt r2, #5 30005bbc: c3a03020 movgt r3, #32
30005bc0: da000005 ble 30005bdc <IMFS_initialize_support+0x4c>
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
30005bc4: e1500003 cmp r0, r3
30005bc8: 0a000004 beq 30005be0 <IMFS_initialize_support+0x50>
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
30005bcc: ba000002 blt 30005bdc <IMFS_initialize_support+0x4c>
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
30005bd0: e2522001 subs r2, r2, #1 30005bd4: e1a03083 lsl r3, r3, #1
30005bd8: 1afffff9 bne 30005bc4 <IMFS_initialize_support+0x34>
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
30005bdc: e3a00080 mov r0, #128 ; 0x80
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
30005be0: e59f509c ldr r5, [pc, #156] ; 30005c84 <IMFS_initialize_support+0xf4> 30005be4: e5850000 str r0, [r5]
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005be8: eb001f2f bl 3000d8ac <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005bec: e59fe094 ldr lr, [pc, #148] ; 30005c88 <IMFS_initialize_support+0xf8> 30005bf0: e284c038 add ip, r4, #56 ; 0x38
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005bf4: e1a06000 mov r6, r0
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005bf8: e8be000f ldm lr!, {r0, r1, r2, r3}
30005bfc: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005c00: e8be000f ldm lr!, {r0, r1, r2, r3}
30005c04: e8ac000f stmia ip!, {r0, r1, r2, r3}
30005c08: e89e000f ldm lr, {r0, r1, r2, r3}
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
30005c0c: e584601c str r6, [r4, #28]
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
30005c10: e88c000f stm ip, {r0, r1, r2, r3}
* Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers;
30005c14: e5847024 str r7, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = op_table;
30005c18: e5848028 str r8, [r4, #40] ; 0x28
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
30005c1c: e3a00001 mov r0, #1 30005c20: e3a01014 mov r1, #20 30005c24: eb0001ae bl 300062e4 <calloc>
if ( !fs_info ) {
30005c28: e3500000 cmp r0, #0
30005c2c: 0a00000c beq 30005c64 <IMFS_initialize_support+0xd4>
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c30: e5952004 ldr r2, [r5, #4]
fs_info->ino_count = 1;
30005c34: e3a03001 mov r3, #1
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
30005c38: e5840034 str r0, [r4, #52] ; 0x34
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c3c: e0821003 add r1, r2, r3 30005c40: e5802000 str r2, [r0]
fs_info->ino_count = 1; fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers; fs_info->fifo_handlers = fifo_handlers;
30005c44: e59d201c ldr r2, [sp, #28]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
30005c48: e9800408 stmib r0, {r3, sl}
fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers;
30005c4c: e580700c str r7, [r0, #12]
fs_info->fifo_handlers = fifo_handlers;
30005c50: e5802010 str r2, [r0, #16]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
30005c54: e5851004 str r1, [r5, #4]
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
return 0;
30005c58: e3a00000 mov r0, #0
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
fs_info->fifo_handlers = fifo_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
30005c5c: e5863038 str r3, [r6, #56] ; 0x38
return 0;
}
30005c60: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
30005c64: e1a00006 mov r0, r6 <== NOT EXECUTED 30005c68: eb00020a bl 30006498 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005c6c: eb002d2d bl 30011128 <__errno> <== NOT EXECUTED
30005c70: e3a0300c mov r3, #12 <== NOT EXECUTED
30005c74: e5803000 str r3, [r0] <== NOT EXECUTED
30005c78: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005c7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30005c8c <IMFS_link>:
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005c8c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
30005c90: e5903000 ldr r3, [r0] <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005c94: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005c98: e1d313b4 ldrh r1, [r3, #52] ; 0x34 <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005c9c: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005ca0: e3510007 cmp r1, #7 <== NOT EXECUTED
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
30005ca4: e1a06002 mov r6, r2 <== NOT EXECUTED
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
30005ca8: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
30005cac: 8a00001d bhi 30005d28 <IMFS_link+0x9c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
30005cb0: e1a00002 mov r0, r2 <== NOT EXECUTED 30005cb4: eb003105 bl 300120d0 <strlen> <== NOT EXECUTED 30005cb8: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30005cbc: e1a01000 mov r1, r0 <== NOT EXECUTED 30005cc0: e1a02004 mov r2, r4 <== NOT EXECUTED 30005cc4: e28d3044 add r3, sp, #68 ; 0x44 <== NOT EXECUTED 30005cc8: e1a00006 mov r0, r6 <== NOT EXECUTED 30005ccc: eb00213e bl 3000e1cc <IMFS_get_token> <== NOT EXECUTED
new_node = IMFS_create_node(
parent_loc,
IMFS_HARD_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
30005cd0: e28d3028 add r3, sp, #40 ; 0x28 <== NOT EXECUTED
* was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node(
30005cd4: e58d3000 str r3, [sp] <== NOT EXECUTED 30005cd8: e3a01003 mov r1, #3 <== NOT EXECUTED 30005cdc: e1a00005 mov r0, r5 <== NOT EXECUTED 30005ce0: e1a02004 mov r2, r4 <== NOT EXECUTED 30005ce4: e59f3064 ldr r3, [pc, #100] ; 30005d50 <IMFS_link+0xc4> <== NOT EXECUTED 30005ce8: eb001e9b bl 3000d75c <IMFS_create_node> <== NOT EXECUTED
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
30005cec: e3500000 cmp r0, #0 <== NOT EXECUTED 30005cf0: 0a000011 beq 30005d3c <IMFS_link+0xb0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005cf4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005cf8: e28d003c add r0, sp, #60 ; 0x3c <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005cfc: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005d00: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
30005d04: e2822001 add r2, r2, #1 <== NOT EXECUTED 30005d08: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( info.hard_link.link_node );
30005d0c: eb00020a bl 3000653c <gettimeofday> <== NOT EXECUTED 30005d10: e59d203c ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED 30005d14: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
return 0;
30005d18: e3a00000 mov r0, #0 <== NOT EXECUTED
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
IMFS_update_ctime( info.hard_link.link_node );
30005d1c: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005d20: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30005d24: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
rtems_set_errno_and_return_minus_one( EMLINK );
30005d28: eb002cfe bl 30011128 <__errno> <== NOT EXECUTED 30005d2c: e3a0301f mov r3, #31 <== NOT EXECUTED 30005d30: e5803000 str r3, [r0] <== NOT EXECUTED 30005d34: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005d38: eafffff8 b 30005d20 <IMFS_link+0x94> <== NOT EXECUTED
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
30005d3c: eb002cf9 bl 30011128 <__errno> <== NOT EXECUTED 30005d40: e3a0300c mov r3, #12 <== NOT EXECUTED 30005d44: e5803000 str r3, [r0] <== NOT EXECUTED 30005d48: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005d4c: eafffff3 b 30005d20 <IMFS_link+0x94> <== NOT EXECUTED
30010158 <IMFS_memfile_extend>:
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010158: e59f3128 ldr r3, [pc, #296] ; 30010288 <IMFS_memfile_extend+0x130>
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
3001015c: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr}
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010160: e593b000 ldr fp, [r3]
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
30010164: e1a06002 mov r6, r2
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010168: e1a0312b lsr r3, fp, #2 3001016c: e0223393 mla r2, r3, r3, r3 30010170: e0233392 mla r3, r2, r3, r3 30010174: e3a02000 mov r2, #0 30010178: e2433001 sub r3, r3, #1 3001017c: e1520006 cmp r2, r6
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
30010180: e24dd004 sub sp, sp, #4 30010184: e1a04000 mov r4, r0 30010188: e1a08001 mov r8, r1
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
3001018c: e003039b mul r3, fp, r3
30010190: da000034 ble 30010268 <IMFS_memfile_extend+0x110>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
30010194: e5947054 ldr r7, [r4, #84] ; 0x54 30010198: e594a050 ldr sl, [r4, #80] ; 0x50 3001019c: e1560007 cmp r6, r7
300101a0: da000027 ble 30010244 <IMFS_memfile_extend+0xec>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
300101a4: e1a0cfcb asr ip, fp, #31 300101a8: e1a0300c mov r3, ip 300101ac: e1a0200b mov r2, fp 300101b0: e1a00008 mov r0, r8 300101b4: e1a01006 mov r1, r6 300101b8: e58dc000 str ip, [sp] 300101bc: eb001442 bl 300152cc <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
300101c0: e59dc000 ldr ip, [sp]
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
300101c4: e1a05000 mov r5, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
300101c8: e1a01007 mov r1, r7 300101cc: e1a0000a mov r0, sl 300101d0: e1a0200b mov r2, fp 300101d4: e1a0300c mov r3, ip 300101d8: eb00143b bl 300152cc <__divdi3>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
300101dc: e1550000 cmp r5, r0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
300101e0: e1a0a000 mov sl, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
300101e4: 3a00001b bcc 30010258 <IMFS_memfile_extend+0x100>
300101e8: e1a07000 mov r7, r0 300101ec: ea000002 b 300101fc <IMFS_memfile_extend+0xa4> 300101f0: e2877001 add r7, r7, #1 300101f4: e1550007 cmp r5, r7
300101f8: 3a000016 bcc 30010258 <IMFS_memfile_extend+0x100>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
300101fc: e1a01007 mov r1, r7 30010200: e1a00004 mov r0, r4 30010204: ebffff4e bl 3000ff44 <IMFS_memfile_addblock> 30010208: e3500000 cmp r0, #0
3001020c: 0afffff7 beq 300101f0 <IMFS_memfile_extend+0x98>
30010210: ea000003 b 30010224 <IMFS_memfile_extend+0xcc> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
30010214: e1a01007 mov r1, r7 <== NOT EXECUTED 30010218: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
3001021c: e2477001 sub r7, r7, #1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
30010220: ebffffc2 bl 30010130 <IMFS_memfile_remove_block> <== NOT EXECUTED
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
30010224: e15a0007 cmp sl, r7 <== NOT EXECUTED 30010228: 9afffff9 bls 30010214 <IMFS_memfile_extend+0xbc> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
3001022c: eb0003bd bl 30011128 <__errno> <== NOT EXECUTED 30010230: e3a0301c mov r3, #28 <== NOT EXECUTED 30010234: e5803000 str r3, [r0] <== NOT EXECUTED 30010238: e3e00000 mvn r0, #0 <== NOT EXECUTED
/* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; }
3001023c: e28dd004 add sp, sp, #4
30010240: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc}
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
30010244: 1a000001 bne 30010250 <IMFS_memfile_extend+0xf8>
30010248: e158000a cmp r8, sl
3001024c: 8affffd4 bhi 300101a4 <IMFS_memfile_extend+0x4c>
return 0;
30010250: e3a00000 mov r0, #0 30010254: eafffff8 b 3001023c <IMFS_memfile_extend+0xe4>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
30010258: e5848050 str r8, [r4, #80] ; 0x50 3001025c: e5846054 str r6, [r4, #84] ; 0x54
return 0;
30010260: e3a00000 mov r0, #0 30010264: eafffff4 b 3001023c <IMFS_memfile_extend+0xe4>
IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
30010268: 1a000001 bne 30010274 <IMFS_memfile_extend+0x11c>
3001026c: e1530001 cmp r3, r1
30010270: 8affffc7 bhi 30010194 <IMFS_memfile_extend+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
30010274: eb0003ab bl 30011128 <__errno> <== NOT EXECUTED 30010278: e3a03016 mov r3, #22 <== NOT EXECUTED 3001027c: e5803000 str r3, [r0] <== NOT EXECUTED 30010280: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010284: eaffffec b 3001023c <IMFS_memfile_extend+0xe4> <== NOT EXECUTED
3000faf8 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000faf8: e59f3200 ldr r3, [pc, #512] ; 3000fd00 <IMFS_memfile_get_block_pointer+0x208>
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000fafc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000fb00: e5934000 ldr r4, [r3]
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000fb04: e24dd004 sub sp, sp, #4
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000fb08: e1a04124 lsr r4, r4, #2 3000fb0c: e2443001 sub r3, r4, #1 3000fb10: e1510003 cmp r1, r3
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
3000fb14: e1a05000 mov r5, r0 3000fb18: e1a06002 mov r6, r2
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
3000fb1c: 8a000007 bhi 3000fb40 <IMFS_memfile_get_block_pointer+0x48>
p = info->indirect;
if ( malloc_it ) {
3000fb20: e3520000 cmp r2, #0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
3000fb24: e5900058 ldr r0, [r0, #88] ; 0x58
if ( malloc_it ) {
3000fb28: 0a00001c beq 3000fba0 <IMFS_memfile_get_block_pointer+0xa8>
if ( !p ) {
3000fb2c: e3500000 cmp r0, #0
3000fb30: 0a000041 beq 3000fc3c <IMFS_memfile_get_block_pointer+0x144>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
3000fb34: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
3000fb38: e28dd004 add sp, sp, #4
3000fb3c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
3000fb40: e0274494 mla r7, r4, r4, r4 3000fb44: e2473001 sub r3, r7, #1 3000fb48: e1510003 cmp r1, r3
3000fb4c: 8a000016 bhi 3000fbac <IMFS_memfile_get_block_pointer+0xb4>
my_block -= FIRST_DOUBLY_INDIRECT;
3000fb50: e0647001 rsb r7, r4, r1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000fb54: e1a00007 mov r0, r7 3000fb58: e1a01004 mov r1, r4 3000fb5c: eb00137a bl 3001494c <__umodsi3>
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fb60: e1a01004 mov r1, r4
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000fb64: e1a08000 mov r8, r0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fb68: e1a00007 mov r0, r7 3000fb6c: eb001330 bl 30014834 <__aeabi_uidiv>
p = info->doubly_indirect;
if ( malloc_it ) {
3000fb70: e3560000 cmp r6, #0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fb74: e1a04000 mov r4, r0
p = info->doubly_indirect;
3000fb78: e595305c ldr r3, [r5, #92] ; 0x5c
if ( malloc_it ) {
3000fb7c: 0a00003f beq 3000fc80 <IMFS_memfile_get_block_pointer+0x188>
if ( !p ) {
3000fb80: e3530000 cmp r3, #0
3000fb84: 0a000045 beq 3000fca0 <IMFS_memfile_get_block_pointer+0x1a8>
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
3000fb88: e7930104 ldr r0, [r3, r4, lsl #2] 3000fb8c: e0834104 add r4, r3, r4, lsl #2
if ( !p1 ) {
3000fb90: e3500000 cmp r0, #0
3000fb94: 0a00002f beq 3000fc58 <IMFS_memfile_get_block_pointer+0x160>
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
3000fb98: e0800108 add r0, r0, r8, lsl #2 3000fb9c: eaffffe5 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40>
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
3000fba0: e3500000 cmp r0, #0
3000fba4: 1affffe2 bne 3000fb34 <IMFS_memfile_get_block_pointer+0x3c>
3000fba8: eaffffe2 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000fbac: e0234497 mla r3, r7, r4, r4 <== NOT EXECUTED 3000fbb0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000fbb4: e1510003 cmp r1, r3 <== NOT EXECUTED
}
/*
* This means the requested block number is out of range.
*/
return 0;
3000fbb8: 83a00000 movhi r0, #0 <== NOT EXECUTED
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
3000fbbc: 8affffdd bhi 3000fb38 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
3000fbc0: e0677001 rsb r7, r7, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000fbc4: e1a00007 mov r0, r7 <== NOT EXECUTED 3000fbc8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000fbcc: eb00135e bl 3001494c <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbd0: e1a01004 mov r1, r4 <== NOT EXECUTED
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
3000fbd4: e1a0a000 mov sl, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbd8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000fbdc: eb001314 bl 30014834 <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbe0: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbe4: e1a08000 mov r8, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbe8: eb001311 bl 30014834 <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000fbec: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
3000fbf0: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000fbf4: e1a00008 mov r0, r8 <== NOT EXECUTED 3000fbf8: eb001353 bl 3001494c <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
3000fbfc: e3560000 cmp r6, #0 <== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
3000fc00: e1a04000 mov r4, r0 <== NOT EXECUTED
p = info->triply_indirect;
3000fc04: e5950060 ldr r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
3000fc08: 0a000029 beq 3000fcb4 <IMFS_memfile_get_block_pointer+0x1bc><== NOT EXECUTED
if ( !p ) {
3000fc0c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fc10: 0a000035 beq 3000fcec <IMFS_memfile_get_block_pointer+0x1f4><== NOT EXECUTED
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
3000fc14: e7903107 ldr r3, [r0, r7, lsl #2] <== NOT EXECUTED 3000fc18: e0807107 add r7, r0, r7, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
3000fc1c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fc20: 0a00002c beq 3000fcd8 <IMFS_memfile_get_block_pointer+0x1e0><== NOT EXECUTED
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
3000fc24: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED 3000fc28: e0834104 add r4, r3, r4, lsl #2 <== NOT EXECUTED
if ( !p2 ) {
3000fc2c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fc30: 0a00000d beq 3000fc6c <IMFS_memfile_get_block_pointer+0x174><== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
3000fc34: e080010a add r0, r0, sl, lsl #2 <== NOT EXECUTED 3000fc38: eaffffbe b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000fc3c: e58d1000 str r1, [sp] 3000fc40: ebffff9f bl 3000fac4 <memfile_alloc_block>
if ( !p )
3000fc44: e3500000 cmp r0, #0 3000fc48: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
3000fc4c: 15850058 strne r0, [r5, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
3000fc50: 1affffb7 bne 3000fb34 <IMFS_memfile_get_block_pointer+0x3c>
3000fc54: eaffffb7 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3000fc58: ebffff99 bl 3000fac4 <memfile_alloc_block>
if ( !p1 )
3000fc5c: e3500000 cmp r0, #0
return 0;
p[ doubly ] = (block_p) p1;
3000fc60: 15840000 strne r0, [r4]
p = (block_p *)p[ doubly ];
if ( !p )
return 0;
return (block_p *)&p[ singly ];
3000fc64: 10800108 addne r0, r0, r8, lsl #2 3000fc68: eaffffb2 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40>
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
3000fc6c: ebffff94 bl 3000fac4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
3000fc70: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
3000fc74: 15840000 strne r0, [r4] <== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
3000fc78: 1080010a addne r0, r0, sl, lsl #2 <== NOT EXECUTED 3000fc7c: eaffffad b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
return (block_p *)&p1[ singly ];
}
if ( !p )
3000fc80: e3530000 cmp r3, #0
3000fc84: 1a000001 bne 3000fc90 <IMFS_memfile_get_block_pointer+0x198>
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
return 0;
3000fc88: e1a00003 mov r0, r3 <== NOT EXECUTED 3000fc8c: eaffffa9 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
}
if ( !p )
return 0;
p = (block_p *)p[ doubly ];
3000fc90: e7930100 ldr r0, [r3, r0, lsl #2]
if ( !p )
3000fc94: e3500000 cmp r0, #0
return 0;
return (block_p *)&p[ singly ];
3000fc98: 10800108 addne r0, r0, r8, lsl #2 3000fc9c: eaffffa5 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40>
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000fca0: ebffff87 bl 3000fac4 <memfile_alloc_block>
if ( !p )
3000fca4: e2503000 subs r3, r0, #0
3000fca8: 0afffff6 beq 3000fc88 <IMFS_memfile_get_block_pointer+0x190>
return 0;
info->doubly_indirect = p;
3000fcac: e585305c str r3, [r5, #92] ; 0x5c 3000fcb0: eaffffb4 b 3000fb88 <IMFS_memfile_get_block_pointer+0x90>
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
3000fcb4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fcb8: 0affff9e beq 3000fb38 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
p1 = (block_p *) p[ triply ];
3000fcbc: e7900107 ldr r0, [r0, r7, lsl #2] <== NOT EXECUTED
if ( !p1 )
3000fcc0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fcc4: 0affff9b beq 3000fb38 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
3000fcc8: e7900104 ldr r0, [r0, r4, lsl #2] <== NOT EXECUTED
if ( !p2 )
3000fccc: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
3000fcd0: 1080010a addne r0, r0, sl, lsl #2 <== NOT EXECUTED 3000fcd4: eaffff97 b 3000fb38 <IMFS_memfile_get_block_pointer+0x40> <== NOT EXECUTED
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
3000fcd8: ebffff79 bl 3000fac4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
3000fcdc: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3000fce0: 0affffe8 beq 3000fc88 <IMFS_memfile_get_block_pointer+0x190><== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
3000fce4: e5873000 str r3, [r7] <== NOT EXECUTED 3000fce8: eaffffcd b 3000fc24 <IMFS_memfile_get_block_pointer+0x12c> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
3000fcec: ebffff74 bl 3000fac4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
3000fcf0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fcf4: 0affff8f beq 3000fb38 <IMFS_memfile_get_block_pointer+0x40><== NOT EXECUTED
return 0;
info->triply_indirect = p;
3000fcf8: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED 3000fcfc: eaffffc4 b 3000fc14 <IMFS_memfile_get_block_pointer+0x11c> <== NOT EXECUTED
300089dc <IMFS_memfile_maximum_size>:
* using the IMFS memory file type.
*
*/
int IMFS_memfile_maximum_size( void )
{
return IMFS_MEMFILE_MAXIMUM_SIZE;
300089dc: e59f3018 ldr r3, [pc, #24] ; 300089fc <IMFS_memfile_maximum_size+0x20><== NOT EXECUTED 300089e0: e5932000 ldr r2, [r3] <== NOT EXECUTED 300089e4: e1a03122 lsr r3, r2, #2 <== NOT EXECUTED 300089e8: e0203393 mla r0, r3, r3, r3 <== NOT EXECUTED 300089ec: e0233390 mla r3, r0, r3, r3 <== NOT EXECUTED 300089f0: e2430001 sub r0, r3, #1 <== NOT EXECUTED
}
300089f4: e0000092 mul r0, r2, r0 <== NOT EXECUTED 300089f8: e12fff1e bx lr <== NOT EXECUTED
3000fd04 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000fd04: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000fd08: e1a09000 mov r9, r0
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3000fd0c: e590004c ldr r0, [r0, #76] ; 0x4c
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000fd10: e24dd014 sub sp, sp, #20
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3000fd14: e3500006 cmp r0, #6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
3000fd18: e1a07001 mov r7, r1 3000fd1c: e1a08002 mov r8, r2 3000fd20: e1a0b003 mov fp, r3 3000fd24: e59d5038 ldr r5, [sp, #56] ; 0x38
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3000fd28: 0a00005c beq 3000fea0 <IMFS_memfile_read+0x19c>
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
3000fd2c: e5992054 ldr r2, [r9, #84] ; 0x54
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
3000fd30: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
3000fd34: e3a01000 mov r1, #0 3000fd38: e1510002 cmp r1, r2 3000fd3c: e5992050 ldr r2, [r9, #80] ; 0x50
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
3000fd40: e0851007 add r1, r5, r7
if ( last_byte > the_jnode->info.file.size )
3000fd44: da00003d ble 3000fe40 <IMFS_memfile_read+0x13c>
my_length = the_jnode->info.file.size - start;
3000fd48: e0635002 rsb r5, r3, r2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fd4c: e59f61b8 ldr r6, [pc, #440] ; 3000ff0c <IMFS_memfile_read+0x208>
3000fd50: e1a00007 mov r0, r7
3000fd54: e5964000 ldr r4, [r6]
3000fd58: e1a01008 mov r1, r8
3000fd5c: e1a02004 mov r2, r4
3000fd60: e1a03fc2 asr r3, r2, #31
3000fd64: e98d000c stmib sp, {r2, r3}
3000fd68: eb001684 bl 30015780 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fd6c: e99d000c ldmib sp, {r2, r3}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fd70: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fd74: e1a01008 mov r1, r8 3000fd78: e1a00007 mov r0, r7 3000fd7c: eb001552 bl 300152cc <__divdi3>
if ( start_offset ) {
3000fd80: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
3000fd84: e1a07000 mov r7, r0
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
3000fd88: 01a0800b moveq r8, fp
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
3000fd8c: 0a000014 beq 3000fde4 <IMFS_memfile_read+0xe0>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000fd90: e1a00009 mov r0, r9 3000fd94: e1a01007 mov r1, r7 3000fd98: e3a02000 mov r2, #0 3000fd9c: ebffff55 bl 3000faf8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000fda0: e3500000 cmp r0, #0
3000fda4: 0a000023 beq 3000fe38 <IMFS_memfile_read+0x134>
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
3000fda8: e5901000 ldr r1, [r0]
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
3000fdac: e06a3004 rsb r3, sl, r4 3000fdb0: e1550003 cmp r5, r3 3000fdb4: 31a03005 movcc r3, r5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
3000fdb8: e081100a add r1, r1, sl 3000fdbc: e1a02003 mov r2, r3 3000fdc0: e1a0000b mov r0, fp 3000fdc4: e58d3000 str r3, [sp] 3000fdc8: eb000704 bl 300119e0 <memcpy>
dest += to_copy;
3000fdcc: e59d3000 ldr r3, [sp]
block++;
my_length -= to_copy;
3000fdd0: e5964000 ldr r4, [r6]
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
dest += to_copy;
3000fdd4: e08b8003 add r8, fp, r3
block++;
3000fdd8: e2877001 add r7, r7, #1
my_length -= to_copy;
3000fddc: e0635005 rsb r5, r3, r5
copied += to_copy;
3000fde0: e1a0a003 mov sl, r3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000fde4: e1550004 cmp r5, r4
3000fde8: 2a000008 bcs 3000fe10 <IMFS_memfile_read+0x10c>
3000fdec: ea000017 b 3000fe50 <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
3000fdf0: e5931000 ldr r1, [r3] 3000fdf4: eb0006f9 bl 300119e0 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000fdf8: e5963000 ldr r3, [r6]
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
3000fdfc: e0888004 add r8, r8, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000fe00: e1530005 cmp r3, r5
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
block++;
3000fe04: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
3000fe08: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3000fe0c: 8a00000f bhi 3000fe50 <IMFS_memfile_read+0x14c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000fe10: e3a02000 mov r2, #0 3000fe14: e1a01007 mov r1, r7 3000fe18: e1a00009 mov r0, r9 3000fe1c: ebffff35 bl 3000faf8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000fe20: e2503000 subs r3, r0, #0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
3000fe24: e1a02004 mov r2, r4
dest += to_copy;
block++;
my_length -= to_copy;
3000fe28: e0645005 rsb r5, r4, r5
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
3000fe2c: e1a00008 mov r0, r8
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
3000fe30: 1affffee bne 3000fdf0 <IMFS_memfile_read+0xec>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
return copied;
3000fe34: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_update_atime( the_jnode );
return copied;
}
3000fe38: e28dd014 add sp, sp, #20
3000fe3c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 3000fe40: 1affffc1 bne 3000fd4c <IMFS_memfile_read+0x48>
3000fe44: e1510002 cmp r1, r2
3000fe48: 9affffbf bls 3000fd4c <IMFS_memfile_read+0x48>
3000fe4c: eaffffbd b 3000fd48 <IMFS_memfile_read+0x44>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
3000fe50: e3550000 cmp r5, #0
3000fe54: 0a00000a beq 3000fe84 <IMFS_memfile_read+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3000fe58: e1a00009 mov r0, r9 3000fe5c: e1a01007 mov r1, r7 3000fe60: e3a02000 mov r2, #0 3000fe64: ebffff23 bl 3000faf8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3000fe68: e2503000 subs r3, r0, #0
3000fe6c: 0afffff0 beq 3000fe34 <IMFS_memfile_read+0x130>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
3000fe70: e1a00008 mov r0, r8 3000fe74: e5931000 ldr r1, [r3] 3000fe78: e1a02005 mov r2, r5 3000fe7c: eb0006d7 bl 300119e0 <memcpy>
copied += my_length;
3000fe80: e08aa005 add sl, sl, r5
}
IMFS_update_atime( the_jnode );
3000fe84: e28d000c add r0, sp, #12 3000fe88: e3a01000 mov r1, #0 3000fe8c: ebffd9aa bl 3000653c <gettimeofday> 3000fe90: e59d300c ldr r3, [sp, #12]
return copied;
3000fe94: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000fe98: e5893040 str r3, [r9, #64] ; 0x40
return copied;
3000fe9c: eaffffe5 b 3000fe38 <IMFS_memfile_read+0x134>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
3000fea0: e2894050 add r4, r9, #80 ; 0x50
3000fea4: e8940018 ldm r4, {r3, r4}
3000fea8: e1a00003 mov r0, r3
3000feac: e1a01004 mov r1, r4
3000feb0: e3a02000 mov r2, #0
3000feb4: e0500007 subs r0, r0, r7
3000feb8: e0c11008 sbc r1, r1, r8
3000febc: e1520001 cmp r2, r1
my_length = length;
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
3000fec0: e5992058 ldr r2, [r9, #88] ; 0x58
if (my_length > (the_jnode->info.linearfile.size - start))
3000fec4: da00000b ble 3000fef8 <IMFS_memfile_read+0x1f4>
my_length = the_jnode->info.linearfile.size - start;
3000fec8: e067a003 rsb sl, r7, r3
memcpy(dest, &file_ptr[start], my_length);
3000fecc: e0821007 add r1, r2, r7 3000fed0: e1a0000b mov r0, fp 3000fed4: e1a0200a mov r2, sl 3000fed8: eb0006c0 bl 300119e0 <memcpy>
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000fedc: e28d000c add r0, sp, #12 3000fee0: e3a01000 mov r1, #0 3000fee4: ebffd994 bl 3000653c <gettimeofday> 3000fee8: e59d300c ldr r3, [sp, #12]
return copied;
3000feec: e1a0000a mov r0, sl
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
3000fef0: e5893040 str r3, [r9, #64] ; 0x40 3000fef4: eaffffcf b 3000fe38 <IMFS_memfile_read+0x134>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
3000fef8: 1a000001 bne 3000ff04 <IMFS_memfile_read+0x200>
3000fefc: e1550000 cmp r5, r0
3000ff00: 8afffff0 bhi 3000fec8 <IMFS_memfile_read+0x1c4>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
3000ff04: e1a0a005 mov sl, r5 <== NOT EXECUTED 3000ff08: eaffffef b 3000fecc <IMFS_memfile_read+0x1c8> <== NOT EXECUTED
3000fff0 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
3000fff0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
3000fff4: e59f6130 ldr r6, [pc, #304] ; 3001012c <IMFS_memfile_remove+0x13c>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
3000fff8: e5903058 ldr r3, [r0, #88] ; 0x58
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
3000fffc: e5967000 ldr r7, [r6]
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
30010000: e3530000 cmp r3, #0
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
30010004: e1a0a000 mov sl, r0
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
30010008: e1a07127 lsr r7, r7, #2
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
3001000c: 12800058 addne r0, r0, #88 ; 0x58 30010010: 11a01007 movne r1, r7 30010014: 1bffffe0 blne 3000ff9c <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
30010018: e59a305c ldr r3, [sl, #92] ; 0x5c 3001001c: e3530000 cmp r3, #0
30010020: 0a000014 beq 30010078 <IMFS_memfile_remove+0x88>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
30010024: e5962000 ldr r2, [r6] <== NOT EXECUTED 30010028: e1b02122 lsrs r2, r2, #2 <== NOT EXECUTED 3001002c: 0a00000e beq 3001006c <IMFS_memfile_remove+0x7c> <== NOT EXECUTED 30010030: e3a02000 mov r2, #0 <== NOT EXECUTED 30010034: e1a04002 mov r4, r2 <== NOT EXECUTED 30010038: ea000000 b 30010040 <IMFS_memfile_remove+0x50> <== NOT EXECUTED 3001003c: e59a305c ldr r3, [sl, #92] ; 0x5c <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
30010040: e7931102 ldr r1, [r3, r2, lsl #2] <== NOT EXECUTED 30010044: e1a02102 lsl r2, r2, #2 <== NOT EXECUTED 30010048: e3510000 cmp r1, #0 <== NOT EXECUTED
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3001004c: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
30010050: e1a01007 mov r1, r7 <== NOT EXECUTED 30010054: e0830002 add r0, r3, r2 <== NOT EXECUTED 30010058: 1bffffcf blne 3000ff9c <memfile_free_blocks_in_table> <== NOT EXECUTED
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
3001005c: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010060: e1a02004 mov r2, r4 <== NOT EXECUTED 30010064: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED 30010068: 3afffff3 bcc 3001003c <IMFS_memfile_remove+0x4c> <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
3001006c: e28a005c add r0, sl, #92 ; 0x5c <== NOT EXECUTED 30010070: e1a01007 mov r1, r7 <== NOT EXECUTED 30010074: ebffffc8 bl 3000ff9c <memfile_free_blocks_in_table> <== NOT EXECUTED
}
if ( info->triply_indirect ) {
30010078: e59a0060 ldr r0, [sl, #96] ; 0x60 3001007c: e3500000 cmp r0, #0
30010080: 0a000027 beq 30010124 <IMFS_memfile_remove+0x134>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
30010084: e5963000 ldr r3, [r6] <== NOT EXECUTED 30010088: e1b03123 lsrs r3, r3, #2 <== NOT EXECUTED 3001008c: 0a000021 beq 30010118 <IMFS_memfile_remove+0x128> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
30010090: e5905000 ldr r5, [r0] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010094: e3550000 cmp r5, #0 <== NOT EXECUTED
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
30010098: 13a09000 movne r9, #0 <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
3001009c: 11a08009 movne r8, r9 <== NOT EXECUTED 300100a0: 0a00001c beq 30010118 <IMFS_memfile_remove+0x128> <== NOT EXECUTED
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
300100a4: e3530000 cmp r3, #0 <== NOT EXECUTED 300100a8: 0a00000d beq 300100e4 <IMFS_memfile_remove+0xf4> <== NOT EXECUTED 300100ac: e3a00000 mov r0, #0 <== NOT EXECUTED 300100b0: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( p[j] ) {
300100b4: e7953100 ldr r3, [r5, r0, lsl #2] <== NOT EXECUTED 300100b8: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 300100bc: e3530000 cmp r3, #0 <== NOT EXECUTED
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
300100c0: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
300100c4: e1a01007 mov r1, r7 <== NOT EXECUTED 300100c8: e0850000 add r0, r5, r0 <== NOT EXECUTED 300100cc: 1bffffb2 blne 3000ff9c <memfile_free_blocks_in_table> <== NOT EXECUTED
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
300100d0: e5963000 ldr r3, [r6] <== NOT EXECUTED 300100d4: e1a00004 mov r0, r4 <== NOT EXECUTED 300100d8: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED 300100dc: 3afffff4 bcc 300100b4 <IMFS_memfile_remove+0xc4> <== NOT EXECUTED 300100e0: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
300100e4: e0800009 add r0, r0, r9 <== NOT EXECUTED 300100e8: e1a01007 mov r1, r7 <== NOT EXECUTED 300100ec: ebffffaa bl 3000ff9c <memfile_free_blocks_in_table> <== NOT EXECUTED
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
300100f0: e5963000 ldr r3, [r6] <== NOT EXECUTED 300100f4: e2888001 add r8, r8, #1 <== NOT EXECUTED 300100f8: e1a03123 lsr r3, r3, #2 <== NOT EXECUTED 300100fc: e1530008 cmp r3, r8 <== NOT EXECUTED 30010100: 9a000004 bls 30010118 <IMFS_memfile_remove+0x128> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
30010104: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010108: e1a09108 lsl r9, r8, #2 <== NOT EXECUTED
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
3001010c: e7905108 ldr r5, [r0, r8, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
30010110: e3550000 cmp r5, #0 <== NOT EXECUTED 30010114: 1affffe2 bne 300100a4 <IMFS_memfile_remove+0xb4> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
30010118: e28a0060 add r0, sl, #96 ; 0x60 <== NOT EXECUTED 3001011c: e1a01007 mov r1, r7 <== NOT EXECUTED 30010120: ebffff9d bl 3000ff9c <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
30010124: e3a00000 mov r0, #0
30010128: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
30010130 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
30010130: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010134: e3a02000 mov r2, #0 <== NOT EXECUTED 30010138: ebfffe6e bl 3000faf8 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
3001013c: e3a02000 mov r2, #0 <== NOT EXECUTED
)
{
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
30010140: e1a03000 mov r3, r0 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
30010144: e5900000 ldr r0, [r0] <== NOT EXECUTED
*block_ptr = 0;
30010148: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
3001014c: ebffff8a bl 3000ff7c <memfile_free_block> <== NOT EXECUTED
return 1;
}
30010150: e3a00001 mov r0, #1 <== NOT EXECUTED
30010154: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001028c <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3001028c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30010290: e1a09000 mov r9, r0
30010294: e24dd010 sub sp, sp, #16
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
30010298: e5900054 ldr r0, [r0, #84] ; 0x54
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
3001029c: e59db034 ldr fp, [sp, #52] ; 0x34
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
300102a0: e3500000 cmp r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
300102a4: e1a06001 mov r6, r1 300102a8: e1a07002 mov r7, r2 300102ac: e1a08003 mov r8, r3
/*
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
300102b0: e08b1001 add r1, fp, r1
if ( last_byte > the_jnode->info.file.size ) {
300102b4: ba000054 blt 3001040c <IMFS_memfile_write+0x180>
300102b8: 0a000050 beq 30010400 <IMFS_memfile_write+0x174>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
300102bc: e59f5170 ldr r5, [pc, #368] ; 30010434 <IMFS_memfile_write+0x1a8>
300102c0: e1a00006 mov r0, r6
300102c4: e5954000 ldr r4, [r5]
300102c8: e1a01007 mov r1, r7
300102cc: e1a02004 mov r2, r4
300102d0: e1a03fc2 asr r3, r2, #31
300102d4: e88d000c stm sp, {r2, r3}
300102d8: eb001528 bl 30015780 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
300102dc: e89d000c ldm sp, {r2, r3}
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
300102e0: e1a0a000 mov sl, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
300102e4: e1a01007 mov r1, r7 300102e8: e1a00006 mov r0, r6 300102ec: eb0013f6 bl 300152cc <__divdi3>
if ( start_offset ) {
300102f0: e35a0000 cmp sl, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
300102f4: e1a07000 mov r7, r0
if ( start_offset ) {
300102f8: 01a0600b moveq r6, fp
300102fc: 1a000016 bne 3001035c <IMFS_memfile_write+0xd0>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010300: e1560004 cmp r6, r4
30010304: 2a000008 bcs 3001032c <IMFS_memfile_write+0xa0>
30010308: ea000027 b 300103ac <IMFS_memfile_write+0x120>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
3001030c: e5900000 ldr r0, [r0] 30010310: eb0005b2 bl 300119e0 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010314: e5953000 ldr r3, [r5]
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
30010318: e0888004 add r8, r8, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
3001031c: e1530006 cmp r3, r6
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
block++;
30010320: e2877001 add r7, r7, #1
* IMFS_memfile_write * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write(
30010324: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
30010328: 8a00001f bhi 300103ac <IMFS_memfile_write+0x120>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3001032c: e1a01007 mov r1, r7 30010330: e3a02000 mov r2, #0 30010334: e1a00009 mov r0, r9 30010338: ebfffdee bl 3000faf8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
3001033c: e3500000 cmp r0, #0
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
30010340: e1a01008 mov r1, r8 30010344: e1a02004 mov r2, r4
src += to_copy;
block++;
my_length -= to_copy;
30010348: e0646006 rsb r6, r4, r6
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
3001034c: 1affffee bne 3001030c <IMFS_memfile_write+0x80>
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
30010350: e1a0000a mov r0, sl <== NOT EXECUTED
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
30010354: e28dd010 add sp, sp, #16
30010358: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
3001035c: e1a00009 mov r0, r9 <== NOT EXECUTED 30010360: e1a01007 mov r1, r7 <== NOT EXECUTED 30010364: e3a02000 mov r2, #0 <== NOT EXECUTED 30010368: ebfffde2 bl 3000faf8 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
if ( !block_ptr )
3001036c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010370: 0afffff7 beq 30010354 <IMFS_memfile_write+0xc8> <== NOT EXECUTED
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
30010374: e06a4004 rsb r4, sl, r4 <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
30010378: e5900000 ldr r0, [r0] <== NOT EXECUTED
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
3001037c: e154000b cmp r4, fp <== NOT EXECUTED 30010380: 21a0400b movcs r4, fp <== NOT EXECUTED
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
30010384: e080000a add r0, r0, sl <== NOT EXECUTED 30010388: e1a01008 mov r1, r8 <== NOT EXECUTED 3001038c: e1a02004 mov r2, r4 <== NOT EXECUTED 30010390: eb000592 bl 300119e0 <memcpy> <== NOT EXECUTED
src += to_copy;
30010394: e0888004 add r8, r8, r4 <== NOT EXECUTED
block++;
my_length -= to_copy;
30010398: e064600b rsb r6, r4, fp <== NOT EXECUTED
copied += to_copy;
3001039c: e1a0a004 mov sl, r4 <== NOT EXECUTED
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
300103a0: e2877001 add r7, r7, #1 <== NOT EXECUTED
my_length -= to_copy;
copied += to_copy;
300103a4: e5954000 ldr r4, [r5] <== NOT EXECUTED 300103a8: eaffffd4 b 30010300 <IMFS_memfile_write+0x74> <== NOT EXECUTED
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
300103ac: e3560000 cmp r6, #0
300103b0: 0a00000a beq 300103e0 <IMFS_memfile_write+0x154>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
300103b4: e1a00009 mov r0, r9 300103b8: e1a01007 mov r1, r7 300103bc: e3a02000 mov r2, #0 300103c0: ebfffdcc bl 3000faf8 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
300103c4: e3500000 cmp r0, #0
300103c8: 0affffe0 beq 30010350 <IMFS_memfile_write+0xc4>
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
300103cc: e5900000 ldr r0, [r0] 300103d0: e1a01008 mov r1, r8 300103d4: e1a02006 mov r2, r6 300103d8: eb000580 bl 300119e0 <memcpy>
my_length = 0;
copied += to_copy;
300103dc: e08aa006 add sl, sl, r6
}
IMFS_mtime_ctime_update( the_jnode );
300103e0: e28d0008 add r0, sp, #8 300103e4: e3a01000 mov r1, #0 300103e8: ebffd853 bl 3000653c <gettimeofday> 300103ec: e59d3008 ldr r3, [sp, #8]
return copied;
300103f0: e1a0000a mov r0, sl
memcpy( &(*block_ptr)[ 0 ], src, my_length );
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
300103f4: e5893044 str r3, [r9, #68] ; 0x44 300103f8: e5893048 str r3, [r9, #72] ; 0x48
return copied;
300103fc: eaffffd4 b 30010354 <IMFS_memfile_write+0xc8>
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
30010400: e5993050 ldr r3, [r9, #80] ; 0x50 30010404: e1530001 cmp r3, r1
30010408: 2affffab bcs 300102bc <IMFS_memfile_write+0x30>
status = IMFS_memfile_extend( the_jnode, last_byte );
3001040c: e1a00009 mov r0, r9 30010410: e3a02000 mov r2, #0 30010414: ebffff4f bl 30010158 <IMFS_memfile_extend>
if ( status )
30010418: e3500000 cmp r0, #0
3001041c: 0affffa6 beq 300102bc <IMFS_memfile_write+0x30>
rtems_set_errno_and_return_minus_one( ENOSPC );
30010420: eb000340 bl 30011128 <__errno> <== NOT EXECUTED 30010424: e3a0301c mov r3, #28 <== NOT EXECUTED 30010428: e5803000 str r3, [r0] <== NOT EXECUTED 3001042c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30010430: eaffffc7 b 30010354 <IMFS_memfile_write+0xc8> <== NOT EXECUTED
30005e0c <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30005e0c: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30005e10: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
30005e14: e593204c ldr r2, [r3, #76] ; 0x4c 30005e18: e3520001 cmp r2, #1
30005e1c: 1a000002 bne 30005e2c <IMFS_mount+0x20>
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
30005e20: e583005c str r0, [r3, #92] ; 0x5c
return 0;
30005e24: e3a00000 mov r0, #0
}
30005e28: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
30005e2c: eb002cbd bl 30011128 <__errno> <== NOT EXECUTED
30005e30: e3a03014 mov r3, #20 <== NOT EXECUTED
30005e34: e5803000 str r3, [r0] <== NOT EXECUTED
30005e38: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e3c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300087b0 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
300087b0: e92d4030 push {r4, r5, lr}
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
300087b4: e59f50f8 ldr r5, [pc, #248] ; 300088b4 <IMFS_print_jnode+0x104>
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
300087b8: e1a04000 mov r4, r0
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
300087bc: e5953000 ldr r3, [r5] 300087c0: e280000c add r0, r0, #12 300087c4: e5931008 ldr r1, [r3, #8] 300087c8: eb003493 bl 30015a1c <fputs>
switch( the_jnode->type ) {
300087cc: e594204c ldr r2, [r4, #76] ; 0x4c 300087d0: e2423001 sub r3, r2, #1 300087d4: e3530006 cmp r3, #6 300087d8: 979ff103 ldrls pc, [pc, r3, lsl #2]
300087dc: ea000023 b 30008870 <IMFS_print_jnode+0xc0> <== NOT EXECUTED 300087e0: 30008884 .word 0x30008884 <== NOT EXECUTED 300087e4: 30008898 .word 0x30008898 <== NOT EXECUTED 300087e8: 300087fc .word 0x300087fc <== NOT EXECUTED 300087ec: 300087fc .word 0x300087fc <== NOT EXECUTED 300087f0: 30008834 .word 0x30008834 <== NOT EXECUTED 300087f4: 30008854 .word 0x30008854 <== NOT EXECUTED 300087f8: 30008818 .word 0x30008818 <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
300087fc: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008800: e59f00b0 ldr r0, [pc, #176] ; 300088b8 <IMFS_print_jnode+0x108><== NOT EXECUTED 30008804: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008808: e3a01001 mov r1, #1 <== NOT EXECUTED 3000880c: e3a02013 mov r2, #19 <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
30008810: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
30008814: ea0037b0 b 300166dc <fwrite> <== NOT EXECUTED
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
30008818: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000881c: e59f0098 ldr r0, [pc, #152] ; 300088bc <IMFS_print_jnode+0x10c><== NOT EXECUTED 30008820: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008824: e3a01001 mov r1, #1 <== NOT EXECUTED 30008828: e3a02012 mov r2, #18 <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
}
3000882c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
30008830: ea0037a9 b 300166dc <fwrite> <== NOT EXECUTED
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
30008834: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008838: e59f1080 ldr r1, [pc, #128] ; 300088c0 <IMFS_print_jnode+0x110><== NOT EXECUTED 3000883c: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 30008840: e5942050 ldr r2, [r4, #80] ; 0x50 <== NOT EXECUTED 30008844: eb00341f bl 300158c8 <fprintf> <== NOT EXECUTED
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
30008848: e59f0074 ldr r0, [pc, #116] ; 300088c4 <IMFS_print_jnode+0x114>
}
3000884c: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
return;
}
puts("");
30008850: ea003b83 b 30017664 <puts>
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
30008854: e5953000 ldr r3, [r5] 30008858: e59f1068 ldr r1, [pc, #104] ; 300088c8 <IMFS_print_jnode+0x118> 3000885c: e5930008 ldr r0, [r3, #8] 30008860: e5942050 ldr r2, [r4, #80] ; 0x50 30008864: e5943058 ldr r3, [r4, #88] ; 0x58 30008868: eb003416 bl 300158c8 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
3000886c: eafffff5 b 30008848 <IMFS_print_jnode+0x98>
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
30008870: e5953000 ldr r3, [r5] <== NOT EXECUTED 30008874: e59f1050 ldr r1, [pc, #80] ; 300088cc <IMFS_print_jnode+0x11c><== NOT EXECUTED 30008878: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
return;
}
puts("");
}
3000887c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
30008880: ea003410 b 300158c8 <fprintf> <== NOT EXECUTED
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
30008884: e5953000 ldr r3, [r5] 30008888: e3a0002f mov r0, #47 ; 0x2f 3000888c: e5931008 ldr r1, [r3, #8] 30008890: eb00342c bl 30015948 <fputc>
break;
30008894: eaffffeb b 30008848 <IMFS_print_jnode+0x98>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
30008898: e5953000 ldr r3, [r5] 3000889c: e59f102c ldr r1, [pc, #44] ; 300088d0 <IMFS_print_jnode+0x120> 300088a0: e5930008 ldr r0, [r3, #8] 300088a4: e5942050 ldr r2, [r4, #80] ; 0x50 300088a8: e5943054 ldr r3, [r4, #84] ; 0x54 300088ac: eb003405 bl 300158c8 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
300088b0: eaffffe4 b 30008848 <IMFS_print_jnode+0x98>
30005e4c <IMFS_readlink>:
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005e4c: e3520000 cmp r2, #0 <== NOT EXECUTED
ssize_t IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
30005e50: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
IMFS_jnode_t *node;
ssize_t i;
node = loc->node_access;
30005e54: e5904000 ldr r4, [r0] <== NOT EXECUTED
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005e58: 01a00002 moveq r0, r2 <== NOT EXECUTED 30005e5c: 0a000010 beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e60: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 30005e64: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30005e68: e3530000 cmp r3, #0 <== NOT EXECUTED 30005e6c: 01a00003 moveq r0, r3 <== NOT EXECUTED 30005e70: 0a00000b beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e74: e3a0c000 mov ip, #0 <== NOT EXECUTED 30005e78: e1a0000c mov r0, ip <== NOT EXECUTED 30005e7c: ea000003 b 30005e90 <IMFS_readlink+0x44> <== NOT EXECUTED 30005e80: e5943050 ldr r3, [r4, #80] ; 0x50 <== NOT EXECUTED 30005e84: e7d33000 ldrb r3, [r3, r0] <== NOT EXECUTED 30005e88: e3530000 cmp r3, #0 <== NOT EXECUTED 30005e8c: 0a000004 beq 30005ea4 <IMFS_readlink+0x58> <== NOT EXECUTED 30005e90: e2800001 add r0, r0, #1 <== NOT EXECUTED 30005e94: e1500002 cmp r0, r2 <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
30005e98: e7c1300c strb r3, [r1, ip] <== NOT EXECUTED
node = loc->node_access;
IMFS_assert( node->type == IMFS_SYM_LINK );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
30005e9c: e1a0c000 mov ip, r0 <== NOT EXECUTED 30005ea0: 3afffff6 bcc 30005e80 <IMFS_readlink+0x34> <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
return i;
}
30005ea4: e8bd0010 pop {r4} <== NOT EXECUTED
30005ea8: e12fff1e bx lr <== NOT EXECUTED
30005eac <IMFS_rename>:
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
30005eac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
30005eb0: e5914000 ldr r4, [r1] <== NOT EXECUTED
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
30005eb4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
30005eb8: e1a01003 mov r1, r3 <== NOT EXECUTED
rtems_filesystem_location_info_t *old_parent_loc, /* IN */
rtems_filesystem_location_info_t *old_loc, /* IN */
rtems_filesystem_location_info_t *new_parent_loc, /* IN */
const char *new_name /* IN */
)
{
30005ebc: e1a05002 mov r5, r2 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
30005ec0: e284000c add r0, r4, #12 <== NOT EXECUTED 30005ec4: e3a02020 mov r2, #32 <== NOT EXECUTED 30005ec8: eb003098 bl 30012130 <strncpy> <== NOT EXECUTED
if ( the_jnode->Parent != NULL )
30005ecc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30005ed0: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
30005ed4: 11a00004 movne r0, r4 <== NOT EXECUTED 30005ed8: 1b001188 blne 3000a500 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
30005edc: e5953000 ldr r3, [r5] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
30005ee0: e1a01004 mov r1, r4 <== NOT EXECUTED 30005ee4: e2830050 add r0, r3, #80 ; 0x50 <== NOT EXECUTED
the_jnode->Parent = new_parent;
30005ee8: e5843008 str r3, [r4, #8] <== NOT EXECUTED 30005eec: eb001178 bl 3000a4d4 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
30005ef0: e1a0000d mov r0, sp <== NOT EXECUTED 30005ef4: e3a01000 mov r1, #0 <== NOT EXECUTED 30005ef8: eb00018f bl 3000653c <gettimeofday> <== NOT EXECUTED 30005efc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return 0;
}
30005f00: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
30005f04: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
30005f08: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30005f0c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000e378 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
3000e378: e5903000 ldr r3, [r0]
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3000e37c: e92d40f0 push {r4, r5, r6, r7, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
3000e380: e593204c ldr r2, [r3, #76] ; 0x4c 3000e384: e2422002 sub r2, r2, #2 3000e388: e3520005 cmp r2, #5 3000e38c: 979ff102 ldrls pc, [pc, r2, lsl #2]
3000e390: ea000026 b 3000e430 <IMFS_stat+0xb8> <== NOT EXECUTED 3000e394: 3000e41c .word 0x3000e41c <== NOT EXECUTED 3000e398: 3000e430 .word 0x3000e430 <== NOT EXECUTED 3000e39c: 3000e3ac .word 0x3000e3ac <== NOT EXECUTED 3000e3a0: 3000e444 .word 0x3000e444 <== NOT EXECUTED 3000e3a4: 3000e444 .word 0x3000e444 <== NOT EXECUTED 3000e3a8: 3000e3ac .word 0x3000e3ac <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
3000e3ac: e3a04000 mov r4, #0 <== NOT EXECUTED 3000e3b0: e3a05000 mov r5, #0 <== NOT EXECUTED 3000e3b4: e5814020 str r4, [r1, #32] <== NOT EXECUTED 3000e3b8: e5815024 str r5, [r1, #36] ; 0x24 <== NOT EXECUTED
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
3000e3bc: e5902010 ldr r2, [r0, #16]
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
3000e3c0: e1d373b4 ldrh r7, [r3, #52] ; 0x34
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000e3c4: e5922034 ldr r2, [r2, #52] ; 0x34
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
3000e3c8: e5930044 ldr r0, [r3, #68] ; 0x44
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000e3cc: e5935030 ldr r5, [r3, #48] ; 0x30
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
3000e3d0: e5934038 ldr r4, [r3, #56] ; 0x38
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
3000e3d4: e5926000 ldr r6, [r2]
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
3000e3d8: e593c040 ldr ip, [r3, #64] ; 0x40
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
3000e3dc: e5932048 ldr r2, [r3, #72] ; 0x48
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
3000e3e0: e1c171b0 strh r7, [r1, #16]
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
3000e3e4: e59f706c ldr r7, [pc, #108] ; 3000e458 <IMFS_stat+0xe0> 3000e3e8: e5817000 str r7, [r1]
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
3000e3ec: e1d373bc ldrh r7, [r3, #60] ; 0x3c
buf->st_gid = the_jnode->st_gid;
3000e3f0: e1d333be ldrh r3, [r3, #62] ; 0x3e
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
3000e3f4: e1c171b2 strh r7, [r1, #18]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
3000e3f8: e5810030 str r0, [r1, #48] ; 0x30
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
3000e3fc: e5816004 str r6, [r1, #4]
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
3000e400: e1c131b4 strh r3, [r1, #20]
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
3000e404: e581500c str r5, [r1, #12]
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
3000e408: e5814008 str r4, [r1, #8]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
3000e40c: e581c028 str ip, [r1, #40] ; 0x28
buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime;
3000e410: e5812038 str r2, [r1, #56] ; 0x38
return 0;
3000e414: e3a00000 mov r0, #0
}
3000e418: e8bd80f0 pop {r4, r5, r6, r7, pc}
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
3000e41c: e593c054 ldr ip, [r3, #84] ; 0x54
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
3000e420: e5932050 ldr r2, [r3, #80] ; 0x50 3000e424: e581c01c str ip, [r1, #28] 3000e428: e5812018 str r2, [r1, #24]
break;
3000e42c: eaffffe2 b 3000e3bc <IMFS_stat+0x44>
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000e430: eb000b3c bl 30011128 <__errno> <== NOT EXECUTED
3000e434: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3000e438: e5803000 str r3, [r0] <== NOT EXECUTED
3000e43c: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000e440: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
3000e444: e2835050 add r5, r3, #80 ; 0x50
3000e448: e8950030 ldm r5, {r4, r5}
3000e44c: e5814020 str r4, [r1, #32]
3000e450: e5815024 str r5, [r1, #36] ; 0x24
break;
3000e454: eaffffd8 b 3000e3bc <IMFS_stat+0x44>
30005f10 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005f10: e92d40f0 push {r4, r5, r6, r7, lr}
30005f14: e1a06000 mov r6, r0
30005f18: e24dd040 sub sp, sp, #64 ; 0x40
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
30005f1c: e1a00002 mov r0, r2
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
30005f20: e1a07002 mov r7, r2 30005f24: e1a05001 mov r5, r1
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
30005f28: eb003068 bl 300120d0 <strlen> 30005f2c: e28d4004 add r4, sp, #4 30005f30: e1a01000 mov r1, r0 30005f34: e1a02004 mov r2, r4 30005f38: e28d303c add r3, sp, #60 ; 0x3c 30005f3c: e1a00007 mov r0, r7 30005f40: eb0020a1 bl 3000e1cc <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005f44: e1a00005 mov r0, r5 30005f48: eb00304c bl 30012080 <strdup>
if (info.sym_link.name == NULL) {
30005f4c: e3500000 cmp r0, #0
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
30005f50: e58d0028 str r0, [sp, #40] ; 0x28
if (info.sym_link.name == NULL) {
30005f54: 0a00000d beq 30005f90 <IMFS_symlink+0x80>
new_node = IMFS_create_node(
parent_loc,
IMFS_SYM_LINK,
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
30005f58: e28d3028 add r3, sp, #40 ; 0x28
* was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node(
30005f5c: e58d3000 str r3, [sp] 30005f60: e3a01004 mov r1, #4 30005f64: e1a00006 mov r0, r6 30005f68: e1a02004 mov r2, r4 30005f6c: e59f3030 ldr r3, [pc, #48] ; 30005fa4 <IMFS_symlink+0x94> 30005f70: eb001df9 bl 3000d75c <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005f74: e3500000 cmp r0, #0
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
30005f78: 13a00000 movne r0, #0
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
30005f7c: 0a000001 beq 30005f88 <IMFS_symlink+0x78>
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
}
30005f80: e28dd040 add sp, sp, #64 ; 0x40
30005f84: e8bd80f0 pop {r4, r5, r6, r7, pc}
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
free(info.sym_link.name);
30005f88: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 30005f8c: eb000141 bl 30006498 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
30005f90: eb002c64 bl 30011128 <__errno> <== NOT EXECUTED 30005f94: e3a0300c mov r3, #12 <== NOT EXECUTED 30005f98: e5803000 str r3, [r0] <== NOT EXECUTED 30005f9c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30005fa0: eafffff6 b 30005f80 <IMFS_symlink+0x70> <== NOT EXECUTED
30005fa8 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fa8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
30005fac: e5915000 ldr r5, [r1]
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fb0: e24dd01c sub sp, sp, #28
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fb4: e595304c ldr r3, [r5, #76] ; 0x4c
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fb8: e1a04001 mov r4, r1
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fbc: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
30005fc0: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
30005fc4: 0a000006 beq 30005fe4 <IMFS_unlink+0x3c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
30005fc8: e5943008 ldr r3, [r4, #8] 30005fcc: e1a00006 mov r0, r6 30005fd0: e1a01004 mov r1, r4 30005fd4: e1a0e00f mov lr, pc 30005fd8: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
30005fdc: e28dd01c add sp, sp, #28
30005fe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
30005fe4: e595e050 ldr lr, [r5, #80] ; 0x50 <== NOT EXECUTED 30005fe8: e35e0000 cmp lr, #0 <== NOT EXECUTED 30005fec: 0a00001f beq 30006070 <IMFS_unlink+0xc8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
30005ff0: e1a0c00d mov ip, sp <== NOT EXECUTED
30005ff4: e1a07001 mov r7, r1 <== NOT EXECUTED
30005ff8: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
30005ffc: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006000: e5973000 ldr r3, [r7] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
30006004: e28d801c add r8, sp, #28 <== NOT EXECUTED
IMFS_Set_handlers( &the_link );
30006008: e1a0000d mov r0, sp <== NOT EXECUTED
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
3000600c: e58c3000 str r3, [ip] <== NOT EXECUTED
the_link.node_access = node->info.hard_link.link_node;
30006010: e528e01c str lr, [r8, #-28]! <== NOT EXECUTED
IMFS_Set_handlers( &the_link );
30006014: eb001e34 bl 3000d8ec <IMFS_Set_handlers> <== NOT EXECUTED
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
30006018: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 3000601c: e1d323b4 ldrh r2, [r3, #52] ; 0x34 <== NOT EXECUTED 30006020: e3520001 cmp r2, #1 <== NOT EXECUTED 30006024: 0a000008 beq 3000604c <IMFS_unlink+0xa4> <== NOT EXECUTED
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
30006028: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000602c: e1c323b4 strh r2, [r3, #52] ; 0x34 <== NOT EXECUTED
IMFS_update_ctime( node->info.hard_link.link_node );
30006030: e28d0014 add r0, sp, #20 <== NOT EXECUTED 30006034: e3a01000 mov r1, #0 <== NOT EXECUTED 30006038: eb00013f bl 3000653c <gettimeofday> <== NOT EXECUTED 3000603c: e5953050 ldr r3, [r5, #80] ; 0x50 <== NOT EXECUTED 30006040: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 30006044: e5832048 str r2, [r3, #72] ; 0x48 <== NOT EXECUTED 30006048: eaffffde b 30005fc8 <IMFS_unlink+0x20> <== NOT EXECUTED
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
3000604c: e1a00006 mov r0, r6 <== NOT EXECUTED 30006050: e1a0100d mov r1, sp <== NOT EXECUTED 30006054: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30006058: e1a0e00f mov lr, pc <== NOT EXECUTED 3000605c: e593f034 ldr pc, [r3, #52] ; 0x34 <== NOT EXECUTED
if ( result != 0 )
30006060: e3500000 cmp r0, #0 <== NOT EXECUTED 30006064: 0affffd7 beq 30005fc8 <IMFS_unlink+0x20> <== NOT EXECUTED
return -1;
30006068: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000606c: eaffffda b 30005fdc <IMFS_unlink+0x34> <== NOT EXECUTED
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
30006070: eb002c2c bl 30011128 <__errno> <== NOT EXECUTED 30006074: e3a03016 mov r3, #22 <== NOT EXECUTED 30006078: e5803000 str r3, [r0] <== NOT EXECUTED 3000607c: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006080: eaffffd5 b 30005fdc <IMFS_unlink+0x34> <== NOT EXECUTED
30006084 <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
30006084: e5903008 ldr r3, [r0, #8]
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
30006088: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
3000608c: e593204c ldr r2, [r3, #76] ; 0x4c 30006090: e3520001 cmp r2, #1
30006094: 1a000005 bne 300060b0 <IMFS_unmount+0x2c>
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
30006098: e593205c ldr r2, [r3, #92] ; 0x5c 3000609c: e3520000 cmp r2, #0
300060a0: 0a000007 beq 300060c4 <IMFS_unmount+0x40>
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
300060a4: e3a00000 mov r0, #0 300060a8: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
300060ac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
300060b0: eb002c1c bl 30011128 <__errno> <== NOT EXECUTED
300060b4: e3a03014 mov r3, #20 <== NOT EXECUTED
300060b8: e5803000 str r3, [r0] <== NOT EXECUTED
300060bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
300060c0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
300060c4: eb002c17 bl 30011128 <__errno> <== NOT EXECUTED
300060c8: e3a03016 mov r3, #22 <== NOT EXECUTED
300060cc: e5803000 str r3, [r0] <== NOT EXECUTED
300060d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300060d4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300060d8 <IMFS_utime>:
int IMFS_utime(
rtems_filesystem_location_info_t *pathloc, /* IN */
time_t actime, /* IN */
time_t modtime /* IN */
)
{
300060d8: e92d4010 push {r4, lr} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
300060dc: e5904000 ldr r4, [r0] <== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
the_jnode->stat_ctime = time( NULL );
300060e0: e3a00000 mov r0, #0 <== NOT EXECUTED
{
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
the_jnode->stat_atime = actime;
300060e4: e5841040 str r1, [r4, #64] ; 0x40 <== NOT EXECUTED
the_jnode->stat_mtime = modtime;
300060e8: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
300060ec: eb00304a bl 3001221c <time> <== NOT EXECUTED 300060f0: e5840048 str r0, [r4, #72] ; 0x48 <== NOT EXECUTED
return 0;
}
300060f4: e3a00000 mov r0, #0 <== NOT EXECUTED
300060f8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006714 <RTEMS_Malloc_Initialize>:
)
{
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
30006714: e59f30cc ldr r3, [pc, #204] ; 300067e8 <RTEMS_Malloc_Initialize+0xd4>
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006718: e92d4070 push {r4, r5, r6, lr}
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
3000671c: e5933000 ldr r3, [r3]
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006720: e1a05000 mov r5, r0
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
30006724: e3530000 cmp r3, #0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
30006728: e1a06001 mov r6, r1 3000672c: e1a04002 mov r4, r2
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
(*rtems_malloc_statistics_helpers->initialize)();
30006730: 11a0e00f movne lr, pc 30006734: 1593f000 ldrne pc, [r3]
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
30006738: ebffffe1 bl 300066c4 <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
3000673c: e59f30a8 ldr r3, [pc, #168] ; 300067ec <RTEMS_Malloc_Initialize+0xd8> 30006740: e5933000 ldr r3, [r3] 30006744: e3530000 cmp r3, #0
30006748: 0a000005 beq 30006764 <RTEMS_Malloc_Initialize+0x50>
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
3000674c: e1a00005 mov r0, r5 <== NOT EXECUTED 30006750: e1a01004 mov r1, r4 <== NOT EXECUTED 30006754: e1a0e00f mov lr, pc <== NOT EXECUTED 30006758: e593f000 ldr pc, [r3] <== NOT EXECUTED
heap_begin,
sbrk_amount
);
heap_size = (uintptr_t) sbrk_amount;
3000675c: e1a06004 mov r6, r4 <== NOT EXECUTED
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
30006760: e1a05000 mov r5, r0 <== NOT EXECUTED
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if (
30006764: e59f4084 ldr r4, [pc, #132] ; 300067f0 <RTEMS_Malloc_Initialize+0xdc> 30006768: e5d41000 ldrb r1, [r4] 3000676c: e3510000 cmp r1, #0
30006770: 1a000018 bne 300067d8 <RTEMS_Malloc_Initialize+0xc4>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
30006774: e59f3078 ldr r3, [pc, #120] ; 300067f4 <RTEMS_Malloc_Initialize+0xe0> 30006778: e5d33028 ldrb r3, [r3, #40] ; 0x28 3000677c: e3530000 cmp r3, #0
30006780: 1a00000e bne 300067c0 <RTEMS_Malloc_Initialize+0xac>
void *area_begin,
uintptr_t area_size,
uintptr_t page_size
)
{
return _Heap_Initialize( heap, area_begin, area_size, page_size );
30006784: e59f406c ldr r4, [pc, #108] ; 300067f8 <RTEMS_Malloc_Initialize+0xe4> 30006788: e1a01005 mov r1, r5 3000678c: e5940000 ldr r0, [r4] 30006790: e1a02006 mov r2, r6 30006794: e3a03008 mov r3, #8 30006798: eb001106 bl 3000abb8 <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
3000679c: e3500000 cmp r0, #0
300067a0: 0a00000e beq 300067e0 <RTEMS_Malloc_Initialize+0xcc>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
300067a4: e59f5050 ldr r5, [pc, #80] ; 300067fc <RTEMS_Malloc_Initialize+0xe8> 300067a8: e5940000 ldr r0, [r4] 300067ac: e5954000 ldr r4, [r5] 300067b0: eb0013b2 bl 3000b680 <_Protected_heap_Get_size> 300067b4: e0800004 add r0, r0, r4 300067b8: e5850000 str r0, [r5]
}
300067bc: e8bd8070 pop {r4, r5, r6, pc}
if (
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
) {
memset( heap_begin, 0, heap_size );
300067c0: e1a00005 mov r0, r5 300067c4: e1a02006 mov r2, r6 300067c8: eb002cbb bl 30011abc <memset>
* Unfortunately we cannot use assert if this fails because if this
* has failed we do not have a heap and if we do not have a heap
* STDIO cannot work because there will be no buffers.
*/
if ( !rtems_unified_work_area ) {
300067cc: e5d43000 ldrb r3, [r4] 300067d0: e3530000 cmp r3, #0
300067d4: 0affffea beq 30006784 <RTEMS_Malloc_Initialize+0x70>
300067d8: e59f4018 ldr r4, [pc, #24] ; 300067f8 <RTEMS_Malloc_Initialize+0xe4> 300067dc: eafffff0 b 300067a4 <RTEMS_Malloc_Initialize+0x90>
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
300067e0: e280001a add r0, r0, #26 <== NOT EXECUTED 300067e4: eb000e81 bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
30005b34 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30005b34: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
30005b38: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
30005b3c: e59060b4 ldr r6, [r0, #180] ; 0xb4 <== NOT EXECUTED
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
30005b40: e283c010 add ip, r3, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
30005b44: e2466010 sub r6, r6, #16 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
30005b48: e28cb010 add fp, ip, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
30005b4c: e3c61003 bic r1, r6, #3 <== NOT EXECUTED 30005b50: e08b1001 add r1, fp, r1 <== NOT EXECUTED 30005b54: e15b0001 cmp fp, r1 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
30005b58: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 30005b5c: e1a05000 mov r5, r0 <== NOT EXECUTED
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
30005b60: e59090e4 ldr r9, [r0, #228] ; 0xe4 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30005b64: 2a00000b bcs 30005b98 <Stack_check_Dump_threads_usage+0x64><== NOT EXECUTED
if (*base != U32_PATTERN)
30005b68: e59c0010 ldr r0, [ip, #16] <== NOT EXECUTED 30005b6c: e59f20d0 ldr r2, [pc, #208] ; 30005c44 <Stack_check_Dump_threads_usage+0x110><== NOT EXECUTED 30005b70: e1500002 cmp r0, r2 <== NOT EXECUTED
* Try to print out how much stack was actually used by the task.
*/
static void *print_context;
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
30005b74: 02833024 addeq r3, r3, #36 ; 0x24 <== NOT EXECUTED
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
30005b78: 0a000003 beq 30005b8c <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED 30005b7c: ea000027 b 30005c20 <Stack_check_Dump_threads_usage+0xec> <== NOT EXECUTED 30005b80: e4932004 ldr r2, [r3], #4 <== NOT EXECUTED 30005b84: e1520000 cmp r2, r0 <== NOT EXECUTED 30005b88: 1a000024 bne 30005c20 <Stack_check_Dump_threads_usage+0xec><== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30005b8c: e1510003 cmp r1, r3 <== NOT EXECUTED
if (*base != U32_PATTERN)
30005b90: e1a0b003 mov fp, r3 <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
30005b94: 8afffff9 bhi 30005b80 <Stack_check_Dump_threads_usage+0x4c><== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
30005b98: e3a0b000 mov fp, #0 <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
30005b9c: e5958008 ldr r8, [r5, #8] <== NOT EXECUTED
30005ba0: e59f40a0 ldr r4, [pc, #160] ; 30005c48 <Stack_check_Dump_threads_usage+0x114><== NOT EXECUTED
30005ba4: e3a01005 mov r1, #5 <== NOT EXECUTED
30005ba8: e28d2008 add r2, sp, #8 <== NOT EXECUTED
30005bac: e1a00008 mov r0, r8 <== NOT EXECUTED
30005bb0: e8940480 ldm r4, {r7, sl} <== NOT EXECUTED
30005bb4: eb00104b bl 30009ce8 <rtems_object_get_name> <== NOT EXECUTED
30005bb8: e1a02008 mov r2, r8 <== NOT EXECUTED
30005bbc: e1a03000 mov r3, r0 <== NOT EXECUTED
30005bc0: e59f1084 ldr r1, [pc, #132] ; 30005c4c <Stack_check_Dump_threads_usage+0x118><== NOT EXECUTED
30005bc4: e1a0000a mov r0, sl <== NOT EXECUTED
30005bc8: e1a0e00f mov lr, pc <== NOT EXECUTED
30005bcc: e12fff17 bx r7 <== NOT EXECUTED
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
30005bd0: e59530b4 ldr r3, [r5, #180] ; 0xb4 <== NOT EXECUTED 30005bd4: e59520b8 ldr r2, [r5, #184] ; 0xb8 <== NOT EXECUTED 30005bd8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
30005bdc: e0823003 add r3, r2, r3 <== NOT EXECUTED 30005be0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005be4: e58d9000 str r9, [sp] <== NOT EXECUTED 30005be8: e58d6004 str r6, [sp, #4] <== NOT EXECUTED 30005bec: e59f105c ldr r1, [pc, #92] ; 30005c50 <Stack_check_Dump_threads_usage+0x11c><== NOT EXECUTED 30005bf0: e1a0e00f mov lr, pc <== NOT EXECUTED 30005bf4: e594f000 ldr pc, [r4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
30005bf8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30005bfc: e3530000 cmp r3, #0 <== NOT EXECUTED 30005c00: 0a00000a beq 30005c30 <Stack_check_Dump_threads_usage+0xfc><== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
30005c04: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005c08: e59f1044 ldr r1, [pc, #68] ; 30005c54 <Stack_check_Dump_threads_usage+0x120><== NOT EXECUTED 30005c0c: e1a0200b mov r2, fp <== NOT EXECUTED 30005c10: e1a0e00f mov lr, pc <== NOT EXECUTED 30005c14: e594f000 ldr pc, [r4] <== NOT EXECUTED
}
}
30005c18: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30005c1c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
30005c20: e35b0000 cmp fp, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
30005c24: 108cc006 addne ip, ip, r6 <== NOT EXECUTED 30005c28: 106bb00c rsbne fp, fp, ip <== NOT EXECUTED 30005c2c: eaffffda b 30005b9c <Stack_check_Dump_threads_usage+0x68> <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
30005c30: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005c34: e59f101c ldr r1, [pc, #28] ; 30005c58 <Stack_check_Dump_threads_usage+0x124><== NOT EXECUTED 30005c38: e1a0e00f mov lr, pc <== NOT EXECUTED 30005c3c: e594f000 ldr pc, [r4] <== NOT EXECUTED 30005c40: eafffff4 b 30005c18 <Stack_check_Dump_threads_usage+0xe4> <== NOT EXECUTED
30005d08 <Stack_check_report_blown_task>:
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30005d08: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30005d0c: e1a06000 mov r6, r0 <== NOT EXECUTED
30005d10: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
30005d14: e59f0084 ldr r0, [pc, #132] ; 30005da0 <Stack_check_report_blown_task+0x98><== NOT EXECUTED
Thread_Control *running,
bool pattern_ok
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
30005d18: e20140ff and r4, r1, #255 ; 0xff <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack);
30005d1c: e59650b8 ldr r5, [r6, #184] ; 0xb8 <== NOT EXECUTED
char name[32];
printk("BLOWN STACK!!!\n");
30005d20: eb000668 bl 300076c8 <printk> <== NOT EXECUTED
printk("task control block: 0x%08" PRIxPTR "\n", running);
30005d24: e59f0078 ldr r0, [pc, #120] ; 30005da4 <Stack_check_report_blown_task+0x9c><== NOT EXECUTED 30005d28: e1a01006 mov r1, r6 <== NOT EXECUTED 30005d2c: eb000665 bl 300076c8 <printk> <== NOT EXECUTED
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
30005d30: e59f0070 ldr r0, [pc, #112] ; 30005da8 <Stack_check_report_blown_task+0xa0><== NOT EXECUTED 30005d34: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 30005d38: eb000662 bl 300076c8 <printk> <== NOT EXECUTED
printk(
30005d3c: e59f0068 ldr r0, [pc, #104] ; 30005dac <Stack_check_report_blown_task+0xa4><== NOT EXECUTED 30005d40: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 30005d44: eb00065f bl 300076c8 <printk> <== NOT EXECUTED
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
30005d48: e1a0200d mov r2, sp <== NOT EXECUTED 30005d4c: e3a01020 mov r1, #32 <== NOT EXECUTED 30005d50: e5960008 ldr r0, [r6, #8] <== NOT EXECUTED 30005d54: eb000fe3 bl 30009ce8 <rtems_object_get_name> <== NOT EXECUTED 30005d58: e1a01000 mov r1, r0 <== NOT EXECUTED 30005d5c: e59f004c ldr r0, [pc, #76] ; 30005db0 <Stack_check_report_blown_task+0xa8><== NOT EXECUTED 30005d60: eb000658 bl 300076c8 <printk> <== NOT EXECUTED
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
30005d64: e59620b8 ldr r2, [r6, #184] ; 0xb8 <== NOT EXECUTED 30005d68: e59610b4 ldr r1, [r6, #180] ; 0xb4 <== NOT EXECUTED
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
30005d6c: e59f0040 ldr r0, [pc, #64] ; 30005db4 <Stack_check_report_blown_task+0xac><== NOT EXECUTED 30005d70: e0823001 add r3, r2, r1 <== NOT EXECUTED 30005d74: eb000653 bl 300076c8 <printk> <== NOT EXECUTED
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
30005d78: e3540000 cmp r4, #0 <== NOT EXECUTED 30005d7c: 0a000001 beq 30005d88 <Stack_check_report_blown_task+0x80> <== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
30005d80: e3a00081 mov r0, #129 ; 0x81 <== NOT EXECUTED 30005d84: eb001202 bl 3000a594 <rtems_fatal_error_occurred> <== NOT EXECUTED
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
);
if (!pattern_ok) {
printk(
30005d88: e59f0028 ldr r0, [pc, #40] ; 30005db8 <Stack_check_report_blown_task+0xb0><== NOT EXECUTED 30005d8c: e3a01010 mov r1, #16 <== NOT EXECUTED 30005d90: e2852008 add r2, r5, #8 <== NOT EXECUTED 30005d94: e2853018 add r3, r5, #24 <== NOT EXECUTED 30005d98: eb00064a bl 300076c8 <printk> <== NOT EXECUTED 30005d9c: eafffff7 b 30005d80 <Stack_check_report_blown_task+0x78> <== NOT EXECUTED
30010000 <TOD_MICROSECONDS_TO_TICKS>:
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
return (microseconds / rtems_configuration_get_microseconds_per_tick());
30010000: e59f300c ldr r3, [pc, #12] ; 30010014 <TOD_MICROSECONDS_TO_TICKS+0x14><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MICROSECONDS_TO_TICKS(
uint32_t microseconds
)
{
30010004: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (microseconds / rtems_configuration_get_microseconds_per_tick());
30010008: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3001000c: eb004e4a bl 3002393c <__aeabi_uidiv> <== NOT EXECUTED
}
30010010: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b6f0 <TOD_MILLISECONDS_TO_TICKS>:
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000b6f0: e59f3018 ldr r3, [pc, #24] ; 3000b710 <TOD_MILLISECONDS_TO_TICKS+0x20><== NOT EXECUTED
#include <rtems/score/tod.h>
uint32_t TOD_MILLISECONDS_TO_TICKS(
uint32_t milliseconds
)
{
3000b6f4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (milliseconds / rtems_configuration_get_milliseconds_per_tick());
3000b6f8: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3000b6fc: e59f3010 ldr r3, [pc, #16] ; 3000b714 <TOD_MILLISECONDS_TO_TICKS+0x24><== NOT EXECUTED 3000b700: e0812193 umull r2, r1, r3, r1 <== NOT EXECUTED 3000b704: e1a01321 lsr r1, r1, #6 <== NOT EXECUTED 3000b708: eb00407a bl 3001b8f8 <__aeabi_uidiv> <== NOT EXECUTED
}
3000b70c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001e278 <TOD_TICKS_PER_SECOND_method>:
#include <rtems/config.h>
#include <rtems/score/tod.h>
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
return (TOD_MICROSECONDS_PER_SECOND /
3001e278: e59f3010 ldr r3, [pc, #16] ; 3001e290 <TOD_TICKS_PER_SECOND_method+0x18><== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/config.h>
#include <rtems/score/tod.h>
uint32_t TOD_TICKS_PER_SECOND_method(void)
{
3001e27c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return (TOD_MICROSECONDS_PER_SECOND /
3001e280: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 3001e284: e59f0008 ldr r0, [pc, #8] ; 3001e294 <TOD_TICKS_PER_SECOND_method+0x1c><== NOT EXECUTED 3001e288: ebfff5c4 bl 3001b9a0 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick());
}
3001e28c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30012d18 <_Barrier_Translate_core_barrier_return_code>:
*/
#if defined(RTEMS_DEBUG)
if ( the_barrier_status > CORE_BARRIER_STATUS_LAST )
return RTEMS_INTERNAL_ERROR;
#endif
return _Barrier_Translate_core_barrier_return_code_[the_barrier_status];
30012d18: e59f3004 ldr r3, [pc, #4] ; 30012d24 <_Barrier_Translate_core_barrier_return_code+0xc><== NOT EXECUTED
}
30012d1c: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED 30012d20: e12fff1e bx lr <== NOT EXECUTED
300122d8 <_CORE_barrier_Release>:
#else
Objects_Id id __attribute__((unused)),
CORE_barrier_API_mp_support_callout api_barrier_mp_support __attribute__((unused))
#endif
)
{
300122d8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300122dc: e1a05000 mov r5, r0 <== NOT EXECUTED
Thread_Control *the_thread;
uint32_t count;
count = 0;
300122e0: e3a04000 mov r4, #0 <== NOT EXECUTED
while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
300122e4: ea000000 b 300122ec <_CORE_barrier_Release+0x14> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_barrier_mp_support) ( the_thread, id );
#endif
count++;
300122e8: e2844001 add r4, r4, #1 <== NOT EXECUTED
{
Thread_Control *the_thread;
uint32_t count;
count = 0;
while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
300122ec: e1a00005 mov r0, r5 <== NOT EXECUTED 300122f0: ebfff068 bl 3000e498 <_Thread_queue_Dequeue> <== NOT EXECUTED 300122f4: e3500000 cmp r0, #0 <== NOT EXECUTED 300122f8: 1afffffa bne 300122e8 <_CORE_barrier_Release+0x10> <== NOT EXECUTED
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_barrier_mp_support) ( the_thread, id );
#endif
count++;
}
the_barrier->number_of_waiting_threads = 0;
300122fc: e5850048 str r0, [r5, #72] ; 0x48 <== NOT EXECUTED
return count; }
30012300: e1a00004 mov r0, r4 <== NOT EXECUTED
30012304: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30012308 <_CORE_barrier_Wait>:
)
{
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30012308: e59f2078 ldr r2, [pc, #120] ; 30012388 <_CORE_barrier_Wait+0x80><== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3001230c: e92d0070 push {r4, r5, r6} <== NOT EXECUTED
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
30012310: e592c004 ldr ip, [r2, #4] <== NOT EXECUTED
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
30012314: e3a04000 mov r4, #0 <== NOT EXECUTED 30012318: e58c4034 str r4, [ip, #52] ; 0x34 <== NOT EXECUTED
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
3001231c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30012320: e10f6000 mrs r6, CPSR <== NOT EXECUTED 30012324: e3864080 orr r4, r6, #128 ; 0x80 <== NOT EXECUTED 30012328: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3001232c: e5904048 ldr r4, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30012330: e5905040 ldr r5, [r0, #64] ; 0x40 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
30012334: e2844001 add r4, r4, #1 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30012338: e3550000 cmp r5, #0 <== NOT EXECUTED
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
3001233c: e5804048 str r4, [r0, #72] ; 0x48 <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
30012340: 1a000002 bne 30012350 <_CORE_barrier_Wait+0x48> <== NOT EXECUTED
if ( the_barrier->number_of_waiting_threads ==
30012344: e5905044 ldr r5, [r0, #68] ; 0x44 <== NOT EXECUTED 30012348: e1540005 cmp r4, r5 <== NOT EXECUTED 3001234c: 0a000008 beq 30012374 <_CORE_barrier_Wait+0x6c> <== NOT EXECUTED 30012350: e3a02001 mov r2, #1 <== NOT EXECUTED 30012354: e5802030 str r2, [r0, #48] ; 0x30 <== NOT EXECUTED
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
30012358: e58c0044 str r0, [ip, #68] ; 0x44 <== NOT EXECUTED
executing->Wait.id = id;
3001235c: e58c1020 str r1, [ip, #32] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30012360: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
30012364: e59f2020 ldr r2, [pc, #32] ; 3001238c <_CORE_barrier_Wait+0x84><== NOT EXECUTED 30012368: e1a01003 mov r1, r3 <== NOT EXECUTED
}
3001236c: e8bd0070 pop {r4, r5, r6} <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
30012370: eafff0a6 b 3000e610 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
30012374: e3a03001 mov r3, #1 <== NOT EXECUTED 30012378: e58c3034 str r3, [ip, #52] ; 0x34 <== NOT EXECUTED 3001237c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
}
30012380: e8bd0070 pop {r4, r5, r6} <== NOT EXECUTED
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
_ISR_Enable( level );
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
30012384: eaffffd3 b 300122d8 <_CORE_barrier_Release> <== NOT EXECUTED
3001b1f0 <_CORE_message_queue_Broadcast>:
{
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001b1f0: e590304c ldr r3, [r0, #76] ; 0x4c
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
3001b1f4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001b1f8: e1530002 cmp r3, r2
Objects_Id id __attribute__((unused)),
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)),
#endif
uint32_t *count
)
{
3001b1fc: e1a07000 mov r7, r0 3001b200: e1a05002 mov r5, r2 3001b204: e1a08001 mov r8, r1 3001b208: e59da020 ldr sl, [sp, #32]
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
3001b20c: 3a000016 bcc 3001b26c <_CORE_message_queue_Broadcast+0x7c>
* 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 ) {
3001b210: e5906048 ldr r6, [r0, #72] ; 0x48 3001b214: e3560000 cmp r6, #0
*count = 0;
3001b218: 13a00000 movne r0, #0 3001b21c: 158a0000 strne r0, [sl]
* 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 ) {
3001b220: 18bd85f0 popne {r4, r5, r6, r7, r8, sl, pc}
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b224: e1a00007 mov r0, r7 3001b228: eb000b0c bl 3001de60 <_Thread_queue_Dequeue> 3001b22c: e2504000 subs r4, r0, #0
3001b230: 0a00000a beq 3001b260 <_CORE_message_queue_Broadcast+0x70>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
3001b234: e594002c ldr r0, [r4, #44] ; 0x2c 3001b238: e1a01008 mov r1, r8 3001b23c: e1a02005 mov r2, r5 3001b240: eb00201c bl 300232b8 <memcpy>
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001b244: e5943028 ldr r3, [r4, #40] ; 0x28
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b248: e1a00007 mov r0, r7
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
3001b24c: e5835000 str r5, [r3]
/* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread =
3001b250: eb000b02 bl 3001de60 <_Thread_queue_Dequeue> 3001b254: e2504000 subs r4, r0, #0
_Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
waitp = &the_thread->Wait;
number_broadcasted += 1;
3001b258: e2866001 add r6, r6, #1
/*
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread =
3001b25c: 1afffff4 bne 3001b234 <_CORE_message_queue_Broadcast+0x44>
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
3001b260: e58a6000 str r6, [sl]
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
3001b264: e1a00004 mov r0, r4
3001b268: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
3001b26c: e3a00001 mov r0, #1 <== NOT EXECUTED
#endif
}
*count = number_broadcasted;
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
3001b270: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300132b8 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
300132b8: e92d4070 push {r4, r5, r6, lr}
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
300132bc: e3130003 tst r3, #3
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
300132c0: e1a04000 mov r4, r0
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
the_message_queue->number_of_pending_messages = 0;
300132c4: e3a00000 mov r0, #0
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
300132c8: e1a05001 mov r5, r1 300132cc: e24dd004 sub sp, sp, #4
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
300132d0: e5842044 str r2, [r4, #68] ; 0x44
the_message_queue->number_of_pending_messages = 0;
300132d4: e5840048 str r0, [r4, #72] ; 0x48
the_message_queue->maximum_message_size = maximum_message_size;
300132d8: e584304c str r3, [r4, #76] ; 0x4c
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
300132dc: 01a01003 moveq r1, r3
300132e0: 0a000005 beq 300132fc <_CORE_message_queue_Initialize+0x44>
allocated_message_size += sizeof(uint32_t);
300132e4: e2831004 add r1, r3, #4 <== NOT EXECUTED
allocated_message_size &= ~(sizeof(uint32_t) - 1);
300132e8: e3c11003 bic r1, r1, #3 <== NOT EXECUTED
}
if (allocated_message_size < maximum_message_size)
300132ec: e1530001 cmp r3, r1 <== NOT EXECUTED 300132f0: 9a000001 bls 300132fc <_CORE_message_queue_Initialize+0x44><== NOT EXECUTED
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
300132f4: e28dd004 add sp, sp, #4
300132f8: e8bd8070 pop {r4, r5, r6, pc}
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
300132fc: e2816010 add r6, r1, #16
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
30013300: e0000692 mul r0, r2, r6
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
30013304: e1500001 cmp r0, r1
return false;
30013308: 33a00000 movcc r0, #0
* check for overflow on the multiplication.
*/
message_buffering_required = (size_t) maximum_pending_messages *
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
3001330c: 3afffff8 bcc 300132f4 <_CORE_message_queue_Initialize+0x3c>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
30013310: e58d2000 str r2, [sp] 30013314: eb000bc5 bl 30016230 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
30013318: e3500000 cmp r0, #0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
3001331c: e1a01000 mov r1, r0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
30013320: e584005c str r0, [r4, #92] ; 0x5c
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
30013324: e59d2000 ldr r2, [sp]
return false;
30013328: 01a00000 moveq r0, r0
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
3001332c: 0afffff0 beq 300132f4 <_CORE_message_queue_Initialize+0x3c>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
30013330: e2840060 add r0, r4, #96 ; 0x60 30013334: e1a03006 mov r3, r6 30013338: eb00139f bl 300181bc <_Chain_Initialize>
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3001333c: e2842054 add r2, r4, #84 ; 0x54
head->next = tail;
30013340: e5842050 str r2, [r4, #80] ; 0x50
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
30013344: e2843050 add r3, r4, #80 ; 0x50
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
30013348: e3a02000 mov r2, #0 3001334c: e5842054 str r2, [r4, #84] ; 0x54
tail->previous = head;
30013350: e5843058 str r3, [r4, #88] ; 0x58
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
30013354: e5951000 ldr r1, [r5] 30013358: e1a00004 mov r0, r4 3001335c: e3510001 cmp r1, #1 30013360: 13a01000 movne r1, #0 30013364: 03a01001 moveq r1, #1 30013368: e3a02080 mov r2, #128 ; 0x80 3001336c: e3a03006 mov r3, #6 30013370: eb000923 bl 30015804 <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
30013374: e3a00001 mov r0, #1 30013378: eaffffdd b 300132f4 <_CORE_message_queue_Initialize+0x3c>
3001345c <_CORE_message_queue_Submit>:
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
3001345c: e590304c ldr r3, [r0, #76] ; 0x4c
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013460: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
30013464: e1530002 cmp r3, r2
#endif
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
30013468: e1a04000 mov r4, r0 3001346c: e1a05002 mov r5, r2 30013470: e1a0a001 mov sl, r1 30013474: e59d7020 ldr r7, [sp, #32]
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
30013478: 33a00001 movcc r0, #1
)
{
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
3001347c: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
30013480: e5946048 ldr r6, [r4, #72] ; 0x48 30013484: e3560000 cmp r6, #0
30013488: 0a000012 beq 300134d8 <_CORE_message_queue_Submit+0x7c>
/*
* No one waiting on the message queue at this time, so attempt to
* queue the message up for a future receive.
*/
if ( the_message_queue->number_of_pending_messages <
3001348c: e5943044 ldr r3, [r4, #68] ; 0x44 30013490: e1530006 cmp r3, r6
30013494: 8a000001 bhi 300134a0 <_CORE_message_queue_Submit+0x44>
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
#if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
30013498: e3a00002 mov r0, #2 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
#endif
}
3001349c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
300134a0: e2840060 add r0, r4, #96 ; 0x60 300134a4: ebffff6c bl 3001325c <_Chain_Get>
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300134a8: e1a0100a mov r1, sl
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
_Chain_Get( &the_message_queue->Inactive_messages );
300134ac: e1a06000 mov r6, r0
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
300134b0: e1a02005 mov r2, r5 300134b4: e280000c add r0, r0, #12 300134b8: eb001d6f bl 3001aa7c <memcpy>
size
);
the_message->Contents.size = size;
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
300134bc: e1a00004 mov r0, r4
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
300134c0: e5865008 str r5, [r6, #8]
_CORE_message_queue_Set_message_priority( the_message, submit_type );
_CORE_message_queue_Insert_message(
300134c4: e1a01006 mov r1, r6 300134c8: e1a02007 mov r2, r7 300134cc: eb001353 bl 30018220 <_CORE_message_queue_Insert_message>
the_message_queue,
the_message,
submit_type
);
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300134d0: e3a00000 mov r0, #0
300134d4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
300134d8: eb0007bd bl 300153d4 <_Thread_queue_Dequeue>
if ( the_thread ) {
300134dc: e2508000 subs r8, r0, #0 300134e0: 05946048 ldreq r6, [r4, #72] ; 0x48
300134e4: 0affffe8 beq 3001348c <_CORE_message_queue_Submit+0x30>
300134e8: e598002c ldr r0, [r8, #44] ; 0x2c 300134ec: e1a0100a mov r1, sl 300134f0: e1a02005 mov r2, r5 300134f4: eb001d60 bl 3001aa7c <memcpy>
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
300134f8: e5983028 ldr r3, [r8, #40] ; 0x28
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
300134fc: e1a00006 mov r0, r6
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
30013500: e5835000 str r5, [r3]
the_thread->Wait.count = (uint32_t) submit_type;
30013504: e5887024 str r7, [r8, #36] ; 0x24
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
30013508: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000a67c <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a67c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a680: e59f40b4 ldr r4, [pc, #180] ; 3000a73c <_CORE_mutex_Seize+0xc0>
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a684: e1a05000 mov r5, r0
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a688: e594c000 ldr ip, [r4]
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a68c: e1a06001 mov r6, r1
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
3000a690: e35c0000 cmp ip, #0
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
3000a694: e1a08003 mov r8, r3 3000a698: e20270ff and r7, r2, #255 ; 0xff
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 3000a69c: 0a000001 beq 3000a6a8 <_CORE_mutex_Seize+0x2c>
3000a6a0: e3570000 cmp r7, #0
3000a6a4: 1a00000d bne 3000a6e0 <_CORE_mutex_Seize+0x64>
3000a6a8: e1a00005 mov r0, r5
3000a6ac: e28d1018 add r1, sp, #24
3000a6b0: eb0012c1 bl 3000f1bc <_CORE_mutex_Seize_interrupt_trylock>
3000a6b4: e3500000 cmp r0, #0
3000a6b8: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
3000a6bc: e3570000 cmp r7, #0
3000a6c0: 1a00000e bne 3000a700 <_CORE_mutex_Seize+0x84>
3000a6c4: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
3000a6c8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000a6cc: e59f306c ldr r3, [pc, #108] ; 3000a740 <_CORE_mutex_Seize+0xc4><== NOT EXECUTED
3000a6d0: e3a02001 mov r2, #1 <== NOT EXECUTED
3000a6d4: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
3000a6d8: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
3000a6dc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000a6e0: e59f305c ldr r3, [pc, #92] ; 3000a744 <_CORE_mutex_Seize+0xc8> 3000a6e4: e5933000 ldr r3, [r3] 3000a6e8: e3530001 cmp r3, #1
3000a6ec: 9affffed bls 3000a6a8 <_CORE_mutex_Seize+0x2c>
3000a6f0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a6f4: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a6f8: e3a02012 mov r2, #18 <== NOT EXECUTED 3000a6fc: eb0001c8 bl 3000ae24 <_Internal_error_Occurred> <== NOT EXECUTED
3000a700: e59f3038 ldr r3, [pc, #56] ; 3000a740 <_CORE_mutex_Seize+0xc4> 3000a704: e5942000 ldr r2, [r4] 3000a708: e5933004 ldr r3, [r3, #4] 3000a70c: e2822001 add r2, r2, #1
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000a710: e3a01001 mov r1, #1
3000a714: e5851030 str r1, [r5, #48] ; 0x30
3000a718: e5842000 str r2, [r4]
3000a71c: e5835044 str r5, [r3, #68] ; 0x44
3000a720: e5836020 str r6, [r3, #32]
3000a724: e59d3018 ldr r3, [sp, #24]
3000a728: e129f003 msr CPSR_fc, r3
3000a72c: e1a00005 mov r0, r5
3000a730: e1a01008 mov r1, r8
3000a734: ebffffb5 bl 3000a610 <_CORE_mutex_Seize_interrupt_blocking>
3000a738: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
3000f1bc <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000f1bc: e59f213c ldr r2, [pc, #316] ; 3000f300 <_CORE_mutex_Seize_interrupt_trylock+0x144>
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f1c0: e590c050 ldr ip, [r0, #80] ; 0x50
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
3000f1c4: e1a03000 mov r3, r0
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
3000f1c8: e5922004 ldr r2, [r2, #4]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000f1cc: e3a00000 mov r0, #0
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f1d0: e15c0000 cmp ip, r0
3000f1d4: e92d40f0 push {r4, r5, r6, r7, lr}
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
3000f1d8: e5820034 str r0, [r2, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
3000f1dc: 0a00000e beq 3000f21c <_CORE_mutex_Seize_interrupt_trylock+0x60>
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
3000f1e0: e593c048 ldr ip, [r3, #72] ; 0x48
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
3000f1e4: e5925008 ldr r5, [r2, #8]
the_mutex->nest_count = 1;
3000f1e8: e3a04001 mov r4, #1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000f1ec: e35c0002 cmp ip, #2
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
3000f1f0: e5830050 str r0, [r3, #80] ; 0x50
the_mutex->holder = executing;
3000f1f4: e583205c str r2, [r3, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
3000f1f8: e5835060 str r5, [r3, #96] ; 0x60
the_mutex->nest_count = 1;
3000f1fc: e5834054 str r4, [r3, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000f200: 0a00000e beq 3000f240 <_CORE_mutex_Seize_interrupt_trylock+0x84>
3000f204: e35c0003 cmp ip, #3
3000f208: 0a000013 beq 3000f25c <_CORE_mutex_Seize_interrupt_trylock+0xa0>
3000f20c: e5913000 ldr r3, [r1] 3000f210: e129f003 msr CPSR_fc, r3
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
return 0;
3000f214: e3a00000 mov r0, #0
3000f218: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000f21c: e593005c ldr r0, [r3, #92] ; 0x5c 3000f220: e1520000 cmp r2, r0
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f224: 13a00001 movne r0, #1
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
3000f228: 18bd80f0 popne {r4, r5, r6, r7, pc}
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
3000f22c: e5932040 ldr r2, [r3, #64] ; 0x40 3000f230: e3520000 cmp r2, #0
3000f234: 0a000019 beq 3000f2a0 <_CORE_mutex_Seize_interrupt_trylock+0xe4>
/*
* The mutex is not available and the caller must deal with the possibility
* of blocking.
*/
return 1;
3000f238: e3a00001 mov r0, #1
3000f23c: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f240: e592301c ldr r3, [r2, #28] 3000f244: e2833001 add r3, r3, #1 3000f248: e582301c str r3, [r2, #28] 3000f24c: e5913000 ldr r3, [r1] 3000f250: e129f003 msr CPSR_fc, r3
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( *level_p );
return 0;
3000f254: e3a00000 mov r0, #0
3000f258: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f25c: e592c01c ldr ip, [r2, #28]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
3000f260: e593704c ldr r7, [r3, #76] ; 0x4c
current = executing->current_priority;
3000f264: e5926014 ldr r6, [r2, #20]
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f268: e08c5004 add r5, ip, r4
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
3000f26c: e1570006 cmp r7, r6
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
3000f270: e582501c str r5, [r2, #28]
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
3000f274: 0a00001d beq 3000f2f0 <_CORE_mutex_Seize_interrupt_trylock+0x134>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
3000f278: 3a00000f bcc 3000f2bc <_CORE_mutex_Seize_interrupt_trylock+0x100>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
3000f27c: e3a05005 mov r5, #5 3000f280: e5825034 str r5, [r2, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000f284: e5834050 str r4, [r3, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
3000f288: e5830054 str r0, [r3, #84] ; 0x54
executing->resource_count--; /* undo locking above */
3000f28c: e582c01c str ip, [r2, #28] 3000f290: e5913000 ldr r3, [r1] 3000f294: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000f298: e3a00000 mov r0, #0
3000f29c: e8bd80f0 pop {r4, r5, r6, r7, pc}
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
3000f2a0: e5932054 ldr r2, [r3, #84] ; 0x54 3000f2a4: e2822001 add r2, r2, #1 3000f2a8: e5832054 str r2, [r3, #84] ; 0x54 3000f2ac: e5913000 ldr r3, [r1] 3000f2b0: e129f003 msr CPSR_fc, r3
_ISR_Enable( *level_p );
return 0;
3000f2b4: e3a00000 mov r0, #0
3000f2b8: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000f2bc: e59f2040 ldr r2, [pc, #64] ; 3000f304 <_CORE_mutex_Seize_interrupt_trylock+0x148><== NOT EXECUTED 3000f2c0: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000f2c4: e2800001 add r0, r0, #1 <== NOT EXECUTED 3000f2c8: e5820000 str r0, [r2] <== NOT EXECUTED 3000f2cc: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000f2d0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
3000f2d4: e3a02000 mov r2, #0 <== NOT EXECUTED 3000f2d8: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED 3000f2dc: e593104c ldr r1, [r3, #76] ; 0x4c <== NOT EXECUTED 3000f2e0: ebfff24a bl 3000bc10 <_Thread_Change_priority> <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
3000f2e4: ebfff366 bl 3000c084 <_Thread_Enable_dispatch> <== NOT EXECUTED
return 0;
3000f2e8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000f2ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f2f0: e5913000 ldr r3, [r1] <== NOT EXECUTED
3000f2f4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
_ISR_Enable( *level_p );
return 0;
3000f2f8: e3a00000 mov r0, #0 <== NOT EXECUTED
3000f2fc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000a748 <_CORE_mutex_Surrender>:
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000a748: e5d03044 ldrb r3, [r0, #68] ; 0x44
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a74c: e92d4030 push {r4, r5, lr}
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000a750: e3530000 cmp r3, #0
#else
Objects_Id id __attribute__((unused)),
CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused))
#endif
)
{
3000a754: e1a04000 mov r4, r0
Thread_Control *the_thread;
Thread_Control *holder;
holder = the_mutex->holder;
3000a758: e590205c ldr r2, [r0, #92] ; 0x5c
* allowed when the mutex in quetion is FIFO or simple Priority
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
3000a75c: 0a000004 beq 3000a774 <_CORE_mutex_Surrender+0x2c>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000a760: e59f3110 ldr r3, [pc, #272] ; 3000a878 <_CORE_mutex_Surrender+0x130>
if ( !_Thread_Is_executing( holder ) )
3000a764: e5933004 ldr r3, [r3, #4] 3000a768: e1520003 cmp r2, r3
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
3000a76c: 13a00002 movne r0, #2
* discipline. But Priority Ceiling or Priority Inheritance mutexes
* must be released by the thread which acquired them.
*/
if ( the_mutex->Attributes.only_owner_release ) {
if ( !_Thread_Is_executing( holder ) )
3000a770: 18bd8030 popne {r4, r5, pc}
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
3000a774: e5940054 ldr r0, [r4, #84] ; 0x54
3000a778: e3500000 cmp r0, #0
3000a77c: 08bd8030 popeq {r4, r5, pc}
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a780: e2400001 sub r0, r0, #1
if ( the_mutex->nest_count != 0 ) {
3000a784: e3500000 cmp r0, #0
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
3000a788: e5840054 str r0, [r4, #84] ; 0x54
/* Currently no API exercises this behavior. */
break;
}
#else
/* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a78c: 13a00000 movne r0, #0
if ( !the_mutex->nest_count )
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
3000a790: 18bd8030 popne {r4, r5, pc}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
3000a794: e5943048 ldr r3, [r4, #72] ; 0x48
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
3000a798: e3530002 cmp r3, #2
3000a79c: 0a00001f beq 3000a820 <_CORE_mutex_Surrender+0xd8>
3000a7a0: e3530003 cmp r3, #3
3000a7a4: 0a00001d beq 3000a820 <_CORE_mutex_Surrender+0xd8>
if ( holder->resource_count == 0 &&
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
}
}
the_mutex->holder = NULL;
3000a7a8: e3a05000 mov r5, #0 3000a7ac: e584505c str r5, [r4, #92] ; 0x5c
the_mutex->holder_id = 0;
3000a7b0: e5845060 str r5, [r4, #96] ; 0x60
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000a7b4: e1a00004 mov r0, r4 3000a7b8: eb0006ef bl 3000c37c <_Thread_queue_Dequeue> 3000a7bc: e2503000 subs r3, r0, #0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
3000a7c0: 03a02001 moveq r2, #1 3000a7c4: 05842050 streq r2, [r4, #80] ; 0x50
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a7c8: 01a00003 moveq r0, r3
/*
* Now we check if another thread was waiting for this mutex. If so,
* transfer the mutex to that thread.
*/
if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) {
3000a7cc: 08bd8030 popeq {r4, r5, pc}
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a7d0: e5931008 ldr r1, [r3, #8]
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a7d4: e5942048 ldr r2, [r4, #72] ; 0x48
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
3000a7d8: e5841060 str r1, [r4, #96] ; 0x60
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a7dc: e3520002 cmp r2, #2
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000a7e0: e3a01001 mov r1, #1
} else
#endif
{
the_mutex->holder = the_thread;
3000a7e4: e584305c str r3, [r4, #92] ; 0x5c
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
3000a7e8: e5841054 str r1, [r4, #84] ; 0x54
switch ( the_mutex->Attributes.discipline ) {
3000a7ec: 0a000018 beq 3000a854 <_CORE_mutex_Surrender+0x10c>
3000a7f0: e3520003 cmp r2, #3 <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a7f4: 11a00005 movne r0, r5 <== NOT EXECUTED
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
3000a7f8: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a7fc: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a800: e594104c ldr r1, [r4, #76] ; 0x4c <== NOT EXECUTED 3000a804: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a808: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a80c: e151000c cmp r1, ip <== NOT EXECUTED
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a810: e583201c str r2, [r3, #28] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
3000a814: 3a000013 bcc 3000a868 <_CORE_mutex_Surrender+0x120> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a818: e1a00005 mov r0, r5 <== NOT EXECUTED
}
3000a81c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a820: e592301c ldr r3, [r2, #28] 3000a824: e2433001 sub r3, r3, #1
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a828: e3530000 cmp r3, #0
_CORE_mutex_Pop_priority( the_mutex, holder );
if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL )
return pop_status;
holder->resource_count--;
3000a82c: e582301c str r3, [r2, #28]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a830: 1affffdc bne 3000a7a8 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
3000a834: e5921018 ldr r1, [r2, #24]
/*
* Whether or not someone is waiting for the mutex, an
* inherited priority must be lowered if this is the last
* mutex (i.e. resource) this task has.
*/
if ( holder->resource_count == 0 &&
3000a838: e5923014 ldr r3, [r2, #20] 3000a83c: e1510003 cmp r1, r3
3000a840: 0affffd8 beq 3000a7a8 <_CORE_mutex_Surrender+0x60>
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, true );
3000a844: e1a00002 mov r0, r2 3000a848: e3a02001 mov r2, #1 3000a84c: eb0004ef bl 3000bc10 <_Thread_Change_priority> 3000a850: eaffffd4 b 3000a7a8 <_CORE_mutex_Surrender+0x60>
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a854: e593201c ldr r2, [r3, #28]
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a858: e1a00005 mov r0, r5
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
3000a85c: e2822001 add r2, r2, #1 3000a860: e583201c str r2, [r3, #28]
break;
3000a864: e8bd8030 pop {r4, r5, pc}
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
_CORE_mutex_Push_priority( the_mutex, the_thread );
the_thread->resource_count++;
if (the_mutex->Attributes.priority_ceiling <
the_thread->current_priority){
_Thread_Change_priority(
3000a868: e1a02005 mov r2, r5 <== NOT EXECUTED 3000a86c: eb0004e7 bl 3000bc10 <_Thread_Change_priority> <== NOT EXECUTED
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
3000a870: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a874: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000af04 <_Chain_Append_with_empty_check>:
bool _Chain_Append_with_empty_check(
Chain_Control *chain,
Chain_Node *node
)
{
3000af04: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
3000af08: e10fc000 mrs ip, CPSR <== NOT EXECUTED
3000af0c: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED
3000af10: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3000af14: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000af18: e5904000 ldr r4, [r0] <== NOT EXECUTED
== _Chain_Immutable_tail( the_chain );
3000af1c: e2802004 add r2, r0, #4 <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3000af20: e5801008 str r1, [r0, #8] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3000af24: e881000c stm r1, {r2, r3} <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3000af28: e5831000 str r1, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
3000af2c: e1540002 cmp r4, r2 <== NOT EXECUTED 3000af30: 13a00000 movne r0, #0 <== NOT EXECUTED 3000af34: 03a00001 moveq r0, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000af38: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Append_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000af3c: e8bd0010 pop {r4} <== NOT EXECUTED
3000af40: e12fff1e bx lr <== NOT EXECUTED
3000af90 <_Chain_Get_with_empty_check>:
bool _Chain_Get_with_empty_check(
Chain_Control *chain,
Chain_Node **node
)
{
3000af90: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000af94: e10f4000 mrs r4, CPSR <== NOT EXECUTED 3000af98: e3843080 orr r3, r4, #128 ; 0x80 <== NOT EXECUTED 3000af9c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
3000afa0: e5903000 ldr r3, [r0] <== NOT EXECUTED
Chain_Node **the_node
)
{
bool is_empty_now = true;
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000afa4: e280c004 add ip, r0, #4 <== NOT EXECUTED
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000afa8: e15c0003 cmp ip, r3 <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
} else
*the_node = NULL;
3000afac: 03a03000 moveq r3, #0 <== NOT EXECUTED 3000afb0: 05813000 streq r3, [r1] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Get_with_empty_check_unprotected(
Chain_Control *the_chain,
Chain_Node **the_node
)
{
bool is_empty_now = true;
3000afb4: 03a00001 moveq r0, #1 <== NOT EXECUTED
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_first = head->next;
if ( old_first != tail ) {
3000afb8: 0a000006 beq 3000afd8 <_Chain_Get_with_empty_check+0x48> <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
3000afbc: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
3000afc0: e5802000 str r2, [r0] <== NOT EXECUTED
new_first->previous = head;
3000afc4: e5820004 str r0, [r2, #4] <== NOT EXECUTED
*the_node = old_first;
is_empty_now = new_first == tail;
3000afc8: e15c0002 cmp ip, r2 <== NOT EXECUTED 3000afcc: 13a00000 movne r0, #0 <== NOT EXECUTED 3000afd0: 03a00001 moveq r0, #1 <== NOT EXECUTED
Chain_Node *new_first = old_first->next;
head->next = new_first;
new_first->previous = head;
*the_node = old_first;
3000afd4: e5813000 str r3, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000afd8: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Disable( level );
is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return is_empty_now;
}
3000afdc: e8bd0010 pop {r4} <== NOT EXECUTED
3000afe0: e12fff1e bx lr <== NOT EXECUTED
3000b040 <_Chain_Prepend_with_empty_check>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b040: e10fc000 mrs ip, CPSR <== NOT EXECUTED 3000b044: e38c3080 orr r3, ip, #128 ; 0x80 <== NOT EXECUTED 3000b048: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Disable( level );
was_empty = _Chain_Prepend_with_empty_check_unprotected( chain, node );
_ISR_Enable( level );
return was_empty;
}
3000b04c: e5902000 ldr r2, [r0] <== NOT EXECUTED
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
3000b050: e1a03000 mov r3, r0 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000b054: e5810004 str r0, [r1, #4] <== NOT EXECUTED
before_node = after_node->next; after_node->next = the_node;
3000b058: e4831004 str r1, [r3], #4 <== NOT EXECUTED
the_node->next = before_node; before_node->previous = the_node;
3000b05c: e5821004 str r1, [r2, #4] <== NOT EXECUTED
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000b060: e5812000 str r2, [r1] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b064: e129f00c msr CPSR_fc, ip <== NOT EXECUTED 3000b068: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b06c: 13a00000 movne r0, #0 <== NOT EXECUTED 3000b070: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000b074: e12fff1e bx lr <== NOT EXECUTED
300095b4 <_Event_Seize>:
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
300095b4: e59fc0fc ldr ip, [pc, #252] ; 300096b8 <_Event_Seize+0x104>
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
300095b8: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
300095bc: e59c4004 ldr r4, [ip, #4]
executing->Wait.return_code = RTEMS_SUCCESSFUL;
300095c0: e3a0c000 mov ip, #0 300095c4: e584c034 str ip, [r4, #52] ; 0x34
api = executing->API_Extensions[ THREAD_API_RTEMS ];
300095c8: e594c0f4 ldr ip, [r4, #244] ; 0xf4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
300095cc: e10f7000 mrs r7, CPSR 300095d0: e3875080 orr r5, r7, #128 ; 0x80 300095d4: e129f005 msr CPSR_fc, r5
_ISR_Disable( level );
pending_events = api->pending_events;
300095d8: e59c5000 ldr r5, [ip]
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
300095dc: e0106005 ands r6, r0, r5
300095e0: 0a000003 beq 300095f4 <_Event_Seize+0x40>
300095e4: e1500006 cmp r0, r6
300095e8: 0a00001f beq 3000966c <_Event_Seize+0xb8>
(seized_events == event_in || _Options_Is_any( option_set )) ) {
300095ec: e3110002 tst r1, #2 <== NOT EXECUTED 300095f0: 1a00001d bne 3000966c <_Event_Seize+0xb8> <== NOT EXECUTED
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
300095f4: e3110001 tst r1, #1
300095f8: 1a000016 bne 30009658 <_Event_Seize+0xa4>
*/
executing->Wait.option = (uint32_t) option_set;
executing->Wait.count = (uint32_t) event_in;
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
300095fc: e59f50b8 ldr r5, [pc, #184] ; 300096bc <_Event_Seize+0x108>
* NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set; executing->Wait.count = (uint32_t) event_in; executing->Wait.return_argument = event_out;
30009600: e5843028 str r3, [r4, #40] ; 0x28
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009604: e3a03001 mov r3, #1
* set properly when we are marked as in the event critical section. * * NOTE: Since interrupts are disabled, this isn't that much of an * issue but better safe than sorry. */ executing->Wait.option = (uint32_t) option_set;
30009608: e5841030 str r1, [r4, #48] ; 0x30
executing->Wait.count = (uint32_t) event_in;
3000960c: e5840024 str r0, [r4, #36] ; 0x24
executing->Wait.return_argument = event_out;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009610: e5853000 str r3, [r5]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009614: e129f007 msr CPSR_fc, r7
_ISR_Enable( level );
if ( ticks ) {
30009618: e3520000 cmp r2, #0
3000961c: 1a000019 bne 30009688 <_Event_Seize+0xd4>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
30009620: e1a00004 mov r0, r4 30009624: e3a01c01 mov r1, #256 ; 0x100 30009628: eb000cad bl 3000c8e4 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000962c: e10f2000 mrs r2, CPSR 30009630: e3823080 orr r3, r2, #128 ; 0x80 30009634: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
sync_state = _Event_Sync_state;
30009638: e5950000 ldr r0, [r5]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000963c: e3a03000 mov r3, #0
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009640: e3500001 cmp r0, #1
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
_ISR_Disable( level );
sync_state = _Event_Sync_state;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
30009644: e5853000 str r3, [r5]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
30009648: 0a00000c beq 30009680 <_Event_Seize+0xcc>
* An interrupt completed the thread's blocking request.
* The blocking thread was satisfied by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
_Thread_blocking_operation_Cancel( sync_state, executing, level );
3000964c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
30009650: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
* An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level );
30009654: ea000957 b 3000bbb8 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009658: e129f007 msr CPSR_fc, r7
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
executing->Wait.return_code = RTEMS_UNSATISFIED;
3000965c: e3a0200d mov r2, #13 30009660: e5842034 str r2, [r4, #52] ; 0x34
*event_out = seized_events;
30009664: e5836000 str r6, [r3]
return;
30009668: e8bd80f0 pop {r4, r5, r6, r7, pc}
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
3000966c: e1c55006 bic r5, r5, r6
pending_events = api->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
30009670: e58c5000 str r5, [ip] 30009674: e129f007 msr CPSR_fc, r7
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
*event_out = seized_events;
30009678: e5836000 str r6, [r3]
return;
3000967c: e8bd80f0 pop {r4, r5, r6, r7, pc}
30009680: e129f002 msr CPSR_fc, r2
30009684: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
_ISR_Enable( level );
if ( ticks ) {
_Watchdog_Initialize(
30009688: e5941008 ldr r1, [r4, #8]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000968c: e59f002c ldr r0, [pc, #44] ; 300096c0 <_Event_Seize+0x10c>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
30009690: e3a03000 mov r3, #0
the_watchdog->routine = routine;
30009694: e5840064 str r0, [r4, #100] ; 0x64
the_watchdog->id = id;
30009698: e5841068 str r1, [r4, #104] ; 0x68
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000969c: e5843050 str r3, [r4, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
300096a0: e584306c str r3, [r4, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
300096a4: e5842054 str r2, [r4, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
300096a8: e59f0014 ldr r0, [pc, #20] ; 300096c4 <_Event_Seize+0x110> 300096ac: e2841048 add r1, r4, #72 ; 0x48 300096b0: eb000ded bl 3000ce6c <_Watchdog_Insert> 300096b4: eaffffd9 b 30009620 <_Event_Seize+0x6c>
30009720 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
30009720: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_event_set event_condition;
rtems_event_set seized_events;
rtems_option option_set;
RTEMS_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
30009724: e59010f4 ldr r1, [r0, #244] ; 0xf4
option_set = (rtems_option) the_thread->Wait.option;
30009728: e5906030 ldr r6, [r0, #48] ; 0x30
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
3000972c: e1a04000 mov r4, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009730: e10f0000 mrs r0, CPSR 30009734: e3803080 orr r3, r0, #128 ; 0x80 30009738: e129f003 msr CPSR_fc, r3
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
pending_events = api->pending_events;
3000973c: e5912000 ldr r2, [r1]
event_condition = (rtems_event_set) the_thread->Wait.count;
30009740: e5943024 ldr r3, [r4, #36] ; 0x24
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
30009744: e013c002 ands ip, r3, r2
30009748: 0a000020 beq 300097d0 <_Event_Surrender+0xb0>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
3000974c: e59f50fc ldr r5, [pc, #252] ; 30009850 <_Event_Surrender+0x130> 30009750: e5957000 ldr r7, [r5] 30009754: e3570000 cmp r7, #0
30009758: 0a000002 beq 30009768 <_Event_Surrender+0x48>
3000975c: e5955004 ldr r5, [r5, #4] <== NOT EXECUTED 30009760: e1540005 cmp r4, r5 <== NOT EXECUTED 30009764: 0a000024 beq 300097fc <_Event_Surrender+0xdc> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
30009768: e5945010 ldr r5, [r4, #16]
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
3000976c: e3150c01 tst r5, #256 ; 0x100
30009770: 0a000014 beq 300097c8 <_Event_Surrender+0xa8>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
30009774: e153000c cmp r3, ip
30009778: 0a000001 beq 30009784 <_Event_Surrender+0x64>
3000977c: e3160002 tst r6, #2 <== NOT EXECUTED 30009780: 0a000010 beq 300097c8 <_Event_Surrender+0xa8> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009784: e5943028 ldr r3, [r4, #40] ; 0x28
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
30009788: e1c2200c bic r2, r2, ip
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
3000978c: e5812000 str r2, [r1]
the_thread->Wait.count = 0;
30009790: e3a02000 mov r2, #0 30009794: e5842024 str r2, [r4, #36] ; 0x24
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009798: e583c000 str ip, [r3]
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000979c: e10f3000 mrs r3, CPSR 300097a0: e129f000 msr CPSR_fc, r0 300097a4: e129f003 msr CPSR_fc, r3
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
300097a8: e5943050 ldr r3, [r4, #80] ; 0x50 300097ac: e3530002 cmp r3, #2
300097b0: 0a000008 beq 300097d8 <_Event_Surrender+0xb8>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300097b4: e129f000 msr CPSR_fc, r0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
300097b8: e59f1094 ldr r1, [pc, #148] ; 30009854 <_Event_Surrender+0x134> 300097bc: e1a00004 mov r0, r4
}
return;
}
}
_ISR_Enable( level );
}
300097c0: e8bd40f0 pop {r4, r5, r6, r7, lr}
300097c4: ea000951 b 3000bd10 <_Thread_Clear_state>
300097c8: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
300097cc: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
300097d0: e129f000 msr CPSR_fc, r0
300097d4: e8bd80f0 pop {r4, r5, r6, r7, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
300097d8: e3a03003 mov r3, #3 <== NOT EXECUTED 300097dc: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 300097e0: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300097e4: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 300097e8: eb000e0e bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 300097ec: e59f1060 ldr r1, [pc, #96] ; 30009854 <_Event_Surrender+0x134><== NOT EXECUTED 300097f0: e1a00004 mov r0, r4 <== NOT EXECUTED
}
return;
}
}
_ISR_Enable( level );
}
300097f4: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
300097f8: ea000944 b 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
300097fc: e59f5054 ldr r5, [pc, #84] ; 30009858 <_Event_Surrender+0x138><== NOT EXECUTED 30009800: e5957000 ldr r7, [r5] <== NOT EXECUTED
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
30009804: e3570002 cmp r7, #2 <== NOT EXECUTED 30009808: 0a000002 beq 30009818 <_Event_Surrender+0xf8> <== NOT EXECUTED
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
3000980c: e5957000 ldr r7, [r5] <== NOT EXECUTED
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
30009810: e3570001 cmp r7, #1 <== NOT EXECUTED 30009814: 1affffd3 bne 30009768 <_Event_Surrender+0x48> <== NOT EXECUTED
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
30009818: e153000c cmp r3, ip <== NOT EXECUTED 3000981c: 0a000001 beq 30009828 <_Event_Surrender+0x108> <== NOT EXECUTED 30009820: e3160002 tst r6, #2 <== NOT EXECUTED 30009824: 0a000007 beq 30009848 <_Event_Surrender+0x128> <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
30009828: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 3000982c: e1c2200c bic r2, r2, ip <== NOT EXECUTED
if ( _ISR_Is_in_progress() &&
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
30009830: e5812000 str r2, [r1] <== NOT EXECUTED
the_thread->Wait.count = 0;
30009834: e3a02000 mov r2, #0 <== NOT EXECUTED 30009838: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
3000983c: e583c000 str ip, [r3] <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
30009840: e3a03003 mov r3, #3 <== NOT EXECUTED
30009844: e5853000 str r3, [r5] <== NOT EXECUTED
30009848: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
3000984c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000985c <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
3000985c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30009860: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
30009864: e1a0100d mov r1, sp <== NOT EXECUTED 30009868: eb000a0e bl 3000c0a8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000986c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30009870: e3530000 cmp r3, #0 <== NOT EXECUTED 30009874: 1a000010 bne 300098bc <_Event_Timeout+0x60> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009878: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000987c: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30009880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
30009884: e5803024 str r3, [r0, #36] ; 0x24 <== NOT EXECUTED
if ( _Thread_Is_executing( the_thread ) ) {
30009888: e59f304c ldr r3, [pc, #76] ; 300098dc <_Event_Timeout+0x80><== NOT EXECUTED 3000988c: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30009890: e1500003 cmp r0, r3 <== NOT EXECUTED 30009894: 0a00000a beq 300098c4 <_Event_Timeout+0x68> <== NOT EXECUTED
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
30009898: e3a03006 mov r3, #6 <== NOT EXECUTED 3000989c: e5803034 str r3, [r0, #52] ; 0x34 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300098a0: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 300098a4: e59f1034 ldr r1, [pc, #52] ; 300098e0 <_Event_Timeout+0x84><== NOT EXECUTED 300098a8: eb000918 bl 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
300098ac: e59f3030 ldr r3, [pc, #48] ; 300098e4 <_Event_Timeout+0x88><== NOT EXECUTED 300098b0: e5932000 ldr r2, [r3] <== NOT EXECUTED 300098b4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 300098b8: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
300098bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300098c0: e8bd8000 pop {pc} <== NOT EXECUTED
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
300098c4: e59f301c ldr r3, [pc, #28] ; 300098e8 <_Event_Timeout+0x8c><== NOT EXECUTED 300098c8: e5931000 ldr r1, [r3] <== NOT EXECUTED 300098cc: e3510001 cmp r1, #1 <== NOT EXECUTED
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
300098d0: 03a01002 moveq r1, #2 <== NOT EXECUTED 300098d4: 05831000 streq r1, [r3] <== NOT EXECUTED 300098d8: eaffffee b 30009898 <_Event_Timeout+0x3c> <== NOT EXECUTED
3000f370 <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f370: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000f374: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
3000f378: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f37c: e24dd01c sub sp, sp, #28 3000f380: e1a05001 mov r5, r1
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000f384: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f388: e1a07000 mov r7, r0
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000f38c: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000f390: e1a0b003 mov fp, r3
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_ALLOC_BONUS;
uintptr_t const page_size = heap->page_size;
3000f394: e58d200c str r2, [sp, #12]
Heap_Block *block = NULL;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
bool search_again = false;
if ( block_size_floor < alloc_size ) {
3000f398: 2a000078 bcs 3000f580 <_Heap_Allocate_aligned_with_boundary+0x210>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
3000f39c: e3530000 cmp r3, #0
3000f3a0: 1a000074 bne 3000f578 <_Heap_Allocate_aligned_with_boundary+0x208>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f3a4: e5979008 ldr r9, [r7, #8]
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f3a8: e1570009 cmp r7, r9
3000f3ac: 0a000073 beq 3000f580 <_Heap_Allocate_aligned_with_boundary+0x210>
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f3b0: e59d300c ldr r3, [sp, #12]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f3b4: e2651004 rsb r1, r5, #4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f3b8: e2833007 add r3, r3, #7
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f3bc: e3a06001 mov r6, #1
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f3c0: e58d3010 str r3, [sp, #16]
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
3000f3c4: e58d1014 str r1, [sp, #20]
/*
* 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 ) {
3000f3c8: e599a004 ldr sl, [r9, #4] 3000f3cc: e59d2000 ldr r2, [sp] 3000f3d0: e152000a cmp r2, sl
3000f3d4: 2a00004e bcs 3000f514 <_Heap_Allocate_aligned_with_boundary+0x1a4>
if ( alignment == 0 ) {
3000f3d8: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000f3dc: 02894008 addeq r4, r9, #8
3000f3e0: 0a000051 beq 3000f52c <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f3e4: e5973014 ldr r3, [r7, #20]
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f3e8: e59d1014 ldr r1, [sp, #20]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000f3ec: e59d2010 ldr r2, [sp, #16]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f3f0: e3caa001 bic sl, sl, #1
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
3000f3f4: e089a00a add sl, r9, sl
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS;
uintptr_t alloc_begin = alloc_end - alloc_size;
3000f3f8: e081400a add r4, r1, sl
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
}
return (void *) alloc_begin;
}
3000f3fc: e58d3004 str r3, [sp, #4]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
3000f400: e0633002 rsb r3, r3, r2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f404: e1a00004 mov r0, r4
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
3000f408: e083a00a add sl, r3, sl 3000f40c: e1a01008 mov r1, r8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000f410: e2893008 add r3, r9, #8 3000f414: e58d3008 str r3, [sp, #8]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f418: eb00154b bl 3001494c <__umodsi3> 3000f41c: e0604004 rsb r4, r0, r4
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
3000f420: e15a0004 cmp sl, r4
3000f424: 2a000003 bcs 3000f438 <_Heap_Allocate_aligned_with_boundary+0xc8>
3000f428: e1a0000a mov r0, sl <== NOT EXECUTED 3000f42c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000f430: eb001545 bl 3001494c <__umodsi3> <== NOT EXECUTED 3000f434: e060400a rsb r4, r0, sl <== NOT EXECUTED
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
3000f438: e35b0000 cmp fp, #0
3000f43c: 0a000026 beq 3000f4dc <_Heap_Allocate_aligned_with_boundary+0x16c>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
3000f440: e084a005 add sl, r4, r5 <== NOT EXECUTED 3000f444: e1a0000a mov r0, sl <== NOT EXECUTED 3000f448: e1a0100b mov r1, fp <== NOT EXECUTED 3000f44c: eb00153e bl 3001494c <__umodsi3> <== NOT EXECUTED 3000f450: e060000a rsb r0, r0, sl <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
3000f454: e15a0000 cmp sl, r0 <== NOT EXECUTED 3000f458: 93a0a000 movls sl, #0 <== NOT EXECUTED 3000f45c: 83a0a001 movhi sl, #1 <== NOT EXECUTED 3000f460: e1540000 cmp r4, r0 <== NOT EXECUTED 3000f464: 23a0a000 movcs sl, #0 <== NOT EXECUTED 3000f468: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000f46c: 0a00001a beq 3000f4dc <_Heap_Allocate_aligned_with_boundary+0x16c><== NOT EXECUTED
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
3000f470: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000f474: e0813005 add r3, r1, r5 <== NOT EXECUTED
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
3000f478: e1530000 cmp r3, r0 <== NOT EXECUTED 3000f47c: 958d9018 strls r9, [sp, #24] <== NOT EXECUTED 3000f480: 91a09003 movls r9, r3 <== NOT EXECUTED 3000f484: 9a000002 bls 3000f494 <_Heap_Allocate_aligned_with_boundary+0x124><== NOT EXECUTED 3000f488: ea000021 b 3000f514 <_Heap_Allocate_aligned_with_boundary+0x1a4><== NOT EXECUTED 3000f48c: e1590000 cmp r9, r0 <== NOT EXECUTED 3000f490: 8a00003c bhi 3000f588 <_Heap_Allocate_aligned_with_boundary+0x218><== NOT EXECUTED
return 0;
}
alloc_begin = boundary_line - alloc_size;
3000f494: e0654000 rsb r4, r5, r0 <== NOT EXECUTED 3000f498: e1a01008 mov r1, r8 <== NOT EXECUTED 3000f49c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f4a0: eb001529 bl 3001494c <__umodsi3> <== NOT EXECUTED 3000f4a4: e0604004 rsb r4, r0, r4 <== NOT EXECUTED
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
3000f4a8: e084a005 add sl, r4, r5 <== NOT EXECUTED 3000f4ac: e1a0000a mov r0, sl <== NOT EXECUTED 3000f4b0: e1a0100b mov r1, fp <== NOT EXECUTED 3000f4b4: eb001524 bl 3001494c <__umodsi3> <== NOT EXECUTED 3000f4b8: e060000a rsb r0, r0, sl <== NOT EXECUTED
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
3000f4bc: e15a0000 cmp sl, r0 <== NOT EXECUTED 3000f4c0: 93a0a000 movls sl, #0 <== NOT EXECUTED 3000f4c4: 83a0a001 movhi sl, #1 <== NOT EXECUTED 3000f4c8: e1540000 cmp r4, r0 <== NOT EXECUTED 3000f4cc: 23a0a000 movcs sl, #0 <== NOT EXECUTED 3000f4d0: e35a0000 cmp sl, #0 <== NOT EXECUTED 3000f4d4: 1affffec bne 3000f48c <_Heap_Allocate_aligned_with_boundary+0x11c><== NOT EXECUTED 3000f4d8: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
3000f4dc: e59d2008 ldr r2, [sp, #8] 3000f4e0: e1520004 cmp r2, r4
3000f4e4: 8a00000a bhi 3000f514 <_Heap_Allocate_aligned_with_boundary+0x1a4>
3000f4e8: e59d100c ldr r1, [sp, #12] 3000f4ec: e1a00004 mov r0, r4 3000f4f0: eb001515 bl 3001494c <__umodsi3> 3000f4f4: e3e0a007 mvn sl, #7 3000f4f8: e069a00a rsb sl, r9, sl
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f4fc: e08aa004 add sl, sl, r4
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
if ( free_size >= min_block_size || free_size == 0 ) {
3000f500: e59d1004 ldr r1, [sp, #4] 3000f504: e060300a rsb r3, r0, sl 3000f508: e15a0000 cmp sl, r0 3000f50c: 11510003 cmpne r1, r3
3000f510: 9a000005 bls 3000f52c <_Heap_Allocate_aligned_with_boundary+0x1bc>
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000f514: e5999008 ldr r9, [r9, #8] 3000f518: e2863001 add r3, r6, #1
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f51c: e1570009 cmp r7, r9
3000f520: 0a00001d beq 3000f59c <_Heap_Allocate_aligned_with_boundary+0x22c>
3000f524: e1a06003 mov r6, r3 3000f528: eaffffa6 b 3000f3c8 <_Heap_Allocate_aligned_with_boundary+0x58>
}
/* Statistics */
++search_count;
if ( alloc_begin != 0 ) {
3000f52c: e3540000 cmp r4, #0
3000f530: 0afffff7 beq 3000f514 <_Heap_Allocate_aligned_with_boundary+0x1a4>
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f534: e5972048 ldr r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000f538: e597304c ldr r3, [r7, #76] ; 0x4c
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f53c: e2822001 add r2, r2, #1
stats->searches += search_count;
3000f540: e0833006 add r3, r3, r6
search_again = _Heap_Protection_free_delayed_blocks( heap, alloc_begin );
} while ( search_again );
if ( alloc_begin != 0 ) {
/* Statistics */
++stats->allocs;
3000f544: e5872048 str r2, [r7, #72] ; 0x48
stats->searches += search_count;
3000f548: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
3000f54c: e1a00007 mov r0, r7 3000f550: e1a01009 mov r1, r9 3000f554: e1a02004 mov r2, r4 3000f558: e1a03005 mov r3, r5 3000f55c: ebffeddf bl 3000ace0 <_Heap_Block_allocate> 3000f560: e1a00004 mov r0, r4
boundary
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
3000f564: e5973044 ldr r3, [r7, #68] ; 0x44 3000f568: e1530006 cmp r3, r6
stats->max_search = search_count;
3000f56c: 35876044 strcc r6, [r7, #68] ; 0x44
}
return (void *) alloc_begin;
}
3000f570: e28dd01c add sp, sp, #28
3000f574: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
3000f578: e1550003 cmp r5, r3 <== NOT EXECUTED 3000f57c: 9a000008 bls 3000f5a4 <_Heap_Allocate_aligned_with_boundary+0x234><== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f580: e3a00000 mov r0, #0 3000f584: eafffff9 b 3000f570 <_Heap_Allocate_aligned_with_boundary+0x200>
3000f588: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
if ( alloc_begin != 0 ) {
break;
}
block = block->next;
3000f58c: e2863001 add r3, r6, #1 <== NOT EXECUTED 3000f590: e5999008 ldr r9, [r9, #8] <== NOT EXECUTED
do {
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
block = _Heap_Free_list_first( heap );
while ( block != free_list_tail ) {
3000f594: e1570009 cmp r7, r9 <== NOT EXECUTED 3000f598: 1affffe1 bne 3000f524 <_Heap_Allocate_aligned_with_boundary+0x1b4><== NOT EXECUTED
3000f59c: e3a00000 mov r0, #0 3000f5a0: eaffffef b 3000f564 <_Heap_Allocate_aligned_with_boundary+0x1f4>
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
alignment = page_size;
3000f5a4: e3580000 cmp r8, #0 <== NOT EXECUTED 3000f5a8: 01a08002 moveq r8, r2 <== NOT EXECUTED 3000f5ac: eaffff7c b 3000f3a4 <_Heap_Allocate_aligned_with_boundary+0x34><== NOT EXECUTED
3000ace0 <_Heap_Block_allocate>:
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ace0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ace4: e5917004 ldr r7, [r1, #4]
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ace8: e1a05001 mov r5, r1
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000acec: e3c71001 bic r1, r7, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000acf0: e0858001 add r8, r5, r1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000acf4: e598c004 ldr ip, [r8, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
3000acf8: e2426008 sub r6, r2, #8
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000acfc: e31c0001 tst ip, #1
Heap_Control *heap,
Heap_Block *block,
uintptr_t alloc_begin,
uintptr_t alloc_size
)
{
3000ad00: e1a0a003 mov sl, r3 3000ad04: e1a04000 mov r4, r0
Heap_Statistics *const stats = &heap->stats;
uintptr_t const alloc_area_begin = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_area_offset = alloc_begin - alloc_area_begin;
3000ad08: e0653006 rsb r3, r5, r6
/* Statistics */
--stats->free_blocks;
++stats->used_blocks;
stats->free_size -= _Heap_Block_size( block );
} else {
free_list_anchor = _Heap_Free_list_head( heap );
3000ad0c: 11a09000 movne r9, r0
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
3000ad10: 1a00000c bne 3000ad48 <_Heap_Block_allocate+0x68>
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad14: e590e038 ldr lr, [r0, #56] ; 0x38
++stats->used_blocks;
3000ad18: e590c040 ldr ip, [r0, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000ad1c: e590b030 ldr fp, [r0, #48] ; 0x30
Heap_Block *free_list_anchor = NULL;
_HAssert( alloc_area_begin <= alloc_begin );
if ( _Heap_Is_free( block ) ) {
free_list_anchor = block->prev;
3000ad20: e595900c ldr r9, [r5, #12]
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ad24: e5950008 ldr r0, [r5, #8]
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad28: e24ee001 sub lr, lr, #1
++stats->used_blocks;
3000ad2c: e28cc001 add ip, ip, #1
stats->free_size -= _Heap_Block_size( block );
3000ad30: e061100b rsb r1, r1, fp
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000ad34: e5890008 str r0, [r9, #8]
next->prev = prev;
3000ad38: e580900c str r9, [r0, #12]
free_list_anchor = block->prev;
_Heap_Free_list_remove( block );
/* Statistics */
--stats->free_blocks;
3000ad3c: e584e038 str lr, [r4, #56] ; 0x38
++stats->used_blocks;
3000ad40: e584c040 str ip, [r4, #64] ; 0x40
stats->free_size -= _Heap_Block_size( block );
3000ad44: e5841030 str r1, [r4, #48] ; 0x30
} else {
free_list_anchor = _Heap_Free_list_head( heap );
}
if ( alloc_area_offset < heap->page_size ) {
3000ad48: e5941010 ldr r1, [r4, #16] 3000ad4c: e1530001 cmp r3, r1
3000ad50: 3a000027 bcc 3000adf4 <_Heap_Block_allocate+0x114>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000ad54: e1a00002 mov r0, r2 3000ad58: eb0026fb bl 3001494c <__umodsi3>
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000ad5c: e5943030 ldr r3, [r4, #48] ; 0x30
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000ad60: e0606006 rsb r6, r0, r6
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
block_end = new_block_begin;
block_size = block_end - block_begin;
3000ad64: e0651006 rsb r1, r5, r6
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000ad68: e0833001 add r3, r3, r1
if ( _Heap_Is_prev_used( block ) ) {
3000ad6c: e3170001 tst r7, #1
uintptr_t block_end = block_begin + block_size;
Heap_Block *const new_block =
_Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
uintptr_t const new_block_begin = (uintptr_t) new_block;
uintptr_t const new_block_size = block_end - new_block_begin;
3000ad70: e0668008 rsb r8, r6, r8
_HAssert( block_size >= heap->min_block_size );
_HAssert( new_block_size >= heap->min_block_size );
/* Statistics */
stats->free_size += block_size;
3000ad74: e5843030 str r3, [r4, #48] ; 0x30
if ( _Heap_Is_prev_used( block ) ) {
3000ad78: 1a000013 bne 3000adcc <_Heap_Block_allocate+0xec>
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Prev_block(
const Heap_Block *block
)
{
return (Heap_Block *) ((uintptr_t) block - block->prev_size);
3000ad7c: e5953000 ldr r3, [r5] <== NOT EXECUTED
} else {
Heap_Block *const prev_block = _Heap_Prev_block( block );
uintptr_t const prev_block_size = _Heap_Block_size( prev_block );
block = prev_block;
block_size += prev_block_size;
3000ad80: e1a02009 mov r2, r9 <== NOT EXECUTED 3000ad84: e0635005 rsb r5, r3, r5 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000ad88: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000ad8c: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000ad90: e0811003 add r1, r1, r3 <== NOT EXECUTED
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000ad94: e3813001 orr r3, r1, #1 3000ad98: e5853004 str r3, [r5, #4]
new_block->prev_size = block_size;
3000ad9c: e5861000 str r1, [r6]
new_block->size_and_flag = new_block_size;
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000ada0: e1a00004 mov r0, r4 3000ada4: e1a0300a mov r3, sl
}
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
new_block->prev_size = block_size;
new_block->size_and_flag = new_block_size;
3000ada8: e5868004 str r8, [r6, #4]
_Heap_Block_split( heap, new_block, free_list_anchor, alloc_size );
3000adac: e1a01006 mov r1, r6 3000adb0: ebffff1a bl 3000aa20 <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000adb4: e5943030 ldr r3, [r4, #48] ; 0x30 3000adb8: e5942034 ldr r2, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000adbc: e1a00006 mov r0, r6
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000adc0: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000adc4: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000adc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
_Heap_Free_list_insert_after( free_list_anchor, block );
free_list_anchor = block;
/* Statistics */
++stats->free_blocks;
3000adcc: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000add0: e5993008 ldr r3, [r9, #8] 3000add4: e2800001 add r0, r0, #1
new_block->next = next;
3000add8: e5853008 str r3, [r5, #8]
new_block->prev = block_before;
3000addc: e585900c str r9, [r5, #12]
block_before->next = new_block;
3000ade0: e5895008 str r5, [r9, #8]
next->prev = new_block;
3000ade4: e583500c str r5, [r3, #12] 3000ade8: e1a02005 mov r2, r5 3000adec: e5840038 str r0, [r4, #56] ; 0x38 3000adf0: eaffffe7 b 3000ad94 <_Heap_Block_allocate+0xb4>
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000adf4: e1a00004 mov r0, r4 3000adf8: e1a02009 mov r2, r9 3000adfc: e083300a add r3, r3, sl 3000ae00: e1a01005 mov r1, r5 3000ae04: ebffff05 bl 3000aa20 <_Heap_Block_split>
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae08: e5943030 ldr r3, [r4, #48] ; 0x30 3000ae0c: e5942034 ldr r2, [r4, #52] ; 0x34
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
_Heap_Block_split( heap, block, free_list_anchor, alloc_size );
3000ae10: e1a06005 mov r6, r5
alloc_size
);
}
/* Statistics */
if ( stats->min_free_size > stats->free_size ) {
3000ae14: e1520003 cmp r2, r3
stats->min_free_size = stats->free_size;
3000ae18: 85843034 strhi r3, [r4, #52] ; 0x34
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000ae1c: e1a00006 mov r0, r6
3000ae20: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000aa20 <_Heap_Block_split>:
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000aa20: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000aa24: e5905014 ldr r5, [r0, #20]
uintptr_t alloc_size
)
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const page_size = heap->page_size;
3000aa28: e5906010 ldr r6, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; uintptr_t const min_alloc_size = min_block_size - HEAP_BLOCK_HEADER_SIZE;
3000aa2c: e2458008 sub r8, r5, #8
return heap->stats.size;
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Max( uintptr_t a, uintptr_t b )
{
return a > b ? a : b;
3000aa30: e1530008 cmp r3, r8 3000aa34: 21a08003 movcs r8, r3
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const used_size =
3000aa38: e2888008 add r8, r8, #8
Heap_Control *heap,
Heap_Block *block,
Heap_Block *free_list_anchor,
uintptr_t alloc_size
)
{
3000aa3c: e1a07001 mov r7, r1 3000aa40: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000aa44: e1a01006 mov r1, r6 3000aa48: e1a00008 mov r0, r8 3000aa4c: e1a09002 mov r9, r2 3000aa50: eb0027bd bl 3001494c <__umodsi3>
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000aa54: e597a004 ldr sl, [r7, #4]
if ( remainder != 0 ) {
3000aa58: e3500000 cmp r0, #0
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000aa5c: e3ca2001 bic r2, sl, #1
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000aa60: e2823004 add r3, r2, #4
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000aa64: 10886006 addne r6, r8, r6
} else {
return value;
3000aa68: 01a06008 moveq r6, r8
uintptr_t const free_size_limit = min_block_size + HEAP_ALLOC_BONUS;
3000aa6c: e2855004 add r5, r5, #4
uintptr_t const used_size =
_Heap_Max( alloc_size, min_alloc_size ) + HEAP_BLOCK_HEADER_SIZE;
uintptr_t const used_block_size = _Heap_Align_up( used_size, page_size );
uintptr_t const free_size = block_size + HEAP_ALLOC_BONUS - used_size;
3000aa70: e0688003 rsb r8, r8, r3
)
{
uintptr_t remainder = value % alignment;
if ( remainder != 0 ) {
return value - remainder + alignment;
3000aa74: 10606006 rsbne r6, r0, r6
Heap_Block *next_block = _Heap_Block_at( block, block_size );
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
3000aa78: e1580005 cmp r8, r5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000aa7c: e0873002 add r3, r7, r2
3000aa80: 3a00001c bcc 3000aaf8 <_Heap_Block_split+0xd8>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000aa84: e20aa001 and sl, sl, #1
block->size_and_flag = size | flag;
3000aa88: e186a00a orr sl, r6, sl 3000aa8c: e587a004 str sl, [r7, #4]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000aa90: e5931004 ldr r1, [r3, #4]
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000aa94: e5940030 ldr r0, [r4, #48] ; 0x30 3000aa98: e3c11001 bic r1, r1, #1
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000aa9c: e083c001 add ip, r3, r1
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000aaa0: e59cc004 ldr ip, [ip, #4]
_HAssert( used_size <= block_size + HEAP_ALLOC_BONUS );
_HAssert( used_size + free_size == block_size + HEAP_ALLOC_BONUS );
if ( free_size >= free_size_limit ) {
Heap_Block *const free_block = _Heap_Block_at( block, used_block_size );
uintptr_t free_block_size = block_size - used_block_size;
3000aaa4: e0662002 rsb r2, r6, r2
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000aaa8: e0800002 add r0, r0, r2
if ( _Heap_Is_used( next_block ) ) {
3000aaac: e31c0001 tst ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000aab0: e0867007 add r7, r6, r7
_HAssert( used_block_size + free_block_size == block_size );
_Heap_Block_set_size( block, used_block_size );
/* Statistics */
stats->free_size += free_block_size;
3000aab4: e5840030 str r0, [r4, #48] ; 0x30
if ( _Heap_Is_used( next_block ) ) {
3000aab8: 1a000012 bne 3000ab08 <_Heap_Block_split+0xe8>
}
_Heap_Protection_block_initialize( heap, block );
return block;
}
3000aabc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000aac0: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
} else {
uintptr_t const next_block_size = _Heap_Block_size( next_block );
_Heap_Free_list_replace( next_block, free_block );
free_block_size += next_block_size;
3000aac4: e0822001 add r2, r2, r1 <== NOT EXECUTED
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
3000aac8: e587300c str r3, [r7, #12] <== NOT EXECUTED
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000aacc: e5870008 str r0, [r7, #8] <== NOT EXECUTED
new_block->prev = prev;
next->prev = new_block;
3000aad0: e580700c str r7, [r0, #12] <== NOT EXECUTED
prev->next = new_block;
3000aad4: e5837008 str r7, [r3, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000aad8: e0823007 add r3, r2, r7 <== NOT EXECUTED
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
3000aadc: e3821001 orr r1, r2, #1 3000aae0: e5871004 str r1, [r7, #4]
next_block->prev_size = free_block_size;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000aae4: e5931004 ldr r1, [r3, #4]
next_block = _Heap_Block_at( free_block, free_block_size );
}
free_block->size_and_flag = free_block_size | HEAP_PREV_BLOCK_USED;
next_block->prev_size = free_block_size;
3000aae8: e5832000 str r2, [r3]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000aaec: e3c12001 bic r2, r1, #1
3000aaf0: e5832004 str r2, [r3, #4]
3000aaf4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
_Heap_Protection_block_initialize( heap, free_block );
} else {
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000aaf8: e5932004 ldr r2, [r3, #4]
3000aafc: e3822001 orr r2, r2, #1
3000ab00: e5832004 str r2, [r3, #4]
3000ab04: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( _Heap_Is_used( next_block ) ) {
_Heap_Free_list_insert_after( free_list_anchor, free_block );
/* Statistics */
++stats->free_blocks;
3000ab08: e5940038 ldr r0, [r4, #56] ; 0x38
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000ab0c: e5991008 ldr r1, [r9, #8] 3000ab10: e2800001 add r0, r0, #1
new_block->next = next;
3000ab14: e5871008 str r1, [r7, #8]
new_block->prev = block_before;
3000ab18: e587900c str r9, [r7, #12]
block_before->next = new_block;
3000ab1c: e5897008 str r7, [r9, #8]
next->prev = new_block;
3000ab20: e581700c str r7, [r1, #12] 3000ab24: e5840038 str r0, [r4, #56] ; 0x38 3000ab28: eaffffeb b 3000aadc <_Heap_Block_split+0xbc>
3000f8f4 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000f8f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3000f8f8: e1a05000 mov r5, r0 <== NOT EXECUTED
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 ) {
3000f8fc: e0916002 adds r6, r1, r2 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000f900: e1a04001 mov r4, r1 <== NOT EXECUTED
Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block;
3000f904: e5908020 ldr r8, [r0, #32] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL; 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; uintptr_t const free_size = stats->free_size;
3000f908: e5951030 ldr r1, [r5, #48] ; 0x30 <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000f90c: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000f910: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
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;
3000f914: e3a07000 mov r7, #0 <== NOT EXECUTED
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
3000f918: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; Heap_Block *extend_last_block = NULL; uintptr_t const page_size = heap->page_size;
3000f91c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
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;
3000f920: e58d7020 str r7, [sp, #32] <== NOT EXECUTED
Heap_Block *extend_last_block = NULL;
3000f924: e58d701c str r7, [sp, #28] <== NOT EXECUTED
uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size;
3000f928: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; uintptr_t const free_size = stats->free_size;
3000f92c: e58d1018 str r1, [sp, #24] <== NOT EXECUTED
uintptr_t extend_first_block_size = 0;
uintptr_t extended_size = 0;
bool extend_area_ok = false;
if ( extend_area_end < extend_area_begin ) {
return false;
3000f930: 21a00007 movcs r0, r7 <== NOT EXECUTED
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 ) {
3000f934: 3a000001 bcc 3000f940 <_Heap_Extend+0x4c> <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
3000f938: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000f93c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( extend_area_end < extend_area_begin ) {
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
3000f940: e28dc020 add ip, sp, #32 <== NOT EXECUTED 3000f944: e1a01002 mov r1, r2 <== NOT EXECUTED 3000f948: e58dc000 str ip, [sp] <== NOT EXECUTED 3000f94c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f950: e28dc01c add ip, sp, #28 <== NOT EXECUTED 3000f954: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3000f958: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000f95c: ebffed49 bl 3000ae88 <_Heap_Get_first_and_last_block> <== NOT EXECUTED
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
3000f960: e3500000 cmp r0, #0 <== NOT EXECUTED 3000f964: 0afffff3 beq 3000f938 <_Heap_Extend+0x44> <== NOT EXECUTED 3000f968: e1a09008 mov r9, r8 <== NOT EXECUTED 3000f96c: e1a0b007 mov fp, r7 <== NOT EXECUTED 3000f970: e58d700c str r7, [sp, #12] <== NOT EXECUTED 3000f974: e58d7014 str r7, [sp, #20] <== NOT EXECUTED
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
3000f978: e1590008 cmp r9, r8 <== NOT EXECUTED 3000f97c: 05953018 ldreq r3, [r5, #24] <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
3000f980: e599a000 ldr sl, [r9] <== NOT EXECUTED
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
3000f984: 11a03009 movne r3, r9 <== NOT EXECUTED
uintptr_t const sub_area_end = start_block->prev_size;
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
3000f988: e1530006 cmp r3, r6 <== NOT EXECUTED 3000f98c: 3154000a cmpcc r4, sl <== NOT EXECUTED 3000f990: 3a00006c bcc 3000fb48 <_Heap_Extend+0x254> <== NOT EXECUTED
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
3000f994: e1530006 cmp r3, r6 <== NOT EXECUTED 3000f998: 058d9014 streq r9, [sp, #20] <== NOT EXECUTED 3000f99c: 0a000001 beq 3000f9a8 <_Heap_Extend+0xb4> <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
3000f9a0: e156000a cmp r6, sl <== NOT EXECUTED 3000f9a4: 31a0b009 movcc fp, r9 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f9a8: e1a0000a mov r0, sl <== NOT EXECUTED 3000f9ac: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000f9b0: eb001538 bl 30014e98 <__umodsi3> <== NOT EXECUTED 3000f9b4: e24a3008 sub r3, sl, #8 <== NOT EXECUTED
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000f9b8: e15a0004 cmp sl, r4 <== NOT EXECUTED
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f9bc: e0603003 rsb r3, r0, r3 <== NOT EXECUTED
start_block->prev_size = extend_area_end;
3000f9c0: 05896000 streq r6, [r9] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_of_alloc_area(
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
3000f9c4: 058d300c streq r3, [sp, #12] <== NOT EXECUTED
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
3000f9c8: 0a000001 beq 3000f9d4 <_Heap_Extend+0xe0> <== NOT EXECUTED 3000f9cc: e154000a cmp r4, sl <== NOT EXECUTED 3000f9d0: 81a07003 movhi r7, r3 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f9d4: e5939004 ldr r9, [r3, #4] <== NOT EXECUTED 3000f9d8: e3c99001 bic r9, r9, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f9dc: e0839009 add r9, r3, r9 <== NOT EXECUTED
} else if ( sub_area_end < extend_area_begin ) {
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
3000f9e0: e1580009 cmp r8, r9 <== NOT EXECUTED 3000f9e4: 1affffe3 bne 3000f978 <_Heap_Extend+0x84> <== NOT EXECUTED
if ( extend_area_begin < heap->area_begin ) {
3000f9e8: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 3000f9ec: e1540003 cmp r4, r3 <== NOT EXECUTED
heap->area_begin = extend_area_begin;
3000f9f0: 35854018 strcc r4, [r5, #24] <== NOT EXECUTED
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
if ( extend_area_begin < heap->area_begin ) {
3000f9f4: 3a000002 bcc 3000fa04 <_Heap_Extend+0x110> <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
3000f9f8: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000f9fc: e1560003 cmp r6, r3 <== NOT EXECUTED
heap->area_end = extend_area_end;
3000fa00: 8585601c strhi r6, [r5, #28] <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
3000fa04: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000fa08: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000fa0c: e595c020 ldr ip, [r5, #32] <== NOT EXECUTED
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
3000fa10: e0631002 rsb r1, r3, r2 <== NOT EXECUTED
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
3000fa14: e3810001 orr r0, r1, #1 <== NOT EXECUTED
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
3000fa18: e5836000 str r6, [r3] <== NOT EXECUTED
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000fa1c: e15c0003 cmp ip, r3 <== NOT EXECUTED
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
3000fa20: e5821000 str r1, [r2] <== NOT EXECUTED
extend_last_block->size_and_flag = 0;
3000fa24: e3a01000 mov r1, #0 <== NOT EXECUTED
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
extend_first_block->prev_size = extend_area_end;
extend_first_block->size_and_flag =
3000fa28: e5830004 str r0, [r3, #4] <== NOT EXECUTED
extend_first_block_size | HEAP_PREV_BLOCK_USED;
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
3000fa2c: e5821004 str r1, [r2, #4] <== NOT EXECUTED
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
heap->first_block = extend_first_block;
3000fa30: 85853020 strhi r3, [r5, #32] <== NOT EXECUTED
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
3000fa34: 8a000002 bhi 3000fa44 <_Heap_Extend+0x150> <== NOT EXECUTED
heap->first_block = extend_first_block;
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
3000fa38: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 3000fa3c: e1530002 cmp r3, r2 <== NOT EXECUTED
heap->last_block = extend_last_block;
3000fa40: 35852024 strcc r2, [r5, #36] ; 0x24 <== NOT EXECUTED
}
if ( merge_below_block != NULL ) {
3000fa44: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3000fa48: e3530000 cmp r3, #0 <== NOT EXECUTED 3000fa4c: 0a000050 beq 3000fb94 <_Heap_Extend+0x2a0> <== NOT EXECUTED
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
3000fa50: e5958010 ldr r8, [r5, #16] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
3000fa54: e2844008 add r4, r4, #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
3000fa58: e1a00004 mov r0, r4 <== NOT EXECUTED 3000fa5c: e1a01008 mov r1, r8 <== NOT EXECUTED 3000fa60: eb00150c bl 30014e98 <__umodsi3> <== NOT EXECUTED
if ( remainder != 0 ) {
3000fa64: e3500000 cmp r0, #0 <== NOT EXECUTED
return value - remainder + alignment;
3000fa68: 10844008 addne r4, r4, r8 <== NOT EXECUTED 3000fa6c: 10604004 rsbne r4, r0, r4 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000fa70: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
3000fa74: e2441008 sub r1, r4, #8 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000fa78: e59c2000 ldr r2, [ip] <== NOT EXECUTED
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
new_first_block_alloc_begin - HEAP_BLOCK_HEADER_SIZE;
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
3000fa7c: e061300c rsb r3, r1, ip <== NOT EXECUTED
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
3000fa80: e3833001 orr r3, r3, #1 <== NOT EXECUTED
uintptr_t const first_block_begin = (uintptr_t) first_block;
uintptr_t const new_first_block_size =
first_block_begin - new_first_block_begin;
Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin;
new_first_block->prev_size = first_block->prev_size;
3000fa84: e5042008 str r2, [r4, #-8] <== NOT EXECUTED
new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED;
3000fa88: e5813004 str r3, [r1, #4] <== NOT EXECUTED
_Heap_Free_block( heap, new_first_block );
3000fa8c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fa90: ebffff8f bl 3000f8d4 <_Heap_Free_block> <== NOT EXECUTED
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
3000fa94: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 3000fa98: e3500000 cmp r0, #0 <== NOT EXECUTED 3000fa9c: 0a00002b beq 3000fb50 <_Heap_Extend+0x25c> <== NOT EXECUTED
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
extend_area_end - last_block_begin - HEAP_BLOCK_HEADER_SIZE,
3000faa0: e2466008 sub r6, r6, #8 <== NOT EXECUTED
uintptr_t extend_area_end
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const last_block_new_size = _Heap_Align_down(
3000faa4: e0606006 rsb r6, r0, r6 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000faa8: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 3000faac: e1a00006 mov r0, r6 <== NOT EXECUTED 3000fab0: eb0014f8 bl 30014e98 <__umodsi3> <== NOT EXECUTED
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
(last_block->size_and_flag - last_block_new_size)
3000fab4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 3000fab8: e0606006 rsb r6, r0, r6 <== NOT EXECUTED 3000fabc: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000fac0: e0862001 add r2, r6, r1 <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
3000fac4: e0663003 rsb r3, r6, r3 <== NOT EXECUTED
| HEAP_PREV_BLOCK_USED;
3000fac8: e3833001 orr r3, r3, #1 <== NOT EXECUTED
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
3000facc: e5823004 str r3, [r2, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000fad0: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
3000fad4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fad8: e2033001 and r3, r3, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fadc: e1866003 orr r6, r6, r3 <== NOT EXECUTED 3000fae0: e5816004 str r6, [r1, #4] <== NOT EXECUTED 3000fae4: ebffff7a bl 3000f8d4 <_Heap_Free_block> <== NOT EXECUTED
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
3000fae8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 3000faec: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3000faf0: e3520000 cmp r2, #0 <== NOT EXECUTED 3000faf4: 03530000 cmpeq r3, #0 <== NOT EXECUTED 3000faf8: 0a000021 beq 3000fb84 <_Heap_Extend+0x290> <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
3000fafc: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000fb00: e595c020 ldr ip, [r5, #32] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000fb04: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000fb08: e5952030 ldr r2, [r5, #48] ; 0x30 <== NOT EXECUTED
* This feature will be used to terminate the scattered heap area list. See
* also _Heap_Extend().
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
3000fb0c: e063c00c rsb ip, r3, ip <== NOT EXECUTED 3000fb10: e59d4018 ldr r4, [sp, #24] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000fb14: e2000001 and r0, r0, #1 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
3000fb18: e595102c ldr r1, [r5, #44] ; 0x2c <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fb1c: e18c0000 orr r0, ip, r0 <== NOT EXECUTED
if ( extended_size_ptr != NULL )
3000fb20: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
3000fb24: e0642002 rsb r2, r4, r2 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
3000fb28: e35c0000 cmp ip, #0 <== NOT EXECUTED
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
3000fb2c: e0811002 add r1, r1, r2 <== NOT EXECUTED 3000fb30: e5830004 str r0, [r3, #4] <== NOT EXECUTED 3000fb34: e585102c str r1, [r5, #44] ; 0x2c <== NOT EXECUTED
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
3000fb38: 13a00001 movne r0, #1 <== NOT EXECUTED
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
3000fb3c: 158c2000 strne r2, [ip] <== NOT EXECUTED
return true;
3000fb40: 03a00001 moveq r0, #1 <== NOT EXECUTED 3000fb44: eaffff7b b 3000f938 <_Heap_Extend+0x44> <== NOT EXECUTED
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
3000fb48: e3a00000 mov r0, #0 <== NOT EXECUTED 3000fb4c: eaffff79 b 3000f938 <_Heap_Extend+0x44> <== NOT EXECUTED
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
3000fb50: e3570000 cmp r7, #0 <== NOT EXECUTED 3000fb54: 0affffe3 beq 3000fae8 <_Heap_Extend+0x1f4> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000fb58: e5971004 ldr r1, [r7, #4] <== NOT EXECUTED
)
{
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
3000fb5c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000fb60: e2011001 and r1, r1, #1 <== NOT EXECUTED 3000fb64: e0672002 rsb r2, r7, r2 <== NOT EXECUTED
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
3000fb68: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
block->size_and_flag = size | flag;
3000fb6c: e1822001 orr r2, r2, r1 <== NOT EXECUTED 3000fb70: e5872004 str r2, [r7, #4] <== NOT EXECUTED
uintptr_t const link_begin = (uintptr_t) link;
uintptr_t const first_block_begin = (uintptr_t) first_block;
_Heap_Block_set_size( link, first_block_begin - link_begin );
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
3000fb74: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000fb78: e3822001 orr r2, r2, #1 <== NOT EXECUTED 3000fb7c: e5832004 str r2, [r3, #4] <== NOT EXECUTED 3000fb80: eaffffd8 b 3000fae8 <_Heap_Extend+0x1f4> <== NOT EXECUTED
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
_Heap_Free_block( heap, extend_first_block );
3000fb84: e1a00005 mov r0, r5 <== NOT EXECUTED 3000fb88: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3000fb8c: ebffff50 bl 3000f8d4 <_Heap_Free_block> <== NOT EXECUTED 3000fb90: eaffffd9 b 3000fafc <_Heap_Extend+0x208> <== NOT EXECUTED
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
3000fb94: e35b0000 cmp fp, #0 <== NOT EXECUTED
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
(link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED;
3000fb98: 1062b00b rsbne fp, r2, fp <== NOT EXECUTED 3000fb9c: 138bb001 orrne fp, fp, #1 <== NOT EXECUTED
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
3000fba0: 1582b004 strne fp, [r2, #4] <== NOT EXECUTED 3000fba4: eaffffba b 3000fa94 <_Heap_Extend+0x1a0> <== NOT EXECUTED
3000f5b0 <_Heap_Free>:
/*
* 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 ) {
3000f5b0: e2513000 subs r3, r1, #0
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
3000f5b4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3000f5b8: e1a04000 mov r4, r0
* 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 ) {
return true;
3000f5bc: 03a00001 moveq r0, #1
/*
* 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 ) {
3000f5c0: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
3000f5c4: e1a00003 mov r0, r3 3000f5c8: e5941010 ldr r1, [r4, #16] 3000f5cc: e2435008 sub r5, r3, #8 3000f5d0: eb0014dd bl 3001494c <__umodsi3>
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
3000f5d4: e5942020 ldr r2, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
3000f5d8: e0605005 rsb r5, r0, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000f5dc: e1550002 cmp r5, r2
3000f5e0: 3a00002f bcc 3000f6a4 <_Heap_Free+0xf4>
3000f5e4: e5941024 ldr r1, [r4, #36] ; 0x24 3000f5e8: e1550001 cmp r5, r1
3000f5ec: 8a00002c bhi 3000f6a4 <_Heap_Free+0xf4>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f5f0: e595c004 ldr ip, [r5, #4]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f5f4: e3cc6001 bic r6, ip, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f5f8: e0853006 add r3, r5, r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000f5fc: e1520003 cmp r2, r3
3000f600: 8a000027 bhi 3000f6a4 <_Heap_Free+0xf4>
3000f604: e1510003 cmp r1, r3
3000f608: 3a000027 bcc 3000f6ac <_Heap_Free+0xfc>
3000f60c: e5937004 ldr r7, [r3, #4]
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
3000f610: e2170001 ands r0, r7, #1
3000f614: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
3000f618: e1510003 cmp r1, r3
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000f61c: e3c77001 bic r7, r7, #1 3000f620: 03a08000 moveq r8, #0
3000f624: 0a000004 beq 3000f63c <_Heap_Free+0x8c>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f628: e0830007 add r0, r3, r7
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f62c: e5900004 ldr r0, [r0, #4]
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
3000f630: e3100001 tst r0, #1 3000f634: 13a08000 movne r8, #0 3000f638: 03a08001 moveq r8, #1
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
3000f63c: e21c0001 ands r0, ip, #1
3000f640: 1a00001b bne 3000f6b4 <_Heap_Free+0x104>
uintptr_t const prev_size = block->prev_size;
3000f644: e595c000 ldr ip, [r5]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000f648: e06ca005 rsb sl, ip, r5
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000f64c: e152000a cmp r2, sl
3000f650: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
3000f654: e151000a cmp r1, sl
3000f658: 38bd85f0 popcc {r4, r5, r6, r7, r8, sl, pc}
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000f65c: e59a0004 ldr r0, [sl, #4]
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
3000f660: e2100001 ands r0, r0, #1
3000f664: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
3000f668: e3580000 cmp r8, #0
3000f66c: 0a000039 beq 3000f758 <_Heap_Free+0x1a8>
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3000f670: e5940038 ldr r0, [r4, #56] ; 0x38
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
3000f674: e0867007 add r7, r6, r7
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f678: e5932008 ldr r2, [r3, #8]
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
3000f67c: e087c00c add ip, r7, ip
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f680: e593300c ldr r3, [r3, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3000f684: e2400001 sub r0, r0, #1
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000f688: e38c1001 orr r1, ip, #1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
3000f68c: e5832008 str r2, [r3, #8]
next->prev = prev;
3000f690: e582300c str r3, [r2, #12]
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
3000f694: e5840038 str r0, [r4, #56] ; 0x38
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000f698: e58a1004 str r1, [sl, #4]
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
3000f69c: e78ac00c str ip, [sl, ip] 3000f6a0: ea00000f b 3000f6e4 <_Heap_Free+0x134>
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
return false;
3000f6a4: e3a00000 mov r0, #0
3000f6a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000f6ac: e3a00000 mov r0, #0 <== NOT EXECUTED
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f6b0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
3000f6b4: e3580000 cmp r8, #0
3000f6b8: 0a000014 beq 3000f710 <_Heap_Free+0x160>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f6bc: e5932008 ldr r2, [r3, #8]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
3000f6c0: e0877006 add r7, r7, r6
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
3000f6c4: e593300c ldr r3, [r3, #12]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000f6c8: e3871001 orr r1, r7, #1
)
{
Heap_Block *next = old_block->next;
Heap_Block *prev = old_block->prev;
new_block->next = next;
3000f6cc: e5852008 str r2, [r5, #8]
new_block->prev = prev;
3000f6d0: e585300c str r3, [r5, #12]
next->prev = new_block;
prev->next = new_block;
3000f6d4: e5835008 str r5, [r3, #8]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
3000f6d8: e582500c str r5, [r2, #12] 3000f6dc: e5851004 str r1, [r5, #4]
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
3000f6e0: e7857007 str r7, [r5, r7]
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000f6e4: e5942040 ldr r2, [r4, #64] ; 0x40
++stats->frees;
3000f6e8: e5943050 ldr r3, [r4, #80] ; 0x50
stats->free_size += block_size;
3000f6ec: e5941030 ldr r1, [r4, #48] ; 0x30
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000f6f0: e2422001 sub r2, r2, #1
++stats->frees;
3000f6f4: e2833001 add r3, r3, #1
stats->free_size += block_size;
3000f6f8: e0816006 add r6, r1, r6
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
3000f6fc: e5842040 str r2, [r4, #64] ; 0x40
++stats->frees;
3000f700: e5843050 str r3, [r4, #80] ; 0x50
stats->free_size += block_size;
3000f704: e5846030 str r6, [r4, #48] ; 0x30
return( true );
3000f708: e3a00001 mov r0, #1
3000f70c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
3000f710: e3862001 orr r2, r6, #1 3000f714: e5852004 str r2, [r5, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
3000f718: e5942038 ldr r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
3000f71c: e594c03c ldr ip, [r4, #60] ; 0x3c
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000f720: e5930004 ldr r0, [r3, #4]
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
3000f724: e5941008 ldr r1, [r4, #8]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
3000f728: e2822001 add r2, r2, #1
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000f72c: e3c00001 bic r0, r0, #1
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
if ( stats->max_free_blocks < stats->free_blocks ) {
3000f730: e152000c cmp r2, ip
new_block->next = next;
3000f734: e5851008 str r1, [r5, #8]
new_block->prev = block_before;
3000f738: e585400c str r4, [r5, #12]
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000f73c: e5830004 str r0, [r3, #4]
block_before->next = new_block; next->prev = new_block;
3000f740: e581500c str r5, [r1, #12]
next_block->prev_size = block_size;
3000f744: e7856006 str r6, [r5, r6]
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
3000f748: e5845008 str r5, [r4, #8]
/* Statistics */
++stats->free_blocks;
3000f74c: e5842038 str r2, [r4, #56] ; 0x38
if ( stats->max_free_blocks < stats->free_blocks ) {
stats->max_free_blocks = stats->free_blocks;
3000f750: 8584203c strhi r2, [r4, #60] ; 0x3c 3000f754: eaffffe2 b 3000f6e4 <_Heap_Free+0x134>
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
3000f758: e086c00c add ip, r6, ip
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
3000f75c: e38c2001 orr r2, ip, #1 3000f760: e58a2004 str r2, [sl, #4]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000f764: e5932004 ldr r2, [r3, #4]
next_block->prev_size = size;
3000f768: e785c006 str ip, [r5, r6]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
3000f76c: e3c22001 bic r2, r2, #1 3000f770: e5832004 str r2, [r3, #4] 3000f774: eaffffda b 3000f6e4 <_Heap_Free+0x134>
3000f8d4 <_Heap_Free_block>:
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000f8d4: e590c040 ldr ip, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000f8d8: e5902050 ldr r2, [r0, #80] ; 0x50 <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000f8dc: e28cc001 add ip, ip, #1 <== NOT EXECUTED
--stats->frees;
3000f8e0: e2422001 sub r2, r2, #1 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000f8e4: e2811008 add r1, r1, #8 <== NOT EXECUTED
static void _Heap_Free_block( Heap_Control *heap, Heap_Block *block )
{
Heap_Statistics *const stats = &heap->stats;
/* Statistics */
++stats->used_blocks;
3000f8e8: e580c040 str ip, [r0, #64] ; 0x40 <== NOT EXECUTED
--stats->frees;
3000f8ec: e5802050 str r2, [r0, #80] ; 0x50 <== NOT EXECUTED
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ));
3000f8f0: ea0000ac b 3000fba8 <_Heap_Free> <== NOT EXECUTED
30016d48 <_Heap_Resize_block>:
void *alloc_begin_ptr,
uintptr_t new_alloc_size,
uintptr_t *old_size,
uintptr_t *new_size
)
{
30016d48: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30016d4c: e1a04000 mov r4, r0
30016d50: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30016d54: e1a00001 mov r0, r1 30016d58: e5941010 ldr r1, [r4, #16] 30016d5c: e1a07003 mov r7, r3 30016d60: e1a0a002 mov sl, r2 30016d64: ebfff6f8 bl 3001494c <__umodsi3> 30016d68: e2458008 sub r8, r5, #8
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30016d6c: e5943020 ldr r3, [r4, #32] 30016d70: e59d601c ldr r6, [sp, #28]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
30016d74: e0601008 rsb r1, r0, r8
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
30016d78: e3a02000 mov r2, #0
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30016d7c: e1530001 cmp r3, r1 30016d80: e5872000 str r2, [r7]
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30016d84: 83a00002 movhi r0, #2
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *const block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
*old_size = 0;
*new_size = 0;
30016d88: e5862000 str r2, [r6]
30016d8c: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
30016d90: e5943024 ldr r3, [r4, #36] ; 0x24
30016d94: e1530001 cmp r3, r1
30016d98: 3a000036 bcc 30016e78 <_Heap_Resize_block+0x130>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
30016d9c: e5910004 ldr r0, [r1, #4]
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30016da0: e2653004 rsb r3, r5, #4 30016da4: e3c00001 bic r0, r0, #1
{
Heap_Statistics *const stats = &heap->stats;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t block_size = _Heap_Block_size( block );
uintptr_t block_end = block_begin + block_size;
30016da8: e0812000 add r2, r1, r0 30016dac: e592c004 ldr ip, [r2, #4]
uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS;
30016db0: e0833002 add r3, r3, r2 30016db4: e3ccc001 bic ip, ip, #1
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30016db8: e082800c add r8, r2, ip
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
30016dbc: e5988004 ldr r8, [r8, #4]
bool next_block_is_free = _Heap_Is_free( next_block );;
_HAssert( _Heap_Is_block_in_heap( heap, next_block ) );
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
30016dc0: e5873000 str r3, [r7]
RTEMS_INLINE_ROUTINE bool _Heap_Is_free(
const Heap_Block *block
)
{
return !_Heap_Is_used( block );
30016dc4: e3180001 tst r8, #1 30016dc8: 13a07000 movne r7, #0 30016dcc: 03a07001 moveq r7, #1
if ( next_block_is_free ) {
30016dd0: e3570000 cmp r7, #0
block_size += next_block_size;
alloc_size += next_block_size;
30016dd4: 1083300c addne r3, r3, ip
_HAssert( _Heap_Is_prev_used( next_block ) );
*old_size = alloc_size;
if ( next_block_is_free ) {
block_size += next_block_size;
30016dd8: 1080000c addne r0, r0, ip
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30016ddc: e15a0003 cmp sl, r3
return HEAP_RESIZE_UNSATISFIED;
30016de0: 83a00001 movhi r0, #1
if ( next_block_is_free ) {
block_size += next_block_size;
alloc_size += next_block_size;
}
if ( new_alloc_size > alloc_size ) {
30016de4: 88bd85f0 pophi {r4, r5, r6, r7, r8, sl, pc}
return HEAP_RESIZE_UNSATISFIED;
}
if ( next_block_is_free ) {
30016de8: e3570000 cmp r7, #0
30016dec: 0a000011 beq 30016e38 <_Heap_Resize_block+0xf0>
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
30016df0: e591e004 ldr lr, [r1, #4] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30016df4: e0803001 add r3, r0, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Block_set_size(
Heap_Block *block,
uintptr_t size
)
{
uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;
30016df8: e20ee001 and lr, lr, #1 <== NOT EXECUTED
block->size_and_flag = size | flag;
30016dfc: e180000e orr r0, r0, lr <== NOT EXECUTED 30016e00: e5810004 str r0, [r1, #4] <== NOT EXECUTED
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
/* Statistics */
--stats->free_blocks;
30016e04: e594e038 ldr lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30016e08: e5948030 ldr r8, [r4, #48] ; 0x30 <== NOT EXECUTED
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
30016e0c: e5937004 ldr r7, [r3, #4] <== NOT EXECUTED
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
}
30016e10: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED 30016e14: e592200c ldr r2, [r2, #12] <== NOT EXECUTED
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
30016e18: e3877001 orr r7, r7, #1 <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30016e1c: e24ee001 sub lr, lr, #1 <== NOT EXECUTED
stats->free_size -= next_block_size;
30016e20: e06cc008 rsb ip, ip, r8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
30016e24: e5820008 str r0, [r2, #8] <== NOT EXECUTED
next->prev = prev;
30016e28: e580200c str r2, [r0, #12] <== NOT EXECUTED
_Heap_Block_set_size( block, block_size );
_Heap_Free_list_remove( next_block );
next_block = _Heap_Block_at( block, block_size );
next_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
30016e2c: e5837004 str r7, [r3, #4] <== NOT EXECUTED
/* Statistics */
--stats->free_blocks;
30016e30: e584e038 str lr, [r4, #56] ; 0x38 <== NOT EXECUTED
stats->free_size -= next_block_size;
30016e34: e584c030 str ip, [r4, #48] ; 0x30 <== NOT EXECUTED
}
block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size );
30016e38: e1a02005 mov r2, r5 30016e3c: e1a0300a mov r3, sl 30016e40: e1a00004 mov r0, r4 30016e44: ebffcfa5 bl 3000ace0 <_Heap_Block_allocate>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
30016e48: e5902004 ldr r2, [r0, #4] 30016e4c: e1a03000 mov r3, r0 30016e50: e3c22001 bic r2, r2, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30016e54: e2822004 add r2, r2, #4
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
30016e58: e0655002 rsb r5, r5, r2 30016e5c: e0833005 add r3, r3, r5 30016e60: e5863000 str r3, [r6]
/* Statistics */
++stats->resizes;
30016e64: e5943054 ldr r3, [r4, #84] ; 0x54
return HEAP_RESIZE_SUCCESSFUL;
30016e68: e3a00000 mov r0, #0
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
*new_size = (uintptr_t) next_block - alloc_begin + HEAP_ALLOC_BONUS;
/* Statistics */
++stats->resizes;
30016e6c: e2833001 add r3, r3, #1
30016e70: e5843054 str r3, [r4, #84] ; 0x54
30016e74: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
new_alloc_size,
old_size,
new_size
);
}
return HEAP_RESIZE_FATAL_ERROR;
30016e78: e3a00002 mov r0, #2 <== NOT EXECUTED
}
30016e7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30016e80 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
30016e80: e92d40f0 push {r4, r5, r6, r7, lr}
30016e84: e1a04000 mov r4, r0
30016e88: e1a05001 mov r5, r1
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
30016e8c: e1a00001 mov r0, r1 30016e90: e5941010 ldr r1, [r4, #16] 30016e94: e1a07002 mov r7, r2 30016e98: ebfff6ab bl 3001494c <__umodsi3> 30016e9c: e2456008 sub r6, r5, #8
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
30016ea0: e5943020 ldr r3, [r4, #32]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
30016ea4: e0600006 rsb r0, r0, r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30016ea8: e1500003 cmp r0, r3
30016eac: 3a000010 bcc 30016ef4 <_Heap_Size_of_alloc_area+0x74>
30016eb0: e5942024 ldr r2, [r4, #36] ; 0x24 30016eb4: e1500002 cmp r0, r2
30016eb8: 8a00000d bhi 30016ef4 <_Heap_Size_of_alloc_area+0x74>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
30016ebc: e5906004 ldr r6, [r0, #4] 30016ec0: e3c66001 bic r6, r6, #1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
30016ec4: e0806006 add r6, r0, r6
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
30016ec8: e1530006 cmp r3, r6
30016ecc: 8a000008 bhi 30016ef4 <_Heap_Size_of_alloc_area+0x74>
30016ed0: e1520006 cmp r2, r6
30016ed4: 3a000008 bcc 30016efc <_Heap_Size_of_alloc_area+0x7c>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
30016ed8: e5960004 ldr r0, [r6, #4]
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 )
30016edc: e2100001 ands r0, r0, #1
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
30016ee0: 12655004 rsbne r5, r5, #4 30016ee4: 10856006 addne r6, r5, r6 30016ee8: 15876000 strne r6, [r7]
return true;
30016eec: 13a00001 movne r0, #1
30016ef0: e8bd80f0 pop {r4, r5, r6, r7, pc}
if (
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
30016ef4: e3a00000 mov r0, #0 <== NOT EXECUTED
30016ef8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30016efc: e3a00000 mov r0, #0 <== NOT EXECUTED
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
}
30016f00: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000ba78 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000ba78: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000ba7c: e59f35d8 ldr r3, [pc, #1496] ; 3000c05c <_Heap_Walk+0x5e4> <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000ba80: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000ba84: e5933000 ldr r3, [r3] <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000ba88: e59f25d0 ldr r2, [pc, #1488] ; 3000c060 <_Heap_Walk+0x5e8> <== NOT EXECUTED 3000ba8c: e59f95d0 ldr r9, [pc, #1488] ; 3000c064 <_Heap_Walk+0x5ec> <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000ba90: e1a0a001 mov sl, r1 <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
3000ba94: 11a09002 movne r9, r2 <== NOT EXECUTED
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
3000ba98: e5901010 ldr r1, [r0, #16] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000ba9c: e3530003 cmp r3, #3 <== NOT EXECUTED
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
3000baa0: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block; Heap_Block *const last_block = heap->last_block;
3000baa4: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
3000baa8: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED 3000baac: e1a04000 mov r4, r0 <== NOT EXECUTED
uintptr_t const page_size = heap->page_size;
3000bab0: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED
uintptr_t const min_block_size = heap->min_block_size;
3000bab4: e58d2028 str r2, [sp, #40] ; 0x28 <== NOT EXECUTED
Heap_Block *const first_block = heap->first_block;
3000bab8: e5908020 ldr r8, [r0, #32] <== NOT EXECUTED
Heap_Block *const last_block = heap->last_block;
3000babc: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED
Heap_Block *block = first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
3000bac0: 0a000002 beq 3000bad0 <_Heap_Walk+0x58> <== NOT EXECUTED
}
block = next_block;
} while ( block != first_block );
return true;
3000bac4: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000bac8: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
3000bacc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
3000bad0: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3000bad4: e5900018 ldr r0, [r0, #24] <== NOT EXECUTED 3000bad8: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3000badc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3000bae0: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bae4: e58d1008 str r1, [sp, #8] <== NOT EXECUTED 3000bae8: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000baec: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000baf0: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000baf4: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 3000baf8: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000bafc: e59f2564 ldr r2, [pc, #1380] ; 3000c068 <_Heap_Walk+0x5f0> <== NOT EXECUTED 3000bb00: e58dc000 str ip, [sp] <== NOT EXECUTED 3000bb04: e58d800c str r8, [sp, #12] <== NOT EXECUTED 3000bb08: e1a0000a mov r0, sl <== NOT EXECUTED 3000bb0c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bb10: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb14: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bb18: e12fff19 bx r9 <== NOT EXECUTED
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
3000bb1c: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb20: e3520000 cmp r2, #0 <== NOT EXECUTED 3000bb24: 0a000026 beq 3000bbc4 <_Heap_Walk+0x14c> <== NOT EXECUTED
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
3000bb28: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb2c: e2135007 ands r5, r3, #7 <== NOT EXECUTED 3000bb30: 1a00002a bne 3000bbe0 <_Heap_Walk+0x168> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bb34: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bb38: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb3c: ebffe55f bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
3000bb40: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3000bb44: 1a00002c bne 3000bbfc <_Heap_Walk+0x184> <== NOT EXECUTED 3000bb48: e2880008 add r0, r8, #8 <== NOT EXECUTED 3000bb4c: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bb50: ebffe55a bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bb54: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bb58: 1a00002f bne 3000bc1c <_Heap_Walk+0x1a4> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bb5c: e598b004 ldr fp, [r8, #4] <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
3000bb60: e21b5001 ands r5, fp, #1 <== NOT EXECUTED 3000bb64: 0a000103 beq 3000bf78 <_Heap_Walk+0x500> <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000bb68: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bb6c: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 3000bb70: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000bb74: e08c3003 add r3, ip, r3 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000bb78: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
3000bb7c: e2155001 ands r5, r5, #1 <== NOT EXECUTED 3000bb80: 0a000008 beq 3000bba8 <_Heap_Walk+0x130> <== NOT EXECUTED
);
return false;
}
if (
3000bb84: e1580003 cmp r8, r3 <== NOT EXECUTED 3000bb88: 0a00002b beq 3000bc3c <_Heap_Walk+0x1c4> <== NOT EXECUTED
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
3000bb8c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bb90: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bb94: e59f24d0 ldr r2, [pc, #1232] ; 3000c06c <_Heap_Walk+0x5f4> <== NOT EXECUTED 3000bb98: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bb9c: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bba0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bba4: eaffffc7 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
3000bba8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bbac: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bbb0: e59f24b8 ldr r2, [pc, #1208] ; 3000c070 <_Heap_Walk+0x5f8> <== NOT EXECUTED 3000bbb4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bbb8: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bbbc: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bbc0: eaffffc0 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
3000bbc4: e1a0000a mov r0, sl <== NOT EXECUTED 3000bbc8: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bbcc: e59f24a0 ldr r2, [pc, #1184] ; 3000c074 <_Heap_Walk+0x5fc> <== NOT EXECUTED 3000bbd0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bbd4: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bbd8: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bbdc: eaffffb9 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
3000bbe0: e1a0000a mov r0, sl <== NOT EXECUTED 3000bbe4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bbe8: e59f2488 ldr r2, [pc, #1160] ; 3000c078 <_Heap_Walk+0x600> <== NOT EXECUTED 3000bbec: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bbf0: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bbf4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bbf8: eaffffb2 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
3000bbfc: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc00: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc04: e59f2470 ldr r2, [pc, #1136] ; 3000c07c <_Heap_Walk+0x604> <== NOT EXECUTED 3000bc08: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bc0c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc10: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc14: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bc18: eaffffaa b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
3000bc1c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bc20: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bc24: e59f2454 ldr r2, [pc, #1108] ; 3000c080 <_Heap_Walk+0x608> <== NOT EXECUTED 3000bc28: e1a03008 mov r3, r8 <== NOT EXECUTED 3000bc2c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bc30: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bc34: e1a0000b mov r0, fp <== NOT EXECUTED 3000bc38: eaffffa2 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bc3c: e5946008 ldr r6, [r4, #8] <== NOT EXECUTED
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
3000bc40: e5947010 ldr r7, [r4, #16] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
3000bc44: e1540006 cmp r4, r6 <== NOT EXECUTED 3000bc48: 05943020 ldreq r3, [r4, #32] <== NOT EXECUTED 3000bc4c: 0a00002c beq 3000bd04 <_Heap_Walk+0x28c> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bc50: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bc54: e1530006 cmp r3, r6 <== NOT EXECUTED 3000bc58: 8a0000cd bhi 3000bf94 <_Heap_Walk+0x51c> <== NOT EXECUTED 3000bc5c: e594c024 ldr ip, [r4, #36] ; 0x24 <== NOT EXECUTED 3000bc60: e15c0006 cmp ip, r6 <== NOT EXECUTED 3000bc64: 3a0000ca bcc 3000bf94 <_Heap_Walk+0x51c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bc68: e2860008 add r0, r6, #8 <== NOT EXECUTED 3000bc6c: e1a01007 mov r1, r7 <== NOT EXECUTED 3000bc70: e58d3020 str r3, [sp, #32] <== NOT EXECUTED 3000bc74: e58dc01c str ip, [sp, #28] <== NOT EXECUTED 3000bc78: ebffe510 bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bc7c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bc80: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3000bc84: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 3000bc88: 1a0000df bne 3000c00c <_Heap_Walk+0x594> <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000bc8c: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED 3000bc90: e3c22001 bic r2, r2, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bc94: e0862002 add r2, r6, r2 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000bc98: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bc9c: e3120001 tst r2, #1 <== NOT EXECUTED 3000bca0: 1a0000eb bne 3000c054 <_Heap_Walk+0x5dc> <== NOT EXECUTED 3000bca4: e58d8030 str r8, [sp, #48] ; 0x30 <== NOT EXECUTED 3000bca8: e58db034 str fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000bcac: e1a02004 mov r2, r4 <== NOT EXECUTED 3000bcb0: e1a08003 mov r8, r3 <== NOT EXECUTED 3000bcb4: e1a0b00c mov fp, ip <== NOT EXECUTED
);
return false;
}
if ( free_block->prev != prev_block ) {
3000bcb8: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 3000bcbc: e1510002 cmp r1, r2 <== NOT EXECUTED 3000bcc0: 1a0000da bne 3000c030 <_Heap_Walk+0x5b8> <== NOT EXECUTED
return false;
}
prev_block = free_block;
free_block = free_block->next;
3000bcc4: e5965008 ldr r5, [r6, #8] <== NOT EXECUTED
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
3000bcc8: e1540005 cmp r4, r5 <== NOT EXECUTED 3000bccc: 0a000009 beq 3000bcf8 <_Heap_Walk+0x280> <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bcd0: e1580005 cmp r8, r5 <== NOT EXECUTED 3000bcd4: 9a00007d bls 3000bed0 <_Heap_Walk+0x458> <== NOT EXECUTED
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
3000bcd8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bcdc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bce0: e59f239c ldr r2, [pc, #924] ; 3000c084 <_Heap_Walk+0x60c> <== NOT EXECUTED 3000bce4: e1a03005 mov r3, r5 <== NOT EXECUTED 3000bce8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bcec: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bcf0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bcf4: eaffff73 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED 3000bcf8: e1a03008 mov r3, r8 <== NOT EXECUTED 3000bcfc: e59db034 ldr fp, [sp, #52] ; 0x34 <== NOT EXECUTED 3000bd00: e59d8030 ldr r8, [sp, #48] ; 0x30 <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bd04: e1a06008 mov r6, r8 <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000bd08: e3cb7001 bic r7, fp, #1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
3000bd0c: e0875006 add r5, r7, r6 <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bd10: e1530005 cmp r3, r5 <== NOT EXECUTED 3000bd14: 9a000008 bls 3000bd3c <_Heap_Walk+0x2c4> <== NOT EXECUTED
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
3000bd18: e1a0000a mov r0, sl <== NOT EXECUTED 3000bd1c: e58d5000 str r5, [sp] <== NOT EXECUTED 3000bd20: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bd24: e59f235c ldr r2, [pc, #860] ; 3000c088 <_Heap_Walk+0x610> <== NOT EXECUTED 3000bd28: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bd2c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bd30: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
3000bd34: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bd38: eaffff62 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED 3000bd3c: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3000bd40: e1530005 cmp r3, r5 <== NOT EXECUTED 3000bd44: 3afffff3 bcc 3000bd18 <_Heap_Walk+0x2a0> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bd48: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3000bd4c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000bd50: ebffe4da bl 300050c0 <__umodsi3> <== NOT EXECUTED
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
3000bd54: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000bd58: e0563001 subs r3, r6, r1 <== NOT EXECUTED 3000bd5c: 13a03001 movne r3, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
3000bd60: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bd64: 0a000001 beq 3000bd70 <_Heap_Walk+0x2f8> <== NOT EXECUTED 3000bd68: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bd6c: 1a00008a bne 3000bf9c <_Heap_Walk+0x524> <== NOT EXECUTED
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
3000bd70: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3000bd74: e1520007 cmp r2, r7 <== NOT EXECUTED 3000bd78: 9a000001 bls 3000bd84 <_Heap_Walk+0x30c> <== NOT EXECUTED 3000bd7c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bd80: 1a00008e bne 3000bfc0 <_Heap_Walk+0x548> <== NOT EXECUTED
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
3000bd84: e1560005 cmp r6, r5 <== NOT EXECUTED 3000bd88: 3a000001 bcc 3000bd94 <_Heap_Walk+0x31c> <== NOT EXECUTED 3000bd8c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bd90: 1a000094 bne 3000bfe8 <_Heap_Walk+0x570> <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000bd94: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 3000bd98: e20bb001 and fp, fp, #1 <== NOT EXECUTED
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
3000bd9c: e3130001 tst r3, #1 <== NOT EXECUTED 3000bda0: 0a000018 beq 3000be08 <_Heap_Walk+0x390> <== NOT EXECUTED
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
3000bda4: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000bda8: 0a00000c beq 3000bde0 <_Heap_Walk+0x368> <== NOT EXECUTED
(*printer)(
3000bdac: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bdb0: e1a0000a mov r0, sl <== NOT EXECUTED 3000bdb4: e3a01000 mov r1, #0 <== NOT EXECUTED 3000bdb8: e59f22cc ldr r2, [pc, #716] ; 3000c08c <_Heap_Walk+0x614> <== NOT EXECUTED 3000bdbc: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bdc0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bdc4: e12fff19 bx r9 <== NOT EXECUTED
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
3000bdc8: e1580005 cmp r8, r5 <== NOT EXECUTED 3000bdcc: 0affff3c beq 3000bac4 <_Heap_Walk+0x4c> <== NOT EXECUTED 3000bdd0: e595b004 ldr fp, [r5, #4] <== NOT EXECUTED 3000bdd4: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000bdd8: e1a06005 mov r6, r5 <== NOT EXECUTED 3000bddc: eaffffc9 b 3000bd08 <_Heap_Walk+0x290> <== NOT EXECUTED
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
3000bde0: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bde4: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000bde8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bdec: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bdf0: e1a0100b mov r1, fp <== NOT EXECUTED 3000bdf4: e59f2294 ldr r2, [pc, #660] ; 3000c090 <_Heap_Walk+0x618> <== NOT EXECUTED 3000bdf8: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bdfc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000be00: e12fff19 bx r9 <== NOT EXECUTED 3000be04: eaffffef b 3000bdc8 <_Heap_Walk+0x350> <== NOT EXECUTED
false,
"block 0x%08x: size %u, prev 0x%08x%s, next 0x%08x%s\n",
block,
block_size,
block->prev,
block->prev == first_free_block ?
3000be08: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000be0c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000be10: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000be14: e1530002 cmp r3, r2 <== NOT EXECUTED 3000be18: 059f0274 ldreq r0, [pc, #628] ; 3000c094 <_Heap_Walk+0x61c><== NOT EXECUTED 3000be1c: 0a000003 beq 3000be30 <_Heap_Walk+0x3b8> <== NOT EXECUTED
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
3000be20: e59f3270 ldr r3, [pc, #624] ; 3000c098 <_Heap_Walk+0x620> <== NOT EXECUTED 3000be24: e1540002 cmp r4, r2 <== NOT EXECUTED 3000be28: e59f026c ldr r0, [pc, #620] ; 3000c09c <_Heap_Walk+0x624> <== NOT EXECUTED 3000be2c: 01a00003 moveq r0, r3 <== NOT EXECUTED
block->next,
block->next == last_free_block ?
3000be30: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000be34: e1510003 cmp r1, r3 <== NOT EXECUTED 3000be38: 059f1260 ldreq r1, [pc, #608] ; 3000c0a0 <_Heap_Walk+0x628><== NOT EXECUTED 3000be3c: 0a000003 beq 3000be50 <_Heap_Walk+0x3d8> <== NOT EXECUTED
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
3000be40: e59fc25c ldr ip, [pc, #604] ; 3000c0a4 <_Heap_Walk+0x62c> <== NOT EXECUTED 3000be44: e1540003 cmp r4, r3 <== NOT EXECUTED 3000be48: e59f124c ldr r1, [pc, #588] ; 3000c09c <_Heap_Walk+0x624> <== NOT EXECUTED 3000be4c: 01a0100c moveq r1, ip <== NOT EXECUTED
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
3000be50: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000be54: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3000be58: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3000be5c: e58d1010 str r1, [sp, #16] <== NOT EXECUTED 3000be60: e1a03006 mov r3, r6 <== NOT EXECUTED 3000be64: e58d7000 str r7, [sp] <== NOT EXECUTED 3000be68: e1a0000a mov r0, sl <== NOT EXECUTED 3000be6c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000be70: e59f2230 ldr r2, [pc, #560] ; 3000c0a8 <_Heap_Walk+0x630> <== NOT EXECUTED 3000be74: e1a0e00f mov lr, pc <== NOT EXECUTED 3000be78: e12fff19 bx r9 <== NOT EXECUTED
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
3000be7c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000be80: e1570003 cmp r7, r3 <== NOT EXECUTED 3000be84: 1a000028 bne 3000bf2c <_Heap_Walk+0x4b4> <== NOT EXECUTED
);
return false;
}
if ( !prev_used ) {
3000be88: e35b0000 cmp fp, #0 <== NOT EXECUTED 3000be8c: 0a000031 beq 3000bf58 <_Heap_Walk+0x4e0> <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000be90: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
3000be94: e1540003 cmp r4, r3 <== NOT EXECUTED 3000be98: 0a000004 beq 3000beb0 <_Heap_Walk+0x438> <== NOT EXECUTED
if ( free_block == block ) {
3000be9c: e1560003 cmp r6, r3 <== NOT EXECUTED 3000bea0: 0affffc8 beq 3000bdc8 <_Heap_Walk+0x350> <== NOT EXECUTED
return true;
}
free_block = free_block->next;
3000bea4: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
3000bea8: e1540003 cmp r4, r3 <== NOT EXECUTED 3000beac: 1afffffa bne 3000be9c <_Heap_Walk+0x424> <== NOT EXECUTED
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
3000beb0: e1a0000a mov r0, sl <== NOT EXECUTED 3000beb4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000beb8: e59f21ec ldr r2, [pc, #492] ; 3000c0ac <_Heap_Walk+0x634> <== NOT EXECUTED 3000bebc: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bec0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bec4: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bec8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000becc: eafffefd b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bed0: e155000b cmp r5, fp <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bed4: e2850008 add r0, r5, #8 <== NOT EXECUTED 3000bed8: e1a01007 mov r1, r7 <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bedc: 8affff7d bhi 3000bcd8 <_Heap_Walk+0x260> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
3000bee0: ebffe476 bl 300050c0 <__umodsi3> <== NOT EXECUTED
);
return false;
}
if (
3000bee4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bee8: 1a000048 bne 3000c010 <_Heap_Walk+0x598> <== NOT EXECUTED
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
3000beec: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bef0: e1a02006 mov r2, r6 <== NOT EXECUTED 3000bef4: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
block = next_block;
} while ( block != first_block );
return true;
}
3000bef8: e0833005 add r3, r3, r5 <== NOT EXECUTED
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
3000befc: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000bf00: e1a06005 mov r6, r5 <== NOT EXECUTED 3000bf04: e3130001 tst r3, #1 <== NOT EXECUTED 3000bf08: 0affff6a beq 3000bcb8 <_Heap_Walk+0x240> <== NOT EXECUTED
(*printer)(
3000bf0c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf10: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf14: e59f2194 ldr r2, [pc, #404] ; 3000c0b0 <_Heap_Walk+0x638> <== NOT EXECUTED 3000bf18: e1a03005 mov r3, r5 <== NOT EXECUTED 3000bf1c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf20: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bf24: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bf28: eafffee6 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
(*printer)(
3000bf2c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000bf30: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf34: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bf38: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 3000bf3c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf40: e59f216c ldr r2, [pc, #364] ; 3000c0b4 <_Heap_Walk+0x63c> <== NOT EXECUTED 3000bf44: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bf48: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf4c: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bf50: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bf54: eafffedb b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !prev_used ) {
(*printer)(
3000bf58: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf5c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf60: e59f2150 ldr r2, [pc, #336] ; 3000c0b8 <_Heap_Walk+0x640> <== NOT EXECUTED 3000bf64: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bf68: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf6c: e12fff19 bx r9 <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
3000bf70: e1a0000b mov r0, fp <== NOT EXECUTED 3000bf74: eafffed3 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
3000bf78: e1a0000a mov r0, sl <== NOT EXECUTED 3000bf7c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bf80: e59f2134 ldr r2, [pc, #308] ; 3000c0bc <_Heap_Walk+0x644> <== NOT EXECUTED 3000bf84: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bf88: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000bf8c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000bf90: eafffecc b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
3000bf94: e1a05006 mov r5, r6 <== NOT EXECUTED 3000bf98: eaffff4e b 3000bcd8 <_Heap_Walk+0x260> <== NOT EXECUTED
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
(*printer)(
3000bf9c: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfa0: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bfa4: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfa8: e59f2110 ldr r2, [pc, #272] ; 3000c0c0 <_Heap_Walk+0x648> <== NOT EXECUTED 3000bfac: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bfb0: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfb4: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
3000bfb8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bfbc: eafffec1 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( block_size < min_block_size && is_not_last_block ) {
(*printer)(
3000bfc0: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000bfc4: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfc8: e58d7000 str r7, [sp] <== NOT EXECUTED 3000bfcc: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bfd0: e59f20ec ldr r2, [pc, #236] ; 3000c0c4 <_Heap_Walk+0x64c> <== NOT EXECUTED 3000bfd4: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bfd8: e1a0e00f mov lr, pc <== NOT EXECUTED 3000bfdc: e12fff19 bx r9 <== NOT EXECUTED
block,
block_size,
min_block_size
);
return false;
3000bfe0: e3a00000 mov r0, #0 <== NOT EXECUTED 3000bfe4: eafffeb7 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
(*printer)(
3000bfe8: e1a0000a mov r0, sl <== NOT EXECUTED 3000bfec: e58d5000 str r5, [sp] <== NOT EXECUTED 3000bff0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000bff4: e59f20cc ldr r2, [pc, #204] ; 3000c0c8 <_Heap_Walk+0x650> <== NOT EXECUTED 3000bff8: e1a03006 mov r3, r6 <== NOT EXECUTED 3000bffc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c000: e12fff19 bx r9 <== NOT EXECUTED
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
3000c004: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c008: eafffeae b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
);
return false;
}
if (
3000c00c: e1a05006 mov r5, r6 <== NOT EXECUTED
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
3000c010: e1a0000a mov r0, sl <== NOT EXECUTED 3000c014: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c018: e59f20ac ldr r2, [pc, #172] ; 3000c0cc <_Heap_Walk+0x654> <== NOT EXECUTED 3000c01c: e1a03005 mov r3, r5 <== NOT EXECUTED 3000c020: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c024: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c028: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c02c: eafffea5 b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
return false;
}
if ( free_block->prev != prev_block ) {
(*printer)(
3000c030: e58d1000 str r1, [sp] <== NOT EXECUTED 3000c034: e1a0000a mov r0, sl <== NOT EXECUTED 3000c038: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c03c: e59f208c ldr r2, [pc, #140] ; 3000c0d0 <_Heap_Walk+0x658> <== NOT EXECUTED 3000c040: e1a03006 mov r3, r6 <== NOT EXECUTED 3000c044: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c048: e12fff19 bx r9 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) ) {
return true;
}
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
3000c04c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c050: eafffe9c b 3000bac8 <_Heap_Walk+0x50> <== NOT EXECUTED
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
3000c054: e1a05006 mov r5, r6 <== NOT EXECUTED 3000c058: eaffffab b 3000bf0c <_Heap_Walk+0x494> <== NOT EXECUTED
3000ba20 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000ba20: e92d000c push {r2, r3} <== NOT EXECUTED
3000ba24: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
va_list ap;
if ( error ) {
3000ba28: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
{
/* Do nothing */
}
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
3000ba2c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000ba30: e1a01000 mov r1, r0 <== NOT EXECUTED
va_list ap;
if ( error ) {
3000ba34: 1a00000a bne 3000ba64 <_Heap_Walk_print+0x44> <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
3000ba38: e59f0030 ldr r0, [pc, #48] ; 3000ba70 <_Heap_Walk_print+0x50><== NOT EXECUTED 3000ba3c: ebfff040 bl 30007b44 <printk> <== NOT EXECUTED
}
va_start( ap, fmt );
3000ba40: e28d300c add r3, sp, #12 <== NOT EXECUTED
vprintk( fmt, ap );
3000ba44: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3000ba48: e1a01003 mov r1, r3 <== NOT EXECUTED
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
3000ba4c: e58d3000 str r3, [sp] <== NOT EXECUTED
vprintk( fmt, ap );
3000ba50: ebfff7cc bl 30009988 <vprintk> <== NOT EXECUTED
va_end( ap ); }
3000ba54: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ba58: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000ba5c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000ba60: e12fff1e bx lr <== NOT EXECUTED
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
va_list ap;
if ( error ) {
printk( "FAIL[%d]: ", source );
3000ba64: e59f0008 ldr r0, [pc, #8] ; 3000ba74 <_Heap_Walk_print+0x54><== NOT EXECUTED 3000ba68: ebfff035 bl 30007b44 <printk> <== NOT EXECUTED 3000ba6c: eafffff3 b 3000ba40 <_Heap_Walk_print+0x20> <== NOT EXECUTED
3000ba14 <_Heap_Walk_print_nothing>:
int source,
bool error,
const char *fmt,
...
)
{
3000ba14: e92d000c push {r2, r3} <== NOT EXECUTED
/* Do nothing */ }
3000ba18: e28dd008 add sp, sp, #8 <== NOT EXECUTED 3000ba1c: e12fff1e bx lr <== NOT EXECUTED
3000ae24 <_Internal_error_Occurred>:
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000ae24: e59f303c ldr r3, [pc, #60] ; 3000ae68 <_Internal_error_Occurred+0x44>
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ae28: e201c0ff and ip, r1, #255 ; 0xff
3000ae2c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
3000ae30: e1a0100c mov r1, ip
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
3000ae34: e5830000 str r0, [r3]
_Internal_errors_What_happened.is_internal = is_internal;
3000ae38: e5c3c004 strb ip, [r3, #4]
_Internal_errors_What_happened.the_error = the_error;
3000ae3c: e5832008 str r2, [r3, #8]
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ae40: e1a04002 mov r4, r2
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
_Internal_errors_What_happened.the_error = the_error;
_User_extensions_Fatal( the_source, is_internal, the_error );
3000ae44: eb0007a5 bl 3000cce0 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
3000ae48: e59f301c ldr r3, [pc, #28] ; 3000ae6c <_Internal_error_Occurred+0x48><== NOT EXECUTED 3000ae4c: e3a02005 mov r2, #5 <== NOT EXECUTED 3000ae50: e5832000 str r2, [r3] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ae54: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000ae58: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000ae5c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
3000ae60: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ae64: eafffffe b 3000ae64 <_Internal_error_Occurred+0x40> <== NOT EXECUTED
3000af2c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af30: e5904034 ldr r4, [r0, #52] ; 0x34
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af34: e24dd014 sub sp, sp, #20
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af38: e3540000 cmp r4, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
3000af3c: e1a05000 mov r5, r0
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000af40: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000af44: 0a00009a beq 3000b1b4 <_Objects_Extend_information+0x288>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
3000af48: e1d081b4 ldrh r8, [r0, #20] 3000af4c: e1d0a1b0 ldrh sl, [r0, #16] 3000af50: e1a01008 mov r1, r8 3000af54: e1a0000a mov r0, sl 3000af58: eb002635 bl 30014834 <__aeabi_uidiv> 3000af5c: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
3000af60: e1b03823 lsrs r3, r3, #16
3000af64: 0a000098 beq 3000b1cc <_Objects_Extend_information+0x2a0>
if ( information->object_blocks[ block ] == NULL ) {
3000af68: e5949000 ldr r9, [r4] 3000af6c: e3590000 cmp r9, #0 3000af70: 01a01008 moveq r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000af74: 01a06007 moveq r6, r7
index_base = minimum_index; block = 0;
3000af78: 01a04009 moveq r4, r9
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
3000af7c: 0a00000c beq 3000afb4 <_Objects_Extend_information+0x88>
3000af80: e1a02004 mov r2, r4 3000af84: e1a01008 mov r1, r8
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000af88: e1a06007 mov r6, r7
index_base = minimum_index; block = 0;
3000af8c: e3a04000 mov r4, #0 3000af90: ea000002 b 3000afa0 <_Objects_Extend_information+0x74>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
3000af94: e5b29004 ldr r9, [r2, #4]! 3000af98: e3590000 cmp r9, #0
3000af9c: 0a000004 beq 3000afb4 <_Objects_Extend_information+0x88>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000afa0: e2844001 add r4, r4, #1 3000afa4: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
3000afa8: e0866008 add r6, r6, r8
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000afac: 8afffff8 bhi 3000af94 <_Objects_Extend_information+0x68>
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000afb0: e3a09001 mov r9, #1
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
3000afb4: e08aa001 add sl, sl, r1
/*
* 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 ( maximum > OBJECTS_ID_FINAL_INDEX ) {
3000afb8: e35a0801 cmp sl, #65536 ; 0x10000
3000afbc: 2a000062 bcs 3000b14c <_Objects_Extend_information+0x220>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
3000afc0: e5d52012 ldrb r2, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000afc4: e5950018 ldr r0, [r5, #24]
if ( information->auto_extend ) {
3000afc8: e3520000 cmp r2, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
3000afcc: e0000091 mul r0, r1, r0
if ( information->auto_extend ) {
3000afd0: 1a00005f bne 3000b154 <_Objects_Extend_information+0x228>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
3000afd4: e58d3000 str r3, [sp] 3000afd8: eb000888 bl 3000d200 <_Workspace_Allocate_or_fatal_error> 3000afdc: e59d3000 ldr r3, [sp] 3000afe0: e1a08000 mov r8, r0
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
3000afe4: e3590000 cmp r9, #0
3000afe8: 0a000038 beq 3000b0d0 <_Objects_Extend_information+0x1a4>
*/
/*
* Up the block count and maximum
*/
block_count++;
3000afec: e283b001 add fp, r3, #1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000aff0: e08b008b add r0, fp, fp, lsl #1
((maximum + minimum_index) * sizeof(Objects_Control *));
3000aff4: e08a0000 add r0, sl, r0
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
3000aff8: e0800007 add r0, r0, r7
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
3000affc: e1a00100 lsl r0, r0, #2 3000b000: e58d3000 str r3, [sp] 3000b004: eb000873 bl 3000d1d8 <_Workspace_Allocate>
if ( !object_blocks ) {
3000b008: e2509000 subs r9, r0, #0 3000b00c: e59d3000 ldr r3, [sp]
3000b010: 0a000072 beq 3000b1e0 <_Objects_Extend_information+0x2b4>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
3000b014: e1d521b0 ldrh r2, [r5, #16]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
3000b018: e089c10b add ip, r9, fp, lsl #2 3000b01c: e1570002 cmp r7, r2 3000b020: e089b18b add fp, r9, fp, lsl #3
3000b024: 3a000050 bcc 3000b16c <_Objects_Extend_information+0x240>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b028: e3570000 cmp r7, #0 3000b02c: 13a02000 movne r2, #0 3000b030: 11a0100b movne r1, fp
local_table[ index ] = NULL;
3000b034: 11a00002 movne r0, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b038: 0a000003 beq 3000b04c <_Objects_Extend_information+0x120>
3000b03c: e2822001 add r2, r2, #1 3000b040: e1570002 cmp r7, r2
local_table[ index ] = NULL;
3000b044: e4810004 str r0, [r1], #4
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
3000b048: 8afffffb bhi 3000b03c <_Objects_Extend_information+0x110>
3000b04c: e1a03103 lsl r3, r3, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000b050: e1d511b4 ldrh r1, [r5, #20]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000b054: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
3000b058: e0861001 add r1, r6, r1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b05c: e1560001 cmp r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
3000b060: e7890003 str r0, [r9, r3]
inactive_per_block[block_count] = 0;
3000b064: e78c0003 str r0, [ip, r3]
for ( index=index_base ;
3000b068: 2a000005 bcs 3000b084 <_Objects_Extend_information+0x158>
3000b06c: e08b2106 add r2, fp, r6, lsl #2
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
3000b070: e1a03006 mov r3, r6
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
3000b074: e2833001 add r3, r3, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b078: e1530001 cmp r3, r1
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
3000b07c: e4820004 str r0, [r2], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
3000b080: 3afffffb bcc 3000b074 <_Objects_Extend_information+0x148>
3000b084: e10f3000 mrs r3, CPSR 3000b088: e3832080 orr r2, r3, #128 ; 0x80 3000b08c: e129f002 msr CPSR_fc, r2
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b090: e5952000 ldr r2, [r5]
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
3000b094: e1d510b4 ldrh r1, [r5, #4] 3000b098: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
3000b09c: e1a0a80a lsl sl, sl, #16 3000b0a0: e3822801 orr r2, r2, #65536 ; 0x10000 3000b0a4: e1a0a82a lsr sl, sl, #16
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b0a8: e1822d81 orr r2, r2, r1, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b0ac: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
3000b0b0: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
3000b0b4: e585c030 str ip, [r5, #48] ; 0x30
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
3000b0b8: e5859034 str r9, [r5, #52] ; 0x34
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
3000b0bc: e585b01c str fp, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
3000b0c0: e1c5a1b0 strh sl, [r5, #16]
information->maximum_id = _Objects_Build_id(
3000b0c4: e585200c str r2, [r5, #12]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b0c8: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
3000b0cc: eb000847 bl 3000d1f0 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b0d0: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000b0d4: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b0d8: e7838104 str r8, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
3000b0dc: e1a01008 mov r1, r8 3000b0e0: e1a00007 mov r0, r7 3000b0e4: e1d521b4 ldrh r2, [r5, #20] 3000b0e8: e5953018 ldr r3, [r5, #24] 3000b0ec: eb001019 bl 3000f158 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
3000b0f0: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000b0f4: e2858020 add r8, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000b0f8: ea000009 b 3000b124 <_Objects_Extend_information+0x1f8> 3000b0fc: e5953000 ldr r3, [r5]
the_object->id = _Objects_Build_id(
3000b100: e1d520b4 ldrh r2, [r5, #4] 3000b104: e1a03c03 lsl r3, r3, #24 3000b108: e3833801 orr r3, r3, #65536 ; 0x10000
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b10c: e1833d82 orr r3, r3, r2, lsl #27
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b110: e1833006 orr r3, r3, r6 3000b114: e5813008 str r3, [r1, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
3000b118: e1a00008 mov r0, r8 3000b11c: ebfffcec bl 3000a4d4 <_Chain_Append>
index++;
3000b120: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
3000b124: e1a00007 mov r0, r7 3000b128: ebfffcfc bl 3000a520 <_Chain_Get> 3000b12c: e2501000 subs r1, r0, #0
3000b130: 1afffff1 bne 3000b0fc <_Objects_Extend_information+0x1d0>
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000b134: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000b138: e1d531b4 ldrh r3, [r5, #20] 3000b13c: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
3000b140: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
3000b144: e7813004 str r3, [r1, r4]
information->inactive =
3000b148: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
3000b14c: e28dd014 add sp, sp, #20
3000b150: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
3000b154: e58d3000 str r3, [sp] 3000b158: eb00081e bl 3000d1d8 <_Workspace_Allocate>
if ( !new_object_block )
3000b15c: e2508000 subs r8, r0, #0 3000b160: e59d3000 ldr r3, [sp]
3000b164: 1affff9e bne 3000afe4 <_Objects_Extend_information+0xb8>
3000b168: eafffff7 b 3000b14c <_Objects_Extend_information+0x220>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
3000b16c: e1a03103 lsl r3, r3, #2
3000b170: e5951034 ldr r1, [r5, #52] ; 0x34
3000b174: e1a02003 mov r2, r3
3000b178: e88d1008 stm sp, {r3, ip}
3000b17c: eb001a17 bl 300119e0 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
3000b180: e89d1008 ldm sp, {r3, ip}
3000b184: e1a0000c mov r0, ip
3000b188: e1a02003 mov r2, r3
3000b18c: e5951030 ldr r1, [r5, #48] ; 0x30
3000b190: eb001a12 bl 300119e0 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000b194: e1d521b0 ldrh r2, [r5, #16]
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000b198: e1a0000b mov r0, fp
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
3000b19c: e0872002 add r2, r7, r2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
3000b1a0: e595101c ldr r1, [r5, #28]
3000b1a4: e1a02102 lsl r2, r2, #2
3000b1a8: eb001a0c bl 300119e0 <memcpy>
3000b1ac: e89d1008 ldm sp, {r3, ip}
3000b1b0: eaffffa6 b 3000b050 <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
3000b1b4: e1d0a1b0 ldrh sl, [r0, #16] 3000b1b8: e1d011b4 ldrh r1, [r0, #20]
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000b1bc: e1a06007 mov r6, r7
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000b1c0: e3a09001 mov r9, #1
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
3000b1c4: e1a03004 mov r3, r4 3000b1c8: eaffff79 b 3000afb4 <_Objects_Extend_information+0x88>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
3000b1cc: e1a01008 mov r1, r8 <== NOT EXECUTED
/* * Search for a free block of indexes. If we do NOT need to allocate or * extend the block table, then we will change do_extend. */ do_extend = true; minimum_index = _Objects_Get_index( information->minimum_id );
3000b1d0: e1a06007 mov r6, r7 <== NOT EXECUTED
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
3000b1d4: e3a09001 mov r9, #1 <== NOT EXECUTED
minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0;
3000b1d8: e1a04003 mov r4, r3 <== NOT EXECUTED 3000b1dc: eaffff74 b 3000afb4 <_Objects_Extend_information+0x88> <== NOT EXECUTED
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
3000b1e0: e1a00008 mov r0, r8 3000b1e4: eb000801 bl 3000d1f0 <_Workspace_Free>
return;
3000b1e8: eaffffd7 b 3000b14c <_Objects_Extend_information+0x220>
3000b348 <_Objects_Get>:
* always NULL.
*
* If the Id is valid but the object has not been created yet, then
* the local_table entry will be NULL.
*/
index = id - information->minimum_id + 1;
3000b348: e590c008 ldr ip, [r0, #8]
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b34c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000b350: e1d031b0 ldrh r3, [r0, #16]
* always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1;
3000b354: e26cc001 rsb ip, ip, #1 3000b358: e08c1001 add r1, ip, r1
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000b35c: e1510003 cmp r1, r3
/* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR;
3000b360: 83a03001 movhi r3, #1
Objects_Control *_Objects_Get(
Objects_Information *information,
Objects_Id id,
Objects_Locations *location
)
{
3000b364: e24dd008 sub sp, sp, #8
/* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR;
3000b368: 85823000 strhi r3, [r2]
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000b36c: 83a00000 movhi r0, #0
/*
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
3000b370: 8a000009 bhi 3000b39c <_Objects_Get+0x54>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b374: e59f3048 ldr r3, [pc, #72] ; 3000b3c4 <_Objects_Get+0x7c> 3000b378: e593c000 ldr ip, [r3] 3000b37c: e28cc001 add ip, ip, #1 3000b380: e583c000 str ip, [r3]
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b384: e590301c ldr r3, [r0, #28] 3000b388: e7930101 ldr r0, [r3, r1, lsl #2] 3000b38c: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000b390: 13a03000 movne r3, #0 3000b394: 15823000 strne r3, [r2]
* If the index is less than maximum, then it is OK to use it to
* index into the local_table array.
*/
if ( index <= information->maximum ) {
_Thread_Disable_dispatch();
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b398: 0a000001 beq 3000b3a4 <_Objects_Get+0x5c>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000b39c: e28dd008 add sp, sp, #8
3000b3a0: e8bd8000 pop {pc}
/*
* Valid Id for this API, Class and Node but the object has not
* been allocated yet.
*/
_Thread_Enable_dispatch();
3000b3a4: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 3000b3a8: e58d2000 str r2, [sp] <== NOT EXECUTED 3000b3ac: eb000334 bl 3000c084 <_Thread_Enable_dispatch> <== NOT EXECUTED
*location = OBJECTS_ERROR;
3000b3b0: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3000b3b4: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b3b8: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000b3bc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3000b3c0: eafffff5 b 3000b39c <_Objects_Get+0x54> <== NOT EXECUTED
3000b274 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b274: e1a01801 lsl r1, r1, #16
3000b278: e92d4030 push {r4, r5, lr}
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b27c: e1b04821 lsrs r4, r1, #16
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
3000b280: e1a05000 mov r5, r0
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
3000b284: 01a00004 moveq r0, r4
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
3000b288: 08bd8030 popeq {r4, r5, pc}
/*
* 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 );
3000b28c: eb001139 bl 3000f778 <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
3000b290: e3500000 cmp r0, #0
3000b294: 08bd8030 popeq {r4, r5, pc}
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
3000b298: e1500004 cmp r0, r4
3000b29c: 2a000001 bcs 3000b2a8 <_Objects_Get_information+0x34>
return NULL;
3000b2a0: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
3000b2a4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
3000b2a8: e59f3024 ldr r3, [pc, #36] ; 3000b2d4 <_Objects_Get_information+0x60>
3000b2ac: e7930105 ldr r0, [r3, r5, lsl #2]
3000b2b0: e3500000 cmp r0, #0
3000b2b4: 08bd8030 popeq {r4, r5, pc}
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
3000b2b8: e7900104 ldr r0, [r0, r4, lsl #2]
if ( !info )
3000b2bc: e3500000 cmp r0, #0
3000b2c0: 08bd8030 popeq {r4, r5, pc}
* 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 ( info->maximum == 0 )
3000b2c4: e1d031b0 ldrh r3, [r0, #16]
return NULL;
3000b2c8: e3530000 cmp r3, #0
3000b2cc: 03a00000 moveq r0, #0
3000b2d0: e8bd8030 pop {r4, r5, pc}
3000b2d8 <_Objects_Get_isr_disable>:
{
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b2d8: e590c008 ldr ip, [r0, #8]
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
3000b2dc: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
Objects_Control *the_object;
uint32_t index;
ISR_Level level;
index = id - information->minimum_id + 1;
3000b2e0: e26cc001 rsb ip, ip, #1 3000b2e4: e08cc001 add ip, ip, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000b2e8: e10f4000 mrs r4, CPSR 3000b2ec: e3841080 orr r1, r4, #128 ; 0x80 3000b2f0: e129f001 msr CPSR_fc, r1
_ISR_Disable( level );
if ( information->maximum >= index ) {
3000b2f4: e1d011b0 ldrh r1, [r0, #16] 3000b2f8: e15c0001 cmp ip, r1
3000b2fc: 8a000008 bhi 3000b324 <_Objects_Get_isr_disable+0x4c>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b300: e590101c ldr r1, [r0, #28] 3000b304: e791010c ldr r0, [r1, ip, lsl #2] 3000b308: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3000b30c: 13a01000 movne r1, #0 3000b310: 15821000 strne r1, [r2]
*level_p = level;
3000b314: 15834000 strne r4, [r3]
index = id - information->minimum_id + 1;
_ISR_Disable( level );
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
3000b318: 0a000006 beq 3000b338 <_Objects_Get_isr_disable+0x60>
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
3000b31c: e8bd0010 pop {r4}
3000b320: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000b324: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000b328: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b32c: e5823000 str r3, [r2] <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
3000b330: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b334: eafffff8 b 3000b31c <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED 3000b338: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
3000b33c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b340: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3000b344: eafffff4 b 3000b31c <_Objects_Get_isr_disable+0x44> <== NOT EXECUTED
3000ce90 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000ce90: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000ce94: e2515000 subs r5, r1, #0 <== NOT EXECUTED
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
3000ce98: e1a04002 mov r4, r2 <== NOT EXECUTED 3000ce9c: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
return NULL;
3000cea0: 01a04005 moveq r4, r5 <== NOT EXECUTED
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
3000cea4: 1a000002 bne 3000ceb4 <_Objects_Get_name_as_string+0x24> <== NOT EXECUTED
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
3000cea8: e1a00004 mov r0, r4 <== NOT EXECUTED
3000ceac: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000ceb0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
3000ceb4: e3540000 cmp r4, #0 <== NOT EXECUTED 3000ceb8: 0afffffa beq 3000cea8 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000cebc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cec0: 059f30c4 ldreq r3, [pc, #196] ; 3000cf8c <_Objects_Get_name_as_string+0xfc><== NOT EXECUTED 3000cec4: 11a06000 movne r6, r0 <== NOT EXECUTED 3000cec8: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000cecc: 05936008 ldreq r6, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000ced0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000ced4: ebffffb3 bl 3000cda8 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000ced8: e2503000 subs r3, r0, #0 <== NOT EXECUTED
return NULL;
3000cedc: 01a04003 moveq r4, r3 <== NOT EXECUTED
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
information = _Objects_Get_information_id( tmpId );
if ( !information )
3000cee0: 0afffff0 beq 3000cea8 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
3000cee4: e1a01006 mov r1, r6 <== NOT EXECUTED 3000cee8: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3000ceec: eb000028 bl 3000cf94 <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000cef0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3000cef4: e3530000 cmp r3, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
/* not supported */
#endif
case OBJECTS_ERROR:
return NULL;
3000cef8: 13a04000 movne r4, #0 <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
3000cefc: 1affffe9 bne 3000cea8 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
if ( information->is_string ) {
s = the_object->name.name_p;
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
3000cf00: e590100c ldr r1, [r0, #12] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf04: e2555001 subs r5, r5, #1 <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3000cf08: e1a02c21 lsr r2, r1, #24 <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000cf0c: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000cf10: e1a00421 lsr r0, r1, #8 <== NOT EXECUTED
} else
#endif
{
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
3000cf14: e5cd2000 strb r2, [sp] <== NOT EXECUTED
lname[ 1 ] = (u32_name >> 16) & 0xff;
3000cf18: e5cdc001 strb ip, [sp, #1] <== NOT EXECUTED
lname[ 2 ] = (u32_name >> 8) & 0xff;
3000cf1c: e5cd0002 strb r0, [sp, #2] <== NOT EXECUTED
lname[ 3 ] = (u32_name >> 0) & 0xff;
3000cf20: e5cd1003 strb r1, [sp, #3] <== NOT EXECUTED
lname[ 4 ] = '\0';
3000cf24: e5cd3004 strb r3, [sp, #4] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf28: 0a000015 beq 3000cf84 <_Objects_Get_name_as_string+0xf4> <== NOT EXECUTED 3000cf2c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000cf30: 0a000013 beq 3000cf84 <_Objects_Get_name_as_string+0xf4> <== NOT EXECUTED 3000cf34: e59fc054 ldr ip, [pc, #84] ; 3000cf90 <_Objects_Get_name_as_string+0x100><== NOT EXECUTED 3000cf38: e1a01004 mov r1, r4 <== NOT EXECUTED 3000cf3c: ea000002 b 3000cf4c <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 3000cf40: e7dd2003 ldrb r2, [sp, r3] <== NOT EXECUTED 3000cf44: e3520000 cmp r2, #0 <== NOT EXECUTED 3000cf48: 0a000009 beq 3000cf74 <_Objects_Get_name_as_string+0xe4> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000cf4c: e59c0000 ldr r0, [ip] <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf50: e2833001 add r3, r3, #1 <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
3000cf54: e0800002 add r0, r0, r2 <== NOT EXECUTED 3000cf58: e5d00001 ldrb r0, [r0, #1] <== NOT EXECUTED 3000cf5c: e3100097 tst r0, #151 ; 0x97 <== NOT EXECUTED 3000cf60: 03a0202a moveq r2, #42 ; 0x2a <== NOT EXECUTED 3000cf64: e4c12001 strb r2, [r1], #1 <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf68: e1530005 cmp r3, r5 <== NOT EXECUTED 3000cf6c: e1a00001 mov r0, r1 <== NOT EXECUTED 3000cf70: 3afffff2 bcc 3000cf40 <_Objects_Get_name_as_string+0xb0> <== NOT EXECUTED
*d = (isprint((unsigned char)*s)) ? *s : '*';
}
}
*d = '\0';
3000cf74: e3a03000 mov r3, #0 <== NOT EXECUTED 3000cf78: e5c03000 strb r3, [r0] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cf7c: eb000331 bl 3000dc48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return name;
3000cf80: eaffffc8 b 3000cea8 <_Objects_Get_name_as_string+0x18> <== NOT EXECUTED
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
3000cf84: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cf88: eafffff9 b 3000cf74 <_Objects_Get_name_as_string+0xe4> <== NOT EXECUTED
3000b50c <_Objects_Get_next>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000b50c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000b510: e2504000 subs r4, r0, #0 <== NOT EXECUTED
Objects_Information *information,
Objects_Id id,
Objects_Locations *location_p,
Objects_Id *next_id_p
)
{
3000b514: e1a05002 mov r5, r2 <== NOT EXECUTED 3000b518: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Control *object;
Objects_Id next_id;
if ( !information )
return NULL;
3000b51c: 01a00004 moveq r0, r4 <== NOT EXECUTED
)
{
Objects_Control *object;
Objects_Id next_id;
if ( !information )
3000b520: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !location_p )
3000b524: e3520000 cmp r2, #0 <== NOT EXECUTED
return NULL;
3000b528: 01a00002 moveq r0, r2 <== NOT EXECUTED
Objects_Id next_id;
if ( !information )
return NULL;
if ( !location_p )
3000b52c: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return NULL;
if ( !next_id_p )
3000b530: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b534: 0a000016 beq 3000b594 <_Objects_Get_next+0x88> <== NOT EXECUTED
return NULL;
if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
3000b538: e1b03801 lsls r3, r1, #16 <== NOT EXECUTED
next_id = information->minimum_id;
3000b53c: 05946008 ldreq r6, [r4, #8] <== NOT EXECUTED
else
next_id = id;
3000b540: 11a06001 movne r6, r1 <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000b544: e1d4c1b0 ldrh ip, [r4, #16] <== NOT EXECUTED 3000b548: e1a07806 lsl r7, r6, #16 <== NOT EXECUTED 3000b54c: e15c0827 cmp ip, r7, lsr #16 <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3000b550: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b554: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b558: e1a02005 mov r2, r5 <== NOT EXECUTED
else
next_id = id;
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
3000b55c: 3a000006 bcc 3000b57c <_Objects_Get_next+0x70> <== NOT EXECUTED
*location_p = OBJECTS_ERROR;
goto final;
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
3000b560: eb00000d bl 3000b59c <_Objects_Get> <== NOT EXECUTED
next_id++;
} while (*location_p != OBJECTS_LOCAL);
3000b564: e5953000 ldr r3, [r5] <== NOT EXECUTED
}
/* try to grab one */
object = _Objects_Get(information, next_id, location_p);
next_id++;
3000b568: e2866001 add r6, r6, #1 <== NOT EXECUTED
} while (*location_p != OBJECTS_LOCAL);
3000b56c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b570: 1afffff3 bne 3000b544 <_Objects_Get_next+0x38> <== NOT EXECUTED
*next_id_p = next_id;
3000b574: e5886000 str r6, [r8] <== NOT EXECUTED
return object;
3000b578: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
do {
/* walked off end of list? */
if (_Objects_Get_index(next_id) > information->maximum)
{
*location_p = OBJECTS_ERROR;
3000b57c: e3a03001 mov r3, #1 <== NOT EXECUTED 3000b580: e5853000 str r3, [r5] <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000b584: e3e03000 mvn r3, #0 <== NOT EXECUTED
return 0;
3000b588: e3a00000 mov r0, #0 <== NOT EXECUTED
*next_id_p = next_id;
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
3000b58c: e5883000 str r3, [r8] <== NOT EXECUTED
return 0;
3000b590: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( !location_p )
return NULL;
if ( !next_id_p )
return NULL;
3000b594: e1a00003 mov r0, r3 <== NOT EXECUTED
return object;
final:
*next_id_p = OBJECTS_ID_FINAL;
return 0;
}
3000b598: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001cdec <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
3001cdec: e590c008 ldr ip, [r0, #8]
if ( information->maximum >= index ) {
3001cdf0: e1d031b0 ldrh r3, [r0, #16]
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
3001cdf4: e26cc001 rsb ip, ip, #1 3001cdf8: e08c1001 add r1, ip, r1
if ( information->maximum >= index ) {
3001cdfc: e1510003 cmp r1, r3
3001ce00: 8a000005 bhi 3001ce1c <_Objects_Get_no_protection+0x30>
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001ce04: e590301c ldr r3, [r0, #28] 3001ce08: e7930101 ldr r0, [r3, r1, lsl #2] 3001ce0c: e3500000 cmp r0, #0
*location = OBJECTS_LOCAL;
3001ce10: 13a03000 movne r3, #0 3001ce14: 15823000 strne r3, [r2]
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
3001ce18: 112fff1e bxne lr
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
3001ce1c: e3a03001 mov r3, #1 <== NOT EXECUTED 3001ce20: e5823000 str r3, [r2] <== NOT EXECUTED
return NULL;
3001ce24: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3001ce28: e12fff1e bx lr <== NOT EXECUTED
3000ca5c <_Objects_Id_to_name>:
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000ca5c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ca60: 059f3078 ldreq r3, [pc, #120] ; 3000cae0 <_Objects_Id_to_name+0x84><== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000ca64: e92d4010 push {r4, lr} <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000ca68: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000ca6c: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000ca70: 05931008 ldreq r1, [r3, #8] <== NOT EXECUTED 3000ca74: 11a01000 movne r1, r0 <== NOT EXECUTED 3000ca78: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3000ca7c: e2033007 and r3, r3, #7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000ca80: e2432001 sub r2, r3, #1 <== NOT EXECUTED 3000ca84: e3520002 cmp r2, #2 <== NOT EXECUTED
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
3000ca88: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000ca8c: 8a000010 bhi 3000cad4 <_Objects_Id_to_name+0x78> <== NOT EXECUTED
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
3000ca90: e59f204c ldr r2, [pc, #76] ; 3000cae4 <_Objects_Id_to_name+0x88><== NOT EXECUTED 3000ca94: e7923103 ldr r3, [r2, r3, lsl #2] <== NOT EXECUTED 3000ca98: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ca9c: 0a00000c beq 3000cad4 <_Objects_Id_to_name+0x78> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000caa0: e1a02da1 lsr r2, r1, #27 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
3000caa4: e7930102 ldr r0, [r3, r2, lsl #2] <== NOT EXECUTED
if ( !information )
3000caa8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000caac: 0a000008 beq 3000cad4 <_Objects_Id_to_name+0x78> <== NOT EXECUTED
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
3000cab0: e1a0200d mov r2, sp <== NOT EXECUTED 3000cab4: ebffffc8 bl 3000c9dc <_Objects_Get> <== NOT EXECUTED
if ( !the_object )
3000cab8: e3500000 cmp r0, #0 <== NOT EXECUTED 3000cabc: 0a000004 beq 3000cad4 <_Objects_Id_to_name+0x78> <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
3000cac0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3000cac4: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000cac8: eb000335 bl 3000d7a4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000cacc: e3a00000 mov r0, #0 <== NOT EXECUTED 3000cad0: ea000000 b 3000cad8 <_Objects_Id_to_name+0x7c> <== NOT EXECUTED
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
3000cad4: e3a00003 mov r0, #3 <== NOT EXECUTED
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
3000cad8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000cadc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b498 <_Objects_Name_to_id_u32>:
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000b498: e3530000 cmp r3, #0
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
3000b49c: e92d0030 push {r4, r5}
#endif
/* ASSERT: information->is_string == false */
if ( !id )
return OBJECTS_INVALID_ADDRESS;
3000b4a0: 03a00002 moveq r0, #2
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == false */
if ( !id )
3000b4a4: 0a000005 beq 3000b4c0 <_Objects_Name_to_id_u32+0x28>
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
3000b4a8: e3510000 cmp r1, #0
3000b4ac: 0a000002 beq 3000b4bc <_Objects_Name_to_id_u32+0x24>
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000b4b0: e1d051b0 ldrh r5, [r0, #16] 3000b4b4: e3550000 cmp r5, #0
3000b4b8: 1a000002 bne 3000b4c8 <_Objects_Name_to_id_u32+0x30>
return OBJECTS_INVALID_NAME;
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
3000b4bc: e3a00001 mov r0, #1
#endif }
3000b4c0: e8bd0030 pop {r4, r5}
3000b4c4: e12fff1e bx lr
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = false;
if ( information->maximum != 0 &&
3000b4c8: e3720106 cmn r2, #-2147483647 ; 0x80000001 3000b4cc: 13520000 cmpne r2, #0
3000b4d0: 1a00000b bne 3000b504 <_Objects_Name_to_id_u32+0x6c>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b4d4: e590c01c ldr ip, [r0, #28] 3000b4d8: e3a02001 mov r2, #1
the_object = information->local_table[ index ];
3000b4dc: e5bc0004 ldr r0, [ip, #4]!
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b4e0: e2822001 add r2, r2, #1
the_object = information->local_table[ index ];
if ( !the_object )
3000b4e4: e3500000 cmp r0, #0
3000b4e8: 0a000002 beq 3000b4f8 <_Objects_Name_to_id_u32+0x60>
continue;
if ( name == the_object->name.name_u32 ) {
3000b4ec: e590400c ldr r4, [r0, #12] 3000b4f0: e1540001 cmp r4, r1
3000b4f4: 0a000005 beq 3000b510 <_Objects_Name_to_id_u32+0x78>
_Objects_Is_local_node( node )
))
search_local_node = true;
if ( search_local_node ) {
for ( index = 1; index <= information->maximum; index++ ) {
3000b4f8: e1550002 cmp r5, r2
3000b4fc: 2afffff6 bcs 3000b4dc <_Objects_Name_to_id_u32+0x44>
3000b500: eaffffed b 3000b4bc <_Objects_Name_to_id_u32+0x24> <== NOT EXECUTED
search_local_node = false;
if ( information->maximum != 0 &&
(node == OBJECTS_SEARCH_ALL_NODES ||
node == OBJECTS_SEARCH_LOCAL_NODE ||
3000b504: e3520001 cmp r2, #1 <== NOT EXECUTED 3000b508: 1affffeb bne 3000b4bc <_Objects_Name_to_id_u32+0x24> <== NOT EXECUTED 3000b50c: eafffff0 b 3000b4d4 <_Objects_Name_to_id_u32+0x3c> <== NOT EXECUTED
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000b510: e5902008 ldr r2, [r0, #8]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000b514: e3a00000 mov r0, #0
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
3000b518: e5832000 str r2, [r3]
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
3000b51c: eaffffe7 b 3000b4c0 <_Objects_Name_to_id_u32+0x28>
3000da18 <_Objects_Set_name>:
{
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000da18: e1d033b8 ldrh r3, [r0, #56] ; 0x38 <== NOT EXECUTED
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000da1c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000da20: e1a00002 mov r0, r2 <== NOT EXECUTED
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000da24: e1a05001 mov r5, r1 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000da28: e1a01003 mov r1, r3 <== NOT EXECUTED
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
3000da2c: e1a04002 mov r4, r2 <== NOT EXECUTED
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length );
3000da30: eb001d58 bl 30014f98 <strnlen> <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000da34: e5d42000 ldrb r2, [r4] <== NOT EXECUTED 3000da38: e3500001 cmp r0, #1 <== NOT EXECUTED 3000da3c: e1a02c02 lsl r2, r2, #24 <== NOT EXECUTED 3000da40: 9a00000c bls 3000da78 <_Objects_Set_name+0x60> <== NOT EXECUTED 3000da44: e5d43001 ldrb r3, [r4, #1] <== NOT EXECUTED 3000da48: e3500002 cmp r0, #2 <== NOT EXECUTED 3000da4c: e1822803 orr r2, r2, r3, lsl #16 <== NOT EXECUTED 3000da50: 0a000009 beq 3000da7c <_Objects_Set_name+0x64> <== NOT EXECUTED 3000da54: e5d43002 ldrb r3, [r4, #2] <== NOT EXECUTED 3000da58: e3500003 cmp r0, #3 <== NOT EXECUTED 3000da5c: e1822403 orr r2, r2, r3, lsl #8 <== NOT EXECUTED 3000da60: 15d43003 ldrbne r3, [r4, #3] <== NOT EXECUTED 3000da64: 03a03020 moveq r3, #32 <== NOT EXECUTED 3000da68: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000da6c: e585300c str r3, [r5, #12] <== NOT EXECUTED
);
}
return true;
}
3000da70: e3a00001 mov r0, #1 <== NOT EXECUTED
3000da74: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
d[length] = '\0';
the_object->name.name_p = d;
} else
#endif
{
the_object->name.name_u32 = _Objects_Build_name(
3000da78: e3822602 orr r2, r2, #2097152 ; 0x200000 <== NOT EXECUTED 3000da7c: e3822a02 orr r2, r2, #8192 ; 0x2000 <== NOT EXECUTED 3000da80: e3a03020 mov r3, #32 <== NOT EXECUTED 3000da84: e1823003 orr r3, r2, r3 <== NOT EXECUTED 3000da88: e585300c str r3, [r5, #12] <== NOT EXECUTED
);
}
return true;
}
3000da8c: e3a00001 mov r0, #1 <== NOT EXECUTED
3000da90: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b520 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000b520: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
3000b524: e1d040b8 ldrh r4, [r0, #8]
block_count = (information->maximum - index_base) /
3000b528: e1d051b4 ldrh r5, [r0, #20]
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
3000b52c: e1a06000 mov r6, r0
/*
* Search the list to find block or chunk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
3000b530: e1d001b0 ldrh r0, [r0, #16] 3000b534: e1a01005 mov r1, r5 3000b538: e0640000 rsb r0, r4, r0 3000b53c: eb0024bc bl 30014834 <__aeabi_uidiv>
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b540: e3500000 cmp r0, #0
3000b544: 08bd80f0 popeq {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000b548: e5962030 ldr r2, [r6, #48] ; 0x30 3000b54c: e5923000 ldr r3, [r2] 3000b550: e1550003 cmp r5, r3
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b554: 13a03000 movne r3, #0
if ( information->inactive_per_block[ block ] ==
3000b558: 1a000005 bne 3000b574 <_Objects_Shrink_information+0x54>
3000b55c: ea000008 b 3000b584 <_Objects_Shrink_information+0x64> <== NOT EXECUTED
3000b560: e5b21004 ldr r1, [r2, #4]!
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000b564: e0844005 add r4, r4, r5
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
3000b568: e1550001 cmp r5, r1
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
3000b56c: e1a07103 lsl r7, r3, #2
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] ==
3000b570: 0a000004 beq 3000b588 <_Objects_Shrink_information+0x68>
index_base = _Objects_Get_index( information->minimum_id );
block_count = (information->maximum - index_base) /
information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
3000b574: e2833001 add r3, r3, #1 3000b578: e1500003 cmp r0, r3
3000b57c: 8afffff7 bhi 3000b560 <_Objects_Shrink_information+0x40>
3000b580: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( information->inactive_per_block[ block ] ==
3000b584: e3a07000 mov r7, #0 <== NOT EXECUTED
information->allocation_size ) {
/*
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
3000b588: e5960020 ldr r0, [r6, #32] 3000b58c: ea000002 b 3000b59c <_Objects_Shrink_information+0x7c>
if ((index >= index_base) &&
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
}
}
while ( the_object );
3000b590: e3550000 cmp r5, #0
3000b594: 0a00000b beq 3000b5c8 <_Objects_Shrink_information+0xa8>
index = _Objects_Get_index( the_object->id );
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000b598: e1a00005 mov r0, r5
* Assume the Inactive chain is never empty at this point
*/
the_object = (Objects_Control *) _Chain_First( &information->Inactive );
do {
index = _Objects_Get_index( the_object->id );
3000b59c: e1d030b8 ldrh r3, [r0, #8]
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
3000b5a0: e5905000 ldr r5, [r0]
if ((index >= index_base) &&
3000b5a4: e1530004 cmp r3, r4
3000b5a8: 3afffff8 bcc 3000b590 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
3000b5ac: e1d621b4 ldrh r2, [r6, #20] 3000b5b0: e0842002 add r2, r4, r2
/*
* Get the next node before the node is extracted
*/
extract_me = the_object;
the_object = (Objects_Control *) the_object->Node.next;
if ((index >= index_base) &&
3000b5b4: e1530002 cmp r3, r2
3000b5b8: 2afffff4 bcs 3000b590 <_Objects_Shrink_information+0x70>
(index < (index_base + information->allocation_size))) {
_Chain_Extract( &extract_me->Node );
3000b5bc: ebfffbcf bl 3000a500 <_Chain_Extract>
}
}
while ( the_object );
3000b5c0: e3550000 cmp r5, #0
3000b5c4: 1afffff3 bne 3000b598 <_Objects_Shrink_information+0x78>
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
3000b5c8: e5963034 ldr r3, [r6, #52] ; 0x34 3000b5cc: e7930007 ldr r0, [r3, r7] 3000b5d0: eb000706 bl 3000d1f0 <_Workspace_Free>
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
3000b5d4: e1d602bc ldrh r0, [r6, #44] ; 0x2c 3000b5d8: e1d631b4 ldrh r3, [r6, #20]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
3000b5dc: e5961034 ldr r1, [r6, #52] ; 0x34
information->inactive_per_block[ block ] = 0;
3000b5e0: e5962030 ldr r2, [r6, #48] ; 0x30
information->inactive -= information->allocation_size;
3000b5e4: e0633000 rsb r3, r3, r0
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
3000b5e8: e7815007 str r5, [r1, r7]
information->inactive_per_block[ block ] = 0;
3000b5ec: e7825007 str r5, [r2, r7]
information->inactive -= information->allocation_size;
3000b5f0: e1c632bc strh r3, [r6, #44] ; 0x2c
return;
3000b5f4: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000b918 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b918: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b91c: e59f4040 ldr r4, [pc, #64] ; 3000b964 <_Protected_heap_Extend+0x4c><== NOT EXECUTED
bool _Protected_heap_Extend(
Heap_Control *the_heap,
void *starting_address,
uintptr_t size
)
{
3000b920: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000b924: e1a05000 mov r5, r0 <== NOT EXECUTED 3000b928: e1a07001 mov r7, r1 <== NOT EXECUTED 3000b92c: e1a06002 mov r6, r2 <== NOT EXECUTED
bool extend_ok;
uintptr_t amount_extended;
_RTEMS_Lock_allocator();
3000b930: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b934: ebfffb94 bl 3000a78c <_API_Mutex_Lock> <== NOT EXECUTED
extend_ok = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
3000b938: e1a01007 mov r1, r7 <== NOT EXECUTED 3000b93c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000b940: e1a0300d mov r3, sp <== NOT EXECUTED 3000b944: e1a00005 mov r0, r5 <== NOT EXECUTED 3000b948: eb000fe9 bl 3000f8f4 <_Heap_Extend> <== NOT EXECUTED 3000b94c: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
3000b950: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000b954: ebfffba8 bl 3000a7fc <_API_Mutex_Unlock> <== NOT EXECUTED
return extend_ok; }
3000b958: e1a00005 mov r0, r5 <== NOT EXECUTED
3000b95c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b960: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000bda8 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000bda8: e92d4070 push {r4, r5, r6, lr}
if ( !the_heap )
3000bdac: e2505000 subs r5, r0, #0
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
3000bdb0: e1a06001 mov r6, r1
if ( !the_heap )
return false;
3000bdb4: 01a00005 moveq r0, r5
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
if ( !the_heap )
3000bdb8: 08bd8070 popeq {r4, r5, r6, pc}
return false;
if ( !the_info )
3000bdbc: e3510000 cmp r1, #0
3000bdc0: 0a000009 beq 3000bdec <_Protected_heap_Get_information+0x44>
return false;
_RTEMS_Lock_allocator();
3000bdc4: e59f4028 ldr r4, [pc, #40] ; 3000bdf4 <_Protected_heap_Get_information+0x4c> 3000bdc8: e5940000 ldr r0, [r4] 3000bdcc: ebfffb83 bl 3000abe0 <_API_Mutex_Lock>
_Heap_Get_information( the_heap, the_info );
3000bdd0: e1a00005 mov r0, r5 3000bdd4: e1a01006 mov r1, r6 3000bdd8: eb00110c bl 30010210 <_Heap_Get_information>
_RTEMS_Unlock_allocator();
3000bddc: e5940000 ldr r0, [r4] 3000bde0: ebfffb9a bl 3000ac50 <_API_Mutex_Unlock>
return true;
3000bde4: e3a00001 mov r0, #1
3000bde8: e8bd8070 pop {r4, r5, r6, pc}
{
if ( !the_heap )
return false;
if ( !the_info )
return false;
3000bdec: e1a00001 mov r0, r1 <== NOT EXECUTED
_RTEMS_Lock_allocator();
_Heap_Get_information( the_heap, the_info );
_RTEMS_Unlock_allocator();
return true;
}
3000bdf0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010d54 <_Protected_heap_Walk>:
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
30010d54: e59f3054 ldr r3, [pc, #84] ; 30010db0 <_Protected_heap_Walk+0x5c><== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010d58: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
30010d5c: e5933000 ldr r3, [r3] <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010d60: e1a07000 mov r7, r0 <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
30010d64: e3530000 cmp r3, #0 <== NOT EXECUTED
bool _Protected_heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
30010d68: e1a06001 mov r6, r1 <== NOT EXECUTED 30010d6c: e20250ff and r5, r2, #255 ; 0xff <== NOT EXECUTED
* then it is forbidden to lock a mutex. But since we are inside
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
30010d70: 0a000002 beq 30010d80 <_Protected_heap_Walk+0x2c> <== NOT EXECUTED
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010d74: e1a02005 mov r2, r5 <== NOT EXECUTED
} return status; }
30010d78: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
status = _Heap_Walk( the_heap, source, do_dump );
_RTEMS_Unlock_allocator();
} else {
status = _Heap_Walk( the_heap, source, do_dump );
30010d7c: eafffbe6 b 3000fd1c <_Heap_Walk> <== NOT EXECUTED
* a critical section, it should be safe to walk it unlocked.
*
* NOTE: Dispatching is also disabled during initialization.
*/
if ( !_Thread_Dispatch_disable_level ) {
_RTEMS_Lock_allocator();
30010d80: e59f402c ldr r4, [pc, #44] ; 30010db4 <_Protected_heap_Walk+0x60><== NOT EXECUTED 30010d84: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010d88: ebfff7dd bl 3000ed04 <_API_Mutex_Lock> <== NOT EXECUTED
status = _Heap_Walk( the_heap, source, do_dump );
30010d8c: e1a02005 mov r2, r5 <== NOT EXECUTED 30010d90: e1a01006 mov r1, r6 <== NOT EXECUTED 30010d94: e1a00007 mov r0, r7 <== NOT EXECUTED 30010d98: ebfffbdf bl 3000fd1c <_Heap_Walk> <== NOT EXECUTED 30010d9c: e1a05000 mov r5, r0 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30010da0: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010da4: ebfff7f2 bl 3000ed74 <_API_Mutex_Unlock> <== NOT EXECUTED
} else {
status = _Heap_Walk( the_heap, source, do_dump );
}
return status;
}
30010da8: e1a00005 mov r0, r5 <== NOT EXECUTED
30010dac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000f060 <_RTEMS_Tasks_Invoke_task_variable_dtor>:
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000f060: e59f303c ldr r3, [pc, #60] ; 3000f0a4 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x44><== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000f064: e92d4010 push {r4, lr} <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000f068: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
void _RTEMS_Tasks_Invoke_task_variable_dtor(
Thread_Control *the_thread,
rtems_task_variable_t *tvp
)
{
3000f06c: e1a04001 mov r4, r1 <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
3000f070: e1520000 cmp r2, r0 <== NOT EXECUTED
value = *tvp->ptr;
3000f074: 05912004 ldreq r2, [r1, #4] <== NOT EXECUTED
)
{
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
3000f078: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000f07c: 05911008 ldreq r1, [r1, #8] <== NOT EXECUTED
void (*dtor)(void *);
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
3000f080: 05920000 ldreq r0, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
} else {
value = tvp->tval;
3000f084: 1594000c ldrne r0, [r4, #12] <== NOT EXECUTED
void *value;
dtor = tvp->dtor;
if (_Thread_Is_executing(the_thread)) {
value = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000f088: 05821000 streq r1, [r2] <== NOT EXECUTED
} else {
value = tvp->tval;
}
if ( dtor )
3000f08c: e3530000 cmp r3, #0 <== NOT EXECUTED
(*dtor)(value);
3000f090: 11a0e00f movne lr, pc <== NOT EXECUTED 3000f094: 112fff13 bxne r3 <== NOT EXECUTED
_Workspace_Free(tvp);
3000f098: e1a00004 mov r0, r4 <== NOT EXECUTED
}
3000f09c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
}
if ( dtor )
(*dtor)(value);
_Workspace_Free(tvp);
3000f0a0: eafff852 b 3000d1f0 <_Workspace_Free> <== NOT EXECUTED
3000ef2c <_RTEMS_tasks_Delete_extension>:
void _RTEMS_tasks_Delete_extension(
Thread_Control *executing,
Thread_Control *deleted
)
{
3000ef2c: e92d4030 push {r4, r5, lr}
3000ef30: e1a05001 mov r5, r1
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
3000ef34: e5911100 ldr r1, [r1, #256] ; 0x100
deleted->task_variables = NULL;
3000ef38: e3a03000 mov r3, #0
while (tvp) {
3000ef3c: e3510000 cmp r1, #0
/*
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
3000ef40: e5853100 str r3, [r5, #256] ; 0x100
while (tvp) {
3000ef44: 1a000001 bne 3000ef50 <_RTEMS_tasks_Delete_extension+0x24>
3000ef48: ea000005 b 3000ef64 <_RTEMS_tasks_Delete_extension+0x38>
next = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
tvp = next;
3000ef4c: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
next = (rtems_task_variable_t *)tvp->next;
3000ef50: e5914000 ldr r4, [r1] <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
3000ef54: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ef58: eb000040 bl 3000f060 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
* Free per task variable memory
*/
tvp = deleted->task_variables;
deleted->task_variables = NULL;
while (tvp) {
3000ef5c: e3540000 cmp r4, #0 <== NOT EXECUTED 3000ef60: 1afffff9 bne 3000ef4c <_RTEMS_tasks_Delete_extension+0x20> <== NOT EXECUTED
/*
* Free API specific memory
*/
(void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
3000ef64: e59500f4 ldr r0, [r5, #244] ; 0xf4 3000ef68: ebfff8a0 bl 3000d1f0 <_Workspace_Free>
deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
3000ef6c: e3a03000 mov r3, #0 3000ef70: e58530f4 str r3, [r5, #244] ; 0xf4
}
3000ef74: e8bd8030 pop {r4, r5, pc}
3000ee20 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
3000ee20: e5903100 ldr r3, [r0, #256] ; 0x100
while (tvp) {
3000ee24: e3530000 cmp r3, #0
3000ee28: 0a000007 beq 3000ee4c <_RTEMS_tasks_Switch_extension+0x2c>
tvp->tval = *tvp->ptr;
3000ee2c: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
3000ee30: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
3000ee34: e592c000 ldr ip, [r2] <== NOT EXECUTED 3000ee38: e583c00c str ip, [r3, #12] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
3000ee3c: e5933000 ldr r3, [r3] <== NOT EXECUTED
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
3000ee40: e5820000 str r0, [r2] <== NOT EXECUTED
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
3000ee44: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ee48: 1afffff7 bne 3000ee2c <_RTEMS_tasks_Switch_extension+0xc> <== NOT EXECUTED
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
3000ee4c: e5913100 ldr r3, [r1, #256] ; 0x100
while (tvp) {
3000ee50: e3530000 cmp r3, #0 3000ee54: 012fff1e bxeq lr
tvp->gval = *tvp->ptr;
3000ee58: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
3000ee5c: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
3000ee60: e5920000 ldr r0, [r2] <== NOT EXECUTED 3000ee64: e5830008 str r0, [r3, #8] <== NOT EXECUTED
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
3000ee68: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
*tvp->ptr = tvp->tval;
3000ee6c: e5821000 str r1, [r2] <== NOT EXECUTED
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
3000ee70: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ee74: 1afffff7 bne 3000ee58 <_RTEMS_tasks_Switch_extension+0x38> <== NOT EXECUTED 3000ee78: e12fff1e bx lr <== NOT EXECUTED
3000b140 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
3000b140: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b144: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b148: e1a01000 mov r1, r0 <== NOT EXECUTED
3000b14c: e1a0200d mov r2, sp <== NOT EXECUTED
3000b150: e59f0094 ldr r0, [pc, #148] ; 3000b1ec <_Rate_monotonic_Timeout+0xac><== NOT EXECUTED
3000b154: eb000783 bl 3000cf68 <_Objects_Get> <== NOT EXECUTED
/*
* When we get here, the Timer is already off the chain so we do not
* have to worry about that -- hence no _Watchdog_Remove().
*/
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000b158: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000b15c: e1a04000 mov r4, r0 <== NOT EXECUTED 3000b160: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b164: 1a000010 bne 3000b1ac <_Rate_monotonic_Timeout+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_thread = the_period->owner;
3000b168: e5900040 ldr r0, [r0, #64] ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
3000b16c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
3000b170: e3130901 tst r3, #16384 ; 0x4000 <== NOT EXECUTED 3000b174: 0a000003 beq 3000b188 <_Rate_monotonic_Timeout+0x48> <== NOT EXECUTED 3000b178: e5902020 ldr r2, [r0, #32] <== NOT EXECUTED 3000b17c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3000b180: e1520003 cmp r2, r3 <== NOT EXECUTED 3000b184: 0a000014 beq 3000b1dc <_Rate_monotonic_Timeout+0x9c> <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
3000b188: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED 3000b18c: e3530001 cmp r3, #1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
3000b190: 13a03004 movne r3, #4 <== NOT EXECUTED 3000b194: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
3000b198: 0a000005 beq 3000b1b4 <_Rate_monotonic_Timeout+0x74> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000b19c: e59f304c ldr r3, [pc, #76] ; 3000b1f0 <_Rate_monotonic_Timeout+0xb0><== NOT EXECUTED 3000b1a0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000b1a4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000b1a8: e5832000 str r2, [r3] <== NOT EXECUTED
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
3000b1ac: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b1b0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3000b1b4: e3a03003 mov r3, #3 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
3000b1b8: e1a00004 mov r0, r4 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
3000b1bc: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
3000b1c0: ebfffe54 bl 3000ab18 <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b1c4: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000b1c8: e59f0024 ldr r0, [pc, #36] ; 3000b1f4 <_Rate_monotonic_Timeout+0xb4><== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b1cc: e584301c str r3, [r4, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000b1d0: e2841010 add r1, r4, #16 <== NOT EXECUTED 3000b1d4: eb000e79 bl 3000ebc0 <_Watchdog_Insert> <== NOT EXECUTED 3000b1d8: eaffffef b 3000b19c <_Rate_monotonic_Timeout+0x5c> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000b1dc: e59f1014 ldr r1, [pc, #20] ; 3000b1f8 <_Rate_monotonic_Timeout+0xb8><== NOT EXECUTED 3000b1e0: eb0009d2 bl 3000d930 <_Thread_Clear_state> <== NOT EXECUTED
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
3000b1e4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b1e8: eafffff4 b 3000b1c0 <_Rate_monotonic_Timeout+0x80> <== NOT EXECUTED
3000ad3c <_TOD_Get_uptime_as_timespec>:
*/
void _TOD_Get_uptime_as_timespec(
struct timespec *uptime
)
{
3000ad3c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000ad40: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
3000ad44: e1a04000 mov r4, r0 <== NOT EXECUTED
Timestamp_Control uptime_ts;
/* assume time checked for NULL by caller */
_TOD_Get_uptime( &uptime_ts );
3000ad48: e1a0000d mov r0, sp <== NOT EXECUTED 3000ad4c: eb00129b bl 3000f7c0 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_To_timespec( &uptime_ts, uptime );
3000ad50: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
3000ad54: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
3000ad58: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000ad5c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000c3f0 <_TOD_Set>:
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000c3f0: e59f3068 ldr r3, [pc, #104] ; 3000c460 <_TOD_Set+0x70>
*/
void _TOD_Set(
const struct timespec *time
)
{
3000c3f4: e92d4030 push {r4, r5, lr}
3000c3f8: e5932000 ldr r2, [r3]
3000c3fc: e1a05000 mov r5, r0
3000c400: e2822001 add r2, r2, #1
3000c404: e5832000 str r2, [r3]
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
3000c408: e59f4054 ldr r4, [pc, #84] ; 3000c464 <_TOD_Set+0x74>
if ( time->tv_sec < seconds )
3000c40c: e5902000 ldr r2, [r0]
long seconds;
_Thread_Disable_dispatch();
_TOD_Deactivate();
seconds = _TOD_Seconds_since_epoch();
3000c410: e5943000 ldr r3, [r4]
if ( time->tv_sec < seconds )
3000c414: e1530002 cmp r3, r2
3000c418: ca00000b bgt 3000c44c <_TOD_Set+0x5c>
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
_Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
3000c41c: e59f0044 ldr r0, [pc, #68] ; 3000c468 <_TOD_Set+0x78> 3000c420: e3a01000 mov r1, #0 3000c424: e0632002 rsb r2, r3, r2 3000c428: eb0009d9 bl 3000eb94 <_Watchdog_Adjust>
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
3000c42c: e895000c ldm r5, {r2, r3}
3000c430: e5843004 str r3, [r4, #4]
_TOD_Is_set = true;
3000c434: e59f3030 ldr r3, [pc, #48] ; 3000c46c <_TOD_Set+0x7c>
_Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec );
else
_Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds );
/* POSIX format TOD (timespec) */
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
3000c438: e5842000 str r2, [r4]
_TOD_Is_set = true;
3000c43c: e3a02001 mov r2, #1 3000c440: e5c32000 strb r2, [r3]
_TOD_Activate();
_Thread_Enable_dispatch();
}
3000c444: e8bd4030 pop {r4, r5, lr}
_Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec );
_TOD_Is_set = true;
_TOD_Activate();
_Thread_Enable_dispatch();
3000c448: ea0005fe b 3000dc48 <_Thread_Enable_dispatch>
3000c44c: e59f0014 ldr r0, [pc, #20] ; 3000c468 <_TOD_Set+0x78> <== NOT EXECUTED 3000c450: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c454: e0622003 rsb r2, r2, r3 <== NOT EXECUTED 3000c458: eb0009cd bl 3000eb94 <_Watchdog_Adjust> <== NOT EXECUTED 3000c45c: eafffff2 b 3000c42c <_TOD_Set+0x3c> <== NOT EXECUTED
3000a99c <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000a99c: e92d4010 push {r4, lr}
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9a0: e59f2064 ldr r2, [pc, #100] ; 3000aa0c <_TOD_Tickle_ticks+0x70>
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9a4: e59f3064 ldr r3, [pc, #100] ; 3000aa10 <_TOD_Tickle_ticks+0x74>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9a8: e592100c ldr r1, [r2, #12]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9ac: e5932000 ldr r2, [r3]
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9b0: e061c281 rsb ip, r1, r1, lsl #5
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
3000a9b4: e24dd008 sub sp, sp, #8
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9b8: e2822001 add r2, r2, #1
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9bc: e081c10c add ip, r1, ip, lsl #2 3000a9c0: e1a0c18c lsl ip, ip, #3 3000a9c4: e3a0e000 mov lr, #0
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a9c8: e1a0100d mov r1, sp
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
3000a9cc: e5832000 str r2, [r3]
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a9d0: e59f003c ldr r0, [pc, #60] ; 3000aa14 <_TOD_Tickle_ticks+0x78>
{
Timestamp_Control tick;
uint32_t seconds;
/* Convert the tick quantum to a timestamp */
_Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() );
3000a9d4: e58de000 str lr, [sp] 3000a9d8: e58dc004 str ip, [sp, #4]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
_Timestamp_Add_to( &_TOD_Uptime, &tick );
3000a9dc: eb000847 bl 3000cb00 <_Timespec_Add_to>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick );
3000a9e0: e59f0030 ldr r0, [pc, #48] ; 3000aa18 <_TOD_Tickle_ticks+0x7c> 3000a9e4: e1a0100d mov r1, sp 3000a9e8: eb000844 bl 3000cb00 <_Timespec_Add_to>
while ( seconds ) {
3000a9ec: e2504000 subs r4, r0, #0
3000a9f0: 0a000003 beq 3000aa04 <_TOD_Tickle_ticks+0x68>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
3000a9f4: e59f0020 ldr r0, [pc, #32] ; 3000aa1c <_TOD_Tickle_ticks+0x80><== NOT EXECUTED 3000a9f8: eb0009b5 bl 3000d0d4 <_Watchdog_Tickle> <== NOT EXECUTED 3000a9fc: e2544001 subs r4, r4, #1 <== NOT EXECUTED 3000aa00: 1afffffb bne 3000a9f4 <_TOD_Tickle_ticks+0x58> <== NOT EXECUTED
_Watchdog_Tickle_seconds();
seconds--;
}
}
3000aa04: e28dd008 add sp, sp, #8
3000aa08: e8bd8010 pop {r4, pc}
3000abdc <_TOD_Validate>:
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
3000abdc: e59f30b0 ldr r3, [pc, #176] ; 3000ac94 <_TOD_Validate+0xb8>
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
3000abe0: e92d4010 push {r4, lr}
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
3000abe4: e2504000 subs r4, r0, #0
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
3000abe8: e593100c ldr r1, [r3, #12]
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000abec: 01a00004 moveq r0, r4
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
3000abf0: 08bd8010 popeq {r4, pc}
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
3000abf4: e59f009c ldr r0, [pc, #156] ; 3000ac98 <_TOD_Validate+0xbc> 3000abf8: eb004675 bl 3001c5d4 <__aeabi_uidiv>
rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) ||
3000abfc: e5943018 ldr r3, [r4, #24] 3000ac00: e1500003 cmp r0, r3
3000ac04: 9a00001e bls 3000ac84 <_TOD_Validate+0xa8>
(the_tod->ticks >= ticks_per_second) ||
3000ac08: e5943014 ldr r3, [r4, #20] 3000ac0c: e353003b cmp r3, #59 ; 0x3b
3000ac10: 8a00001b bhi 3000ac84 <_TOD_Validate+0xa8>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
3000ac14: e5943010 ldr r3, [r4, #16] 3000ac18: e353003b cmp r3, #59 ; 0x3b
3000ac1c: 8a000018 bhi 3000ac84 <_TOD_Validate+0xa8>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
3000ac20: e594300c ldr r3, [r4, #12] 3000ac24: e3530017 cmp r3, #23
3000ac28: 8a000015 bhi 3000ac84 <_TOD_Validate+0xa8>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
3000ac2c: e5940004 ldr r0, [r4, #4]
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
3000ac30: e3500000 cmp r0, #0
3000ac34: 08bd8010 popeq {r4, pc}
(the_tod->month == 0) ||
3000ac38: e350000c cmp r0, #12
3000ac3c: 8a000010 bhi 3000ac84 <_TOD_Validate+0xa8>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ac40: e5943000 ldr r3, [r4]
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
3000ac44: e59f2050 ldr r2, [pc, #80] ; 3000ac9c <_TOD_Validate+0xc0> 3000ac48: e1530002 cmp r3, r2
3000ac4c: 9a00000c bls 3000ac84 <_TOD_Validate+0xa8>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
3000ac50: e5944008 ldr r4, [r4, #8]
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
3000ac54: e3540000 cmp r4, #0
3000ac58: 0a00000b beq 3000ac8c <_TOD_Validate+0xb0>
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
3000ac5c: e3130003 tst r3, #3
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ac60: 059f3038 ldreq r3, [pc, #56] ; 3000aca0 <_TOD_Validate+0xc4>
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ac64: 159f3034 ldrne r3, [pc, #52] ; 3000aca0 <_TOD_Validate+0xc4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
3000ac68: 0280000d addeq r0, r0, #13 3000ac6c: 07930100 ldreq r0, [r3, r0, lsl #2]
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
3000ac70: 17930100 ldrne r0, [r3, r0, lsl #2]
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
3000ac74: e1500004 cmp r0, r4
3000ac78: 33a00000 movcc r0, #0
3000ac7c: 23a00001 movcs r0, #1
3000ac80: e8bd8010 pop {r4, pc}
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
3000ac84: e3a00000 mov r0, #0 <== NOT EXECUTED
3000ac88: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ac8c: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( the_tod->day > days_in_month )
return false;
return true;
}
3000ac90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bc10 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
3000bc10: e92d40f0 push {r4, r5, r6, r7, lr}
3000bc14: e1a04000 mov r4, r0
3000bc18: e1a07001 mov r7, r1
3000bc1c: e20260ff and r6, r2, #255 ; 0xff
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
3000bc20: e5905010 ldr r5, [r0, #16]
/* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread );
3000bc24: eb000340 bl 3000c92c <_Thread_Set_transient>
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
3000bc28: e5943014 ldr r3, [r4, #20] 3000bc2c: e1530007 cmp r3, r7
_Thread_Set_priority( the_thread, new_priority );
3000bc30: 11a00004 movne r0, r4 3000bc34: 11a01007 movne r1, r7 3000bc38: 1b000322 blne 3000c8c8 <_Thread_Set_priority>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bc3c: e10f7000 mrs r7, CPSR 3000bc40: e3873080 orr r3, r7, #128 ; 0x80 3000bc44: e129f003 msr CPSR_fc, r3
/*
* If the thread has more than STATES_TRANSIENT set, then it is blocked,
* If it is blocked on a thread queue, then we need to requeue it.
*/
state = the_thread->current_state;
3000bc48: e5943010 ldr r3, [r4, #16]
if ( state != STATES_TRANSIENT ) {
3000bc4c: e3530004 cmp r3, #4
3000bc50: 0a00000b beq 3000bc84 <_Thread_Change_priority+0x74>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
3000bc54: e3150004 tst r5, #4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
3000bc58: 03c32004 biceq r2, r3, #4 <== NOT EXECUTED
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000bc5c: 05842010 streq r2, [r4, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bc60: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000bc64: e59f2098 ldr r2, [pc, #152] ; 3000bd04 <_Thread_Change_priority+0xf4><== NOT EXECUTED 3000bc68: e0032002 and r2, r3, r2 <== NOT EXECUTED
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
3000bc6c: e3520000 cmp r2, #0 <== NOT EXECUTED
3000bc70: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000bc74: e5940044 ldr r0, [r4, #68] ; 0x44 <== NOT EXECUTED 3000bc78: e1a01004 mov r1, r4 <== NOT EXECUTED
if ( !_Thread_Is_executing_also_the_heir() &&
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
_ISR_Enable( level );
}
3000bc7c: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
3000bc80: ea0002e4 b 3000c818 <_Thread_queue_Requeue> <== NOT EXECUTED
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
3000bc84: e2155004 ands r5, r5, #4 3000bc88: 159f5078 ldrne r5, [pc, #120] ; 3000bd08 <_Thread_Change_priority+0xf8>
3000bc8c: 0a00000f beq 3000bcd0 <_Thread_Change_priority+0xc0>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000bc90: e10f3000 mrs r3, CPSR 3000bc94: e129f007 msr CPSR_fc, r7 3000bc98: e129f003 msr CPSR_fc, r3
* This kernel routine implements the scheduling decision logic for
* the scheduler. It does NOT dispatch.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void )
{
_Scheduler.Operations.schedule();
3000bc9c: e1a0e00f mov lr, pc 3000bca0: e595f008 ldr pc, [r5, #8]
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
3000bca4: e59f3060 ldr r3, [pc, #96] ; 3000bd0c <_Thread_Change_priority+0xfc> 3000bca8: e5932004 ldr r2, [r3, #4]
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Scheduler_Schedule();
if ( !_Thread_Is_executing_also_the_heir() &&
3000bcac: e5931008 ldr r1, [r3, #8] 3000bcb0: e1520001 cmp r2, r1
3000bcb4: 0a000003 beq 3000bcc8 <_Thread_Change_priority+0xb8>
3000bcb8: e5d22074 ldrb r2, [r2, #116] ; 0x74 3000bcbc: e3520000 cmp r2, #0
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
3000bcc0: 13a02001 movne r2, #1 3000bcc4: 15c32010 strbne r2, [r3, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bcc8: e129f007 msr CPSR_fc, r7
3000bccc: e8bd80f0 pop {r4, r5, r6, r7, pc}
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
if ( prepend_it )
3000bcd0: e3560000 cmp r6, #0
* Interrupts are STILL disabled.
* We now know the thread will be in the READY state when we remove
* the TRANSIENT state. So we have to place it on the appropriate
* Ready Queue with interrupts off.
*/
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
3000bcd4: e5845010 str r5, [r4, #16]
if ( prepend_it )
3000bcd8: 0a000004 beq 3000bcf0 <_Thread_Change_priority+0xe0>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
3000bcdc: e59f5024 ldr r5, [pc, #36] ; 3000bd08 <_Thread_Change_priority+0xf8> 3000bce0: e1a00004 mov r0, r4 3000bce4: e1a0e00f mov lr, pc 3000bce8: e595f028 ldr pc, [r5, #40] ; 0x28 3000bcec: eaffffe7 b 3000bc90 <_Thread_Change_priority+0x80>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
3000bcf0: e59f5010 ldr r5, [pc, #16] ; 3000bd08 <_Thread_Change_priority+0xf8> 3000bcf4: e1a00004 mov r0, r4 3000bcf8: e1a0e00f mov lr, pc 3000bcfc: e595f024 ldr pc, [r5, #36] ; 0x24 3000bd00: eaffffe2 b 3000bc90 <_Thread_Change_priority+0x80>
3000bd5c <_Thread_Close>:
RTEMS_INLINE_ROUTINE void _Objects_Invalidate_Id(
Objects_Information *information,
Objects_Control *the_object
)
{
_Objects_Set_local_object(
3000bd5c: e1d120b8 ldrh r2, [r1, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bd60: e590301c ldr r3, [r0, #28]
void _Thread_Close(
Objects_Information *information,
Thread_Control *the_thread
)
{
3000bd64: e92d4070 push {r4, r5, r6, lr}
3000bd68: e1a04001 mov r4, r1
3000bd6c: e3a01000 mov r1, #0
3000bd70: e7831102 str r1, [r3, r2, lsl #2]
3000bd74: e1a05000 mov r5, r0
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000bd78: e59f608c ldr r6, [pc, #140] ; 3000be0c <_Thread_Close+0xb0>
* disappear and set a transient state on it. So we temporarily
* unnest dispatching.
*/
_Thread_Unnest_dispatch();
_User_extensions_Thread_delete( the_thread );
3000bd7c: e1a00004 mov r0, r4 3000bd80: e5963000 ldr r3, [r6] 3000bd84: e2433001 sub r3, r3, #1 3000bd88: e5863000 str r3, [r6] 3000bd8c: eb000400 bl 3000cd94 <_User_extensions_Thread_delete>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000bd90: e5963000 ldr r3, [r6] 3000bd94: e2833001 add r3, r3, #1 3000bd98: e5863000 str r3, [r6]
/* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object );
3000bd9c: e1a01004 mov r1, r4 3000bda0: e1a00005 mov r0, r5 3000bda4: ebfffc5b bl 3000af18 <_Objects_Close>
/*
* By setting the dormant state, the thread will not be considered
* for scheduling when we remove any blocking states.
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
3000bda8: e1a00004 mov r0, r4 3000bdac: e3a01001 mov r1, #1 3000bdb0: eb0002cb bl 3000c8e4 <_Thread_Set_state>
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
3000bdb4: e1a00004 mov r0, r4 3000bdb8: eb000265 bl 3000c754 <_Thread_queue_Extract_with_proxy> 3000bdbc: e3500000 cmp r0, #0
3000bdc0: 1a000002 bne 3000bdd0 <_Thread_Close+0x74>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
3000bdc4: e5943050 ldr r3, [r4, #80] ; 0x50 3000bdc8: e3530002 cmp r3, #2
3000bdcc: 0a00000b beq 3000be00 <_Thread_Close+0xa4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Free(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.free( the_thread );
3000bdd0: e59f3038 ldr r3, [pc, #56] ; 3000be10 <_Thread_Close+0xb4> 3000bdd4: e1a00004 mov r0, r4 3000bdd8: e1a0e00f mov lr, pc 3000bddc: e593f01c ldr pc, [r3, #28]
/* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); the_thread->Start.stack = NULL;
3000bde0: e3a05000 mov r5, #0
/*
* Free the rest of the memory associated with this task
* and set the associated pointers to NULL for safety.
*/
_Thread_Stack_Free( the_thread );
3000bde4: e1a00004 mov r0, r4 3000bde8: eb0002f9 bl 3000c9d4 <_Thread_Stack_Free>
the_thread->Start.stack = NULL;
3000bdec: e58450bc str r5, [r4, #188] ; 0xbc
_Workspace_Free( the_thread->extensions );
3000bdf0: e59400fc ldr r0, [r4, #252] ; 0xfc 3000bdf4: eb0004fd bl 3000d1f0 <_Workspace_Free>
the_thread->extensions = NULL;
3000bdf8: e58450fc str r5, [r4, #252] ; 0xfc
}
3000bdfc: e8bd8070 pop {r4, r5, r6, pc}
*/
_Thread_Set_state( the_thread, STATES_DORMANT );
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3000be00: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000be04: eb000487 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 3000be08: eafffff0 b 3000bdd0 <_Thread_Close+0x74> <== NOT EXECUTED
3000bee8 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000bee8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000beec: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000bef0: e1a0100d mov r1, sp <== NOT EXECUTED 3000bef4: eb00006b bl 3000c0a8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000bef8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000befc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000bf00: 1a000005 bne 3000bf1c <_Thread_Delay_ended+0x34> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
3000bf04: e59f1018 ldr r1, [pc, #24] ; 3000bf24 <_Thread_Delay_ended+0x3c><== NOT EXECUTED 3000bf08: ebffff80 bl 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED 3000bf0c: e59f3014 ldr r3, [pc, #20] ; 3000bf28 <_Thread_Delay_ended+0x40><== NOT EXECUTED 3000bf10: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000bf14: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000bf18: e5832000 str r2, [r3] <== NOT EXECUTED
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
3000bf1c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bf20: e8bd8000 pop {pc} <== NOT EXECUTED
3000bf2c <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
3000bf2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
3000bf30: e59f7138 ldr r7, [pc, #312] ; 3000c070 <_Thread_Dispatch+0x144>
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
3000bf34: e24dd010 sub sp, sp, #16
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
3000bf38: e5975004 ldr r5, [r7, #4]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000bf3c: e10f2000 mrs r2, CPSR 3000bf40: e3823080 orr r3, r2, #128 ; 0x80 3000bf44: e129f003 msr CPSR_fc, r3
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000bf48: e5d71010 ldrb r1, [r7, #16] 3000bf4c: e3510000 cmp r1, #0
3000bf50: 0a000043 beq 3000c064 <_Thread_Dispatch+0x138>
heir = _Thread_Heir;
3000bf54: e5974008 ldr r4, [r7, #8]
_Thread_Dispatch_disable_level = 1;
3000bf58: e59f9114 ldr r9, [pc, #276] ; 3000c074 <_Thread_Dispatch+0x148> 3000bf5c: e3a00001 mov r0, #1
_Thread_Dispatch_necessary = false;
3000bf60: e3a01000 mov r1, #0
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bf64: e1550004 cmp r5, r4
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
3000bf68: e5890000 str r0, [r9]
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000bf6c: e5874004 str r4, [r7, #4]
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
3000bf70: e5c71010 strb r1, [r7, #16]
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
3000bf74: 01a03002 moveq r3, r2
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bf78: 0a000033 beq 3000c04c <_Thread_Dispatch+0x120>
3000bf7c: e28da008 add sl, sp, #8 3000bf80: e1a0800d mov r8, sp
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000bf84: e1a06007 mov r6, r7 3000bf88: ea000007 b 3000bfac <_Thread_Dispatch+0x80>
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
3000bf8c: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED
_Thread_Dispatch_disable_level = 1;
3000bf90: e3a01001 mov r1, #1 <== NOT EXECUTED
_Thread_Dispatch_necessary = false;
3000bf94: e3a0b000 mov fp, #0 <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bf98: e1540005 cmp r4, r5 <== NOT EXECUTED
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
3000bf9c: e5891000 str r1, [r9] <== NOT EXECUTED
_Thread_Dispatch_necessary = false;
_Thread_Executing = heir;
3000bfa0: e5864004 str r4, [r6, #4] <== NOT EXECUTED
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Thread_Dispatch_necessary = false;
3000bfa4: e5c6b010 strb fp, [r6, #16] <== NOT EXECUTED
/*
* When the heir and executing are the same, then we are being
* requested to do the post switch dispatching. This is normally
* done to dispatch signals.
*/
if ( heir == executing )
3000bfa8: 0a000027 beq 3000c04c <_Thread_Dispatch+0x120> <== NOT EXECUTED
*/
#if __RTEMS_ADA__
executing->rtems_ada_self = rtems_ada_self;
rtems_ada_self = heir->rtems_ada_self;
#endif
if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE )
3000bfac: e594307c ldr r3, [r4, #124] ; 0x7c 3000bfb0: e3530001 cmp r3, #1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000bfb4: 059fc0bc ldreq ip, [pc, #188] ; 3000c078 <_Thread_Dispatch+0x14c> 3000bfb8: 059c3000 ldreq r3, [ip] 3000bfbc: 05843078 streq r3, [r4, #120] ; 0x78
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000bfc0: e129f002 msr CPSR_fc, r2
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
3000bfc4: e1a0000a mov r0, sl 3000bfc8: eb000cce bl 3000f308 <_TOD_Get_uptime>
_Timestamp_Subtract(
3000bfcc: e1a0200d mov r2, sp 3000bfd0: e1a0100a mov r1, sl 3000bfd4: e59f00a0 ldr r0, [pc, #160] ; 3000c07c <_Thread_Dispatch+0x150> 3000bfd8: eb0002df bl 3000cb5c <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
3000bfdc: e1a0100d mov r1, sp 3000bfe0: e2850084 add r0, r5, #132 ; 0x84 3000bfe4: eb0002c5 bl 3000cb00 <_Timespec_Add_to>
_Thread_Time_of_last_context_switch = uptime;
3000bfe8: e28dc008 add ip, sp, #8
3000bfec: e89c1800 ldm ip, {fp, ip}
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000bff0: e59f2088 ldr r2, [pc, #136] ; 3000c080 <_Thread_Dispatch+0x154>
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
3000bff4: e1a00005 mov r0, r5
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000bff8: e5923000 ldr r3, [r2]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000bffc: e59f2078 ldr r2, [pc, #120] ; 3000c07c <_Thread_Dispatch+0x150>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
3000c000: e3530000 cmp r3, #0
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
3000c004: e8821800 stm r2, {fp, ip}
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000c008: 15932000 ldrne r2, [r3]
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
3000c00c: e1a01004 mov r1, r4
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
3000c010: 158520f0 strne r2, [r5, #240] ; 0xf0
*_Thread_libc_reent = heir->libc_reent;
3000c014: 159420f0 ldrne r2, [r4, #240] ; 0xf0 3000c018: 15832000 strne r2, [r3]
}
_User_extensions_Thread_switch( executing, heir );
3000c01c: eb000382 bl 3000ce2c <_User_extensions_Thread_switch>
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
3000c020: e28500c0 add r0, r5, #192 ; 0xc0 3000c024: e28410c0 add r1, r4, #192 ; 0xc0 3000c028: eb000550 bl 3000d570 <_CPU_Context_switch>
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
3000c02c: e5975004 ldr r5, [r7, #4]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c030: e10f3000 mrs r3, CPSR 3000c034: e3832080 orr r2, r3, #128 ; 0x80 3000c038: e129f002 msr CPSR_fc, r2
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
3000c03c: e5d71010 ldrb r1, [r7, #16] 3000c040: e1a02003 mov r2, r3 3000c044: e3510000 cmp r1, #0
3000c048: 1affffcf bne 3000bf8c <_Thread_Dispatch+0x60>
_ISR_Disable( level );
}
post_switch:
_Thread_Dispatch_disable_level = 0;
3000c04c: e3a01000 mov r1, #0 3000c050: e5891000 str r1, [r9]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c054: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_API_extensions_Run_postswitch();
3000c058: ebfff8cb bl 3000a38c <_API_extensions_Run_postswitch>
}
3000c05c: e28dd010 add sp, sp, #16
3000c060: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
3000c064: e1a03002 mov r3, r2 3000c068: e59f9004 ldr r9, [pc, #4] ; 3000c074 <_Thread_Dispatch+0x148> 3000c06c: eafffff6 b 3000c04c <_Thread_Dispatch+0x120>
3000c0a8 <_Thread_Get>:
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
3000c0a8: e2503000 subs r3, r0, #0
*/
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
3000c0ac: e1a02001 mov r2, r1
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
3000c0b0: 0a000014 beq 3000c108 <_Thread_Get+0x60>
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000c0b4: e1a01c23 lsr r1, r3, #24 3000c0b8: e2011007 and r1, r1, #7
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000c0bc: e2410001 sub r0, r1, #1 3000c0c0: e3500002 cmp r0, #2
3000c0c4: 8a00000b bhi 3000c0f8 <_Thread_Get+0x50>
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class(
Objects_Id id
)
{
return (uint32_t)
3000c0c8: e1a0cda3 lsr ip, r3, #27
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
3000c0cc: e35c0001 cmp ip, #1
3000c0d0: 1a000008 bne 3000c0f8 <_Thread_Get+0x50>
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
3000c0d4: e59f0054 ldr r0, [pc, #84] ; 3000c130 <_Thread_Get+0x88> 3000c0d8: e7900101 ldr r0, [r0, r1, lsl #2]
* There is no way for this to happen if POSIX is enabled. But there
* is actually a test case in sp43 for this which trips it whether or
* not POSIX is enabled. So in the interest of safety, this is left
* on in all configurations.
*/
if ( !api_information ) {
3000c0dc: e3500000 cmp r0, #0
3000c0e0: 0a000010 beq 3000c128 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
3000c0e4: e5900004 ldr r0, [r0, #4]
if ( !information ) {
3000c0e8: e3500000 cmp r0, #0
3000c0ec: 0a00000d beq 3000c128 <_Thread_Get+0x80>
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
3000c0f0: e1a01003 mov r1, r3 3000c0f4: eafffc93 b 3000b348 <_Objects_Get>
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
3000c0f8: e3a03001 mov r3, #1 3000c0fc: e5823000 str r3, [r2]
{
uint32_t the_api;
uint32_t the_class;
Objects_Information **api_information;
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
3000c100: e3a00000 mov r0, #0
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
goto done;
3000c104: e12fff1e bx lr
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000c108: e59f1024 ldr r1, [pc, #36] ; 3000c134 <_Thread_Get+0x8c> 3000c10c: e5910000 ldr r0, [r1] 3000c110: e2800001 add r0, r0, #1 3000c114: e5810000 str r0, [r1]
Objects_Information *information;
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
3000c118: e5823000 str r3, [r2]
tp = _Thread_Executing;
3000c11c: e59f3014 ldr r3, [pc, #20] ; 3000c138 <_Thread_Get+0x90> 3000c120: e5930004 ldr r0, [r3, #4]
goto done;
3000c124: e12fff1e bx lr
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
3000c128: e582c000 str ip, [r2] <== NOT EXECUTED
goto done;
3000c12c: e12fff1e bx lr <== NOT EXECUTED
3000c2d8 <_Thread_Handler_initialization>:
uint32_t maximum_extensions;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
3000c2d8: e59f2088 ldr r2, [pc, #136] ; 3000c368 <_Thread_Handler_initialization+0x90>
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
3000c2dc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c2e0: e592c020 ldr ip, [r2, #32]
== (!Configuration.stack_free_hook) ) )
3000c2e4: e5923024 ldr r3, [r2, #36] ; 0x24
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c2e8: e27cc001 rsbs ip, ip, #1 3000c2ec: 33a0c000 movcc ip, #0 3000c2f0: e3530000 cmp r3, #0 3000c2f4: 022cc001 eoreq ip, ip, #1 3000c2f8: e35c0000 cmp ip, #0
uint32_t maximum_extensions;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
3000c2fc: e5923010 ldr r3, [r2, #16]
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
3000c300: e24dd00c sub sp, sp, #12
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies;
#endif
ticks_per_timeslice = Configuration.ticks_per_timeslice;
maximum_extensions = Configuration.maximum_extensions;
3000c304: e5922008 ldr r2, [r2, #8]
#endif
/*
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
3000c308: 1a000012 bne 3000c358 <_Thread_Handler_initialization+0x80>
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
3000c30c: e59f0058 ldr r0, [pc, #88] ; 3000c36c <_Thread_Handler_initialization+0x94>
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
3000c310: e59fe058 ldr lr, [pc, #88] ; 3000c370 <_Thread_Handler_initialization+0x98>
_Thread_Heir = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
3000c314: e5802000 str r2, [r0]
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
3000c318: e59f2054 ldr r2, [pc, #84] ; 3000c374 <_Thread_Handler_initialization+0x9c>
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c31c: e3a01001 mov r1, #1
_Thread_Allocated_fp = NULL;
#endif
_Thread_Maximum_extensions = maximum_extensions;
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
3000c320: e5823000 str r3, [r2]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c324: e3a03f41 mov r3, #260 ; 0x104
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
_Thread_Executing = NULL;
3000c328: e58ec004 str ip, [lr, #4]
_Thread_Heir = NULL;
3000c32c: e58ec008 str ip, [lr, #8]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c330: e59f0040 ldr r0, [pc, #64] ; 3000c378 <_Thread_Handler_initialization+0xa0>
3000c334: e88d1008 stm sp, {r3, ip}
3000c338: e1a02001 mov r2, r1
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
_Thread_Dispatch_necessary = false;
3000c33c: e5cec010 strb ip, [lr, #16]
/*
* Initialize this class of objects.
*/
_Objects_Initialize_information(
3000c340: e1a03001 mov r3, r1 3000c344: e3a0c008 mov ip, #8 3000c348: e58dc008 str ip, [sp, #8] 3000c34c: ebfffc1d bl 3000b3c8 <_Objects_Initialize_information>
false, /* true if this is a global object class */
NULL /* Proxy extraction support callout */
#endif
);
}
3000c350: e28dd00c add sp, sp, #12
3000c354: e8bd8000 pop {pc}
* BOTH stacks hooks must be set or both must be NULL.
* Do not allow mixture.
*/
if ( !( (!Configuration.stack_allocate_hook)
== (!Configuration.stack_free_hook) ) )
_Internal_error_Occurred(
3000c358: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c35c: e3a01001 mov r1, #1 <== NOT EXECUTED 3000c360: e3a0200e mov r2, #14 <== NOT EXECUTED 3000c364: ebfffaae bl 3000ae24 <_Internal_error_Occurred> <== NOT EXECUTED
300108c4 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
300108c4: e92d4030 push {r4, r5, lr}
the_thread->resource_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
300108c8: e590c0a4 ldr ip, [r0, #164] ; 0xa4
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
300108cc: e5d0e0a0 ldrb lr, [r0, #160] ; 0xa0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout;
300108d0: e59030a8 ldr r3, [r0, #168] ; 0xa8
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
300108d4: e3a05000 mov r5, #0 300108d8: e580501c str r5, [r0, #28]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
300108dc: e5c0e074 strb lr, [r0, #116] ; 0x74
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
300108e0: e580c07c str ip, [r0, #124] ; 0x7c
the_thread->budget_callout = the_thread->Start.budget_callout;
300108e4: e5803080 str r3, [r0, #128] ; 0x80
the_thread->Start.pointer_argument = pointer_argument;
300108e8: e5801098 str r1, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
300108ec: e580209c str r2, [r0, #156] ; 0x9c
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
300108f0: e1a04000 mov r4, r0
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
300108f4: ebfff2db bl 3000d468 <_Thread_queue_Extract_with_proxy> 300108f8: e1500005 cmp r0, r5
300108fc: 1a000002 bne 3001090c <_Thread_Reset+0x48>
if ( _Watchdog_Is_active( &the_thread->Timer ) )
30010900: e5943050 ldr r3, [r4, #80] ; 0x50 30010904: e3530002 cmp r3, #2
30010908: 0a000007 beq 3001092c <_Thread_Reset+0x68>
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
3001090c: e59410b0 ldr r1, [r4, #176] ; 0xb0
30010910: e5943014 ldr r3, [r4, #20]
30010914: e1530001 cmp r3, r1
30010918: 08bd8030 popeq {r4, r5, pc}
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
3001091c: e1a00004 mov r0, r4
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
30010920: e5841018 str r1, [r4, #24]
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
}
}
30010924: e8bd4030 pop {r4, r5, lr}
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
the_thread->real_priority = the_thread->Start.initial_priority;
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
30010928: eafff347 b 3000d64c <_Thread_Set_priority>
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
3001092c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 30010930: ebfff530 bl 3000ddf8 <_Watchdog_Remove> <== NOT EXECUTED 30010934: eafffff4 b 3001090c <_Thread_Reset+0x48> <== NOT EXECUTED
30010084 <_Thread_Resume>:
*/
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
30010084: e92d4010 push {r4, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010088: e10f4000 mrs r4, CPSR 3001008c: e3842080 orr r2, r4, #128 ; 0x80 30010090: e129f002 msr CPSR_fc, r2
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
current_state = the_thread->current_state;
30010094: e5902010 ldr r2, [r0, #16]
if ( current_state & STATES_SUSPENDED ) {
30010098: e3120002 tst r2, #2
3001009c: 0a000003 beq 300100b0 <_Thread_Resume+0x2c>
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
300100a0: e3c22002 bic r2, r2, #2
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
300100a4: e3520000 cmp r2, #0
_ISR_Disable( level );
current_state = the_thread->current_state;
if ( current_state & STATES_SUSPENDED ) {
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
300100a8: e5802010 str r2, [r0, #16]
if ( _States_Is_ready( current_state ) ) {
300100ac: 0a000001 beq 300100b8 <_Thread_Resume+0x34>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
300100b0: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
_Scheduler_Unblock( the_thread );
}
}
_ISR_Enable( level );
}
300100b4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Unblock(
Thread_Control *the_thread
)
{
_Scheduler.Operations.unblock( the_thread );
300100b8: e59f300c ldr r3, [pc, #12] ; 300100cc <_Thread_Resume+0x48>
300100bc: e1a0e00f mov lr, pc
300100c0: e593f014 ldr pc, [r3, #20]
300100c4: e129f004 msr CPSR_fc, r4
300100c8: e8bd8010 pop {r4, pc}
3000ca48 <_Thread_Start>:
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
3000ca48: e590c010 ldr ip, [r0, #16]
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000ca4c: e92d4010 push {r4, lr}
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000ca50: e21cc001 ands ip, ip, #1
Thread_Start_types the_prototype,
void *entry_point,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
3000ca54: e1a04000 mov r4, r0
if ( _States_Is_dormant( the_thread->current_state ) ) {
3000ca58: 1a000001 bne 3000ca64 <_Thread_Start+0x1c>
_User_extensions_Thread_start( the_thread );
return true;
}
return false;
3000ca5c: e1a0000c mov r0, ip <== NOT EXECUTED
}
3000ca60: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
the_thread->Start.prototype = the_prototype;
the_thread->Start.pointer_argument = pointer_argument;
3000ca64: e5803098 str r3, [r0, #152] ; 0x98
the_thread->Start.numeric_argument = numeric_argument;
3000ca68: e59d3008 ldr r3, [sp, #8]
Thread_Entry_numeric_type numeric_argument
)
{
if ( _States_Is_dormant( the_thread->current_state ) ) {
the_thread->Start.entry_point = (Thread_Entry) entry_point;
3000ca6c: e5802090 str r2, [r0, #144] ; 0x90
the_thread->Start.prototype = the_prototype;
3000ca70: e5801094 str r1, [r0, #148] ; 0x94
the_thread->Start.pointer_argument = pointer_argument;
the_thread->Start.numeric_argument = numeric_argument;
3000ca74: e580309c str r3, [r0, #156] ; 0x9c
_Thread_Load_environment( the_thread );
3000ca78: eb000b45 bl 3000f794 <_Thread_Load_environment>
_Thread_Ready( the_thread );
3000ca7c: e1a00004 mov r0, r4 3000ca80: eb000be6 bl 3000fa20 <_Thread_Ready>
_User_extensions_Thread_start( the_thread );
3000ca84: e1a00004 mov r0, r4 3000ca88: eb0000d4 bl 3000cde0 <_User_extensions_Thread_start>
return true;
3000ca8c: e3a00001 mov r0, #1
3000ca90: e8bd8010 pop {r4, pc}
30010424 <_Thread_Suspend>:
* select map
*/
void _Thread_Suspend(
Thread_Control *the_thread
)
{
30010424: e92d4010 push {r4, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010428: e10f4000 mrs r4, CPSR 3001042c: e3842080 orr r2, r4, #128 ; 0x80 30010430: e129f002 msr CPSR_fc, r2
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_ready( the_thread->current_state ) ) {
30010434: e5902010 ldr r2, [r0, #16] 30010438: e3520000 cmp r2, #0
3001043c: 0a000003 beq 30010450 <_Thread_Suspend+0x2c>
RTEMS_INLINE_ROUTINE States_Control _States_Set (
States_Control states_to_set,
States_Control current_state
)
{
return (current_state | states_to_set);
30010440: e3822002 orr r2, r2, #2 <== NOT EXECUTED
the_thread->current_state =
30010444: e5802010 str r2, [r0, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010448: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
3001044c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
30010450: e3a02002 mov r2, #2 30010454: e5802010 str r2, [r0, #16]
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Block(
Thread_Control *the_thread
)
{
_Scheduler.Operations.block( the_thread );
30010458: e59f300c ldr r3, [pc, #12] ; 3001046c <_Thread_Suspend+0x48>
3001045c: e1a0e00f mov lr, pc
30010460: e593f010 ldr pc, [r3, #16]
30010464: e129f004 msr CPSR_fc, r4
30010468: e8bd8010 pop {r4, pc}
3000ca94 <_Thread_Tickle_timeslice>:
void _Thread_Tickle_timeslice( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
3000ca94: e59f3058 ldr r3, [pc, #88] ; 3000caf4 <_Thread_Tickle_timeslice+0x60>
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
3000ca98: e92d4010 push {r4, lr}
Thread_Control *executing;
executing = _Thread_Executing;
3000ca9c: e5934004 ldr r4, [r3, #4]
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
3000caa0: e5d43074 ldrb r3, [r4, #116] ; 0x74
3000caa4: e3530000 cmp r3, #0
3000caa8: 08bd8010 popeq {r4, pc}
return;
if ( !_States_Is_ready( executing->current_state ) )
3000caac: e5943010 ldr r3, [r4, #16]
3000cab0: e3530000 cmp r3, #0
3000cab4: 18bd8010 popne {r4, pc}
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
3000cab8: e594307c ldr r3, [r4, #124] ; 0x7c
3000cabc: e3530001 cmp r3, #1
3000cac0: 18bd8010 popne {r4, pc}
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
#if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE)
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
#endif
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
3000cac4: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cac8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3000cacc: e3530000 cmp r3, #0 <== NOT EXECUTED
3000cad0: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000cad4: c8bd8010 popgt {r4, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000cad8: e59f3018 ldr r3, [pc, #24] ; 3000caf8 <_Thread_Tickle_timeslice+0x64><== NOT EXECUTED 3000cadc: e1a0e00f mov lr, pc <== NOT EXECUTED 3000cae0: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
* executing thread's timeslice is reset. Otherwise, the
* currently executing thread is placed at the rear of the
* FIFO for this priority and a new heir is selected.
*/
_Scheduler_Yield( );
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
3000cae4: e59f3010 ldr r3, [pc, #16] ; 3000cafc <_Thread_Tickle_timeslice+0x68><== NOT EXECUTED
3000cae8: e5933000 ldr r3, [r3] <== NOT EXECUTED
3000caec: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
3000caf0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000bbb8 <_Thread_blocking_operation_Cancel>:
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000bbb8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000bbbc: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED
Thread_blocking_operation_States sync_state __attribute__((unused)),
#endif
Thread_Control *the_thread,
ISR_Level level
)
{
3000bbc0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000bbc4: e3530002 cmp r3, #2 <== NOT EXECUTED
#endif
/*
* The thread is not waiting on anything after this completes.
*/
the_thread->Wait.queue = NULL;
3000bbc8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000bbcc: e5813044 str r3, [r1, #68] ; 0x44 <== NOT EXECUTED
/*
* If the sync state is timed out, this is very likely not needed.
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
3000bbd0: 0a000005 beq 3000bbec <_Thread_blocking_operation_Cancel+0x34><== NOT EXECUTED 3000bbd4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000bbd8: e1a00001 mov r0, r1 <== NOT EXECUTED 3000bbdc: e59f1028 ldr r1, [pc, #40] ; 3000bc0c <_Thread_blocking_operation_Cancel+0x54><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000bbe0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bbe4: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
3000bbe8: ea000048 b 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000bbec: e3a03003 mov r3, #3 <== NOT EXECUTED 3000bbf0: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000bbf4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* But better safe than sorry when it comes to critical sections.
*/
if ( _Watchdog_Is_active( &the_thread->Timer ) ) {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000bbf8: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000bbfc: e58d1000 str r1, [sp] <== NOT EXECUTED 3000bc00: eb000508 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 3000bc04: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000bc08: eafffff2 b 3000bbd8 <_Thread_blocking_operation_Cancel+0x20><== NOT EXECUTED
3000f7e4 <_Thread_queue_Dequeue_fifo>:
*/
Thread_Control *_Thread_queue_Dequeue_fifo(
Thread_queue_Control *the_thread_queue
)
{
3000f7e4: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f7e8: e10f2000 mrs r2, CPSR 3000f7ec: e3823080 orr r3, r2, #128 ; 0x80 3000f7f0: e129f003 msr CPSR_fc, r3
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
3000f7f4: e1a03000 mov r3, r0 3000f7f8: e4934004 ldr r4, [r3], #4
{
ISR_Level level;
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
3000f7fc: e1540003 cmp r4, r3
3000f800: 0a000018 beq 3000f868 <_Thread_queue_Dequeue_fifo+0x84>
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f804: e5941050 ldr r1, [r4, #80] ; 0x50
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3000f808: e5943000 ldr r3, [r4] 3000f80c: e3510002 cmp r1, #2
head->next = new_first;
3000f810: e5803000 str r3, [r0]
new_first->previous = head;
3000f814: e5830004 str r0, [r3, #4]
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
the_thread = (Thread_Control *)
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000f818: e3a03000 mov r3, #0
Thread_Control *the_thread;
_ISR_Disable( level );
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
the_thread = (Thread_Control *)
3000f81c: e1a05004 mov r5, r4
_Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );
the_thread->Wait.queue = NULL;
3000f820: e5843044 str r3, [r4, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f824: 0a000005 beq 3000f840 <_Thread_queue_Dequeue_fifo+0x5c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f828: e129f002 msr CPSR_fc, r2
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000f82c: e59f1040 ldr r1, [pc, #64] ; 3000f874 <_Thread_queue_Dequeue_fifo+0x90> 3000f830: e1a00004 mov r0, r4 3000f834: ebfff135 bl 3000bd10 <_Thread_Clear_state>
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
3000f838: e1a00005 mov r0, r5
3000f83c: e8bd8030 pop {r4, r5, pc}
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000f840: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f844: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000f848: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000f84c: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000f850: ebfff5f4 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 3000f854: e1a00004 mov r0, r4 <== NOT EXECUTED 3000f858: e59f1014 ldr r1, [pc, #20] ; 3000f874 <_Thread_queue_Dequeue_fifo+0x90><== NOT EXECUTED 3000f85c: ebfff12b bl 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED
return the_thread;
}
_ISR_Enable( level );
return NULL;
}
3000f860: e1a00005 mov r0, r5 <== NOT EXECUTED
3000f864: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000f868: e129f002 msr CPSR_fc, r2
return the_thread;
}
_ISR_Enable( level );
return NULL;
3000f86c: e3a05000 mov r5, #0 3000f870: eafffff0 b 3000f838 <_Thread_queue_Dequeue_fifo+0x54>
3000c3ec <_Thread_queue_Dequeue_priority>:
*/
Thread_Control *_Thread_queue_Dequeue_priority(
Thread_queue_Control *the_thread_queue
)
{
3000c3ec: e92d4030 push {r4, r5, lr}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c3f0: e10fc000 mrs ip, CPSR 3000c3f4: e38c3080 orr r3, ip, #128 ; 0x80 3000c3f8: e129f003 msr CPSR_fc, r3
Chain_Node *new_second_node;
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
3000c3fc: e3a02000 mov r2, #0
for( index=0 ;
3000c400: e1a03002 mov r3, r2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000c404: e0831083 add r1, r3, r3, lsl #1
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000c408: e7904002 ldr r4, [r0, r2] 3000c40c: e0801101 add r1, r0, r1, lsl #2 3000c410: e2811004 add r1, r1, #4
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000c414: e1540001 cmp r4, r1
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000c418: e2833001 add r3, r3, #1
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
3000c41c: 1a000006 bne 3000c43c <_Thread_queue_Dequeue_priority+0x50>
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000c420: e3530004 cmp r3, #4
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
3000c424: e282200c add r2, r2, #12
Chain_Node *last_node;
Chain_Node *next_node;
Chain_Node *previous_node;
_ISR_Disable( level );
for( index=0 ;
3000c428: 1afffff5 bne 3000c404 <_Thread_queue_Dequeue_priority+0x18>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c42c: e129f00c msr CPSR_fc, ip
/*
* We did not find a thread to unblock.
*/
_ISR_Enable( level );
return NULL;
3000c430: e3a05000 mov r5, #0
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000c434: e1a00005 mov r0, r5
3000c438: e8bd8030 pop {r4, r5, pc}
3000c43c: e5943038 ldr r3, [r4, #56] ; 0x38
3000c440: e284203c add r2, r4, #60 ; 0x3c
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000c444: e1530002 cmp r3, r2
*/
_ISR_Enable( level );
return NULL;
dequeue:
the_thread->Wait.queue = NULL;
3000c448: e3a02000 mov r2, #0 3000c44c: e5842044 str r2, [r4, #68] ; 0x44
_ISR_Disable( level );
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
the_thread = (Thread_Control *) _Chain_First(
3000c450: e1a05004 mov r5, r4
dequeue:
the_thread->Wait.queue = NULL;
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
next_node = the_thread->Object.Node.next;
3000c454: e5942000 ldr r2, [r4]
previous_node = the_thread->Object.Node.previous;
3000c458: e5941004 ldr r1, [r4, #4]
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000c45c: 0a000020 beq 3000c4e4 <_Thread_queue_Dequeue_priority+0xf8>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
return( the_thread );
}
3000c460: e5940040 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED
next_node = the_thread->Object.Node.next;
previous_node = the_thread->Object.Node.previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000c464: e593e000 ldr lr, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000c468: e5823004 str r3, [r2, #4] <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000c46c: e5813000 str r3, [r1] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000c470: e5831004 str r1, [r3, #4] <== NOT EXECUTED
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
next_node->previous = new_first_node;
new_first_node->next = next_node;
3000c474: e5832000 str r2, [r3] <== NOT EXECUTED
new_first_node->previous = previous_node;
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000c478: e5941038 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED 3000c47c: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED 3000c480: e1510002 cmp r1, r2 <== NOT EXECUTED 3000c484: 0a000005 beq 3000c4a0 <_Thread_queue_Dequeue_priority+0xb4><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000c488: e2831038 add r1, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000c48c: e283203c add r2, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
3000c490: e58e1004 str r1, [lr, #4] <== NOT EXECUTED
head->next = new_second_node;
3000c494: e583e038 str lr, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
3000c498: e5830040 str r0, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
3000c49c: e5802000 str r2, [r0] <== NOT EXECUTED
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000c4a0: e5943050 ldr r3, [r4, #80] ; 0x50 3000c4a4: e3530002 cmp r3, #2
3000c4a8: 0a000004 beq 3000c4c0 <_Thread_queue_Dequeue_priority+0xd4>
3000c4ac: e129f00c msr CPSR_fc, ip
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
3000c4b0: e59f1038 ldr r1, [pc, #56] ; 3000c4f0 <_Thread_queue_Dequeue_priority+0x104> 3000c4b4: e1a00004 mov r0, r4 3000c4b8: ebfffe14 bl 3000bd10 <_Thread_Clear_state> 3000c4bc: eaffffdc b 3000c434 <_Thread_queue_Dequeue_priority+0x48>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
3000c4c0: e3a03003 mov r3, #3 <== NOT EXECUTED 3000c4c4: e5843050 str r3, [r4, #80] ; 0x50 <== NOT EXECUTED 3000c4c8: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000c4cc: e2840048 add r0, r4, #72 ; 0x48 <== NOT EXECUTED 3000c4d0: eb0002d4 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 3000c4d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c4d8: e59f1010 ldr r1, [pc, #16] ; 3000c4f0 <_Thread_queue_Dequeue_priority+0x104><== NOT EXECUTED 3000c4dc: ebfffe0b bl 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED 3000c4e0: eaffffd3 b 3000c434 <_Thread_queue_Dequeue_priority+0x48> <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000c4e4: e5812000 str r2, [r1]
next_node->previous = previous_node;
3000c4e8: e5821004 str r1, [r2, #4] 3000c4ec: eaffffeb b 3000c4a0 <_Thread_queue_Dequeue_priority+0xb4>
3000c5a0 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
3000c5a0: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
3000c5a4: e92d05f0 push {r4, r5, r6, r7, r8, sl}
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
3000c5a8: e281403c add r4, r1, #60 ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
3000c5ac: e281c038 add ip, r1, #56 ; 0x38
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3000c5b0: e5814038 str r4, [r1, #56] ; 0x38
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
3000c5b4: e3130020 tst r3, #32
head->previous = NULL;
3000c5b8: e3a04000 mov r4, #0 3000c5bc: e581403c str r4, [r1, #60] ; 0x3c
tail->previous = head;
3000c5c0: e581c040 str ip, [r1, #64] ; 0x40
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
3000c5c4: e1a07323 lsr r7, r3, #6
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
3000c5c8: e5905038 ldr r5, [r0, #56] ; 0x38
if ( _Thread_queue_Is_reverse_search( priority ) )
3000c5cc: 1a00001e bne 3000c64c <_Thread_queue_Enqueue_priority+0xac>
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
}
3000c5d0: e0877087 add r7, r7, r7, lsl #1 3000c5d4: e1a0c107 lsl ip, r7, #2
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
3000c5d8: e28c7004 add r7, ip, #4 3000c5dc: e080a00c add sl, r0, ip 3000c5e0: e0807007 add r7, r0, r7
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c5e4: e10f8000 mrs r8, CPSR 3000c5e8: e388c080 orr ip, r8, #128 ; 0x80 3000c5ec: e129f00c msr CPSR_fc, ip 3000c5f0: e59ac000 ldr ip, [sl]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000c5f4: e15c0007 cmp ip, r7
3000c5f8: 1a000009 bne 3000c624 <_Thread_queue_Enqueue_priority+0x84>
3000c5fc: ea000051 b 3000c748 <_Thread_queue_Enqueue_priority+0x1a8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c600: e10f6000 mrs r6, CPSR 3000c604: e129f008 msr CPSR_fc, r8 3000c608: e129f006 msr CPSR_fc, r6
RTEMS_INLINE_ROUTINE bool _States_Are_set (
States_Control the_states,
States_Control mask
)
{
return ( (the_states & mask) != STATES_READY);
3000c60c: e59c6010 ldr r6, [ip, #16]
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
3000c610: e1150006 tst r5, r6
3000c614: 0a000034 beq 3000c6ec <_Thread_queue_Enqueue_priority+0x14c>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
3000c618: e59cc000 ldr ip, [ip]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_First( header );
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
3000c61c: e15c0007 cmp ip, r7
3000c620: 0a000002 beq 3000c630 <_Thread_queue_Enqueue_priority+0x90>
search_priority = search_thread->current_priority;
3000c624: e59c4014 ldr r4, [ip, #20]
if ( priority <= search_priority )
3000c628: e1530004 cmp r3, r4
3000c62c: 8afffff3 bhi 3000c600 <_Thread_queue_Enqueue_priority+0x60>
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
3000c630: e5905030 ldr r5, [r0, #48] ; 0x30 3000c634: e3550001 cmp r5, #1
3000c638: 0a00002d beq 3000c6f4 <_Thread_queue_Enqueue_priority+0x154> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level;
3000c63c: e5828000 str r8, [r2] <== NOT EXECUTED
return the_thread_queue->sync_state; }
3000c640: e1a00005 mov r0, r5
3000c644: e8bd05f0 pop {r4, r5, r6, r7, r8, sl}
3000c648: e12fff1e bx lr
3000c64c: e0877087 add r7, r7, r7, lsl #1
3000c650: e59fa0f8 ldr sl, [pc, #248] ; 3000c750 <_Thread_queue_Enqueue_priority+0x1b0>
3000c654: e0807107 add r7, r0, r7, lsl #2
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
3000c658: e5da4000 ldrb r4, [sl] 3000c65c: e2844001 add r4, r4, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c660: e10f8000 mrs r8, CPSR 3000c664: e388c080 orr ip, r8, #128 ; 0x80 3000c668: e129f00c msr CPSR_fc, ip
* * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; }
3000c66c: e597c008 ldr ip, [r7, #8]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000c670: e15c0007 cmp ip, r7
3000c674: 1a000009 bne 3000c6a0 <_Thread_queue_Enqueue_priority+0x100>
3000c678: ea00000b b 3000c6ac <_Thread_queue_Enqueue_priority+0x10c>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000c67c: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c680: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c684: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c688: e59c6010 ldr r6, [ip, #16] <== NOT EXECUTED
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
3000c68c: e1150006 tst r5, r6 <== NOT EXECUTED 3000c690: 0a000013 beq 3000c6e4 <_Thread_queue_Enqueue_priority+0x144><== NOT EXECUTED
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
3000c694: e59cc004 ldr ip, [ip, #4] <== NOT EXECUTED
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) _Chain_Last( header );
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
3000c698: e15c0007 cmp ip, r7 <== NOT EXECUTED 3000c69c: 0a000002 beq 3000c6ac <_Thread_queue_Enqueue_priority+0x10c><== NOT EXECUTED
search_priority = search_thread->current_priority;
3000c6a0: e59c4014 ldr r4, [ip, #20]
if ( priority >= search_priority )
3000c6a4: e1530004 cmp r3, r4
3000c6a8: 3afffff3 bcc 3000c67c <_Thread_queue_Enqueue_priority+0xdc>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
3000c6ac: e5905030 ldr r5, [r0, #48] ; 0x30 3000c6b0: e3550001 cmp r5, #1
3000c6b4: 1affffe0 bne 3000c63c <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000c6b8: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000c6bc: e3a03000 mov r3, #0 3000c6c0: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000c6c4: 0a000016 beq 3000c724 <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
3000c6c8: e59c3000 ldr r3, [ip]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
3000c6cc: e8811008 stm r1, {r3, ip}
search_node->next = the_node; next_node->previous = the_node;
3000c6d0: e5831004 str r1, [r3, #4]
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
3000c6d4: e58c1000 str r1, [ip]
next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
3000c6d8: e5810044 str r0, [r1, #68] ; 0x44
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c6dc: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c6e0: eaffffd6 b 3000c640 <_Thread_queue_Enqueue_priority+0xa0>
3000c6e4: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c6e8: eaffffda b 3000c658 <_Thread_queue_Enqueue_priority+0xb8> <== NOT EXECUTED 3000c6ec: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED 3000c6f0: eaffffbb b 3000c5e4 <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
3000c6f4: e1530004 cmp r3, r4
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
3000c6f8: e3a03000 mov r3, #0 3000c6fc: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
3000c700: 0a000007 beq 3000c724 <_Thread_queue_Enqueue_priority+0x184>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
3000c704: e59c3004 ldr r3, [ip, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000c708: e581c000 str ip, [r1]
the_node->previous = previous_node;
3000c70c: e5813004 str r3, [r1, #4]
previous_node->next = the_node;
3000c710: e5831000 str r1, [r3]
search_node->previous = the_node;
3000c714: e58c1004 str r1, [ip, #4]
the_thread->Wait.queue = the_thread_queue;
3000c718: e5810044 str r0, [r1, #68] ; 0x44 3000c71c: e129f008 msr CPSR_fc, r8
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c720: eaffffc6 b 3000c640 <_Thread_queue_Enqueue_priority+0xa0>
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
3000c724: e59c3040 ldr r3, [ip, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
3000c728: e28c203c add r2, ip, #60 ; 0x3c <== NOT EXECUTED
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
3000c72c: e881000c stm r1, {r2, r3} <== NOT EXECUTED
the_node->previous = previous_node; previous_node->next = the_node;
3000c730: e5831000 str r1, [r3] <== NOT EXECUTED
search_node->previous = the_node;
3000c734: e58c1040 str r1, [ip, #64] ; 0x40 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
3000c738: e5810044 str r0, [r1, #68] ; 0x44 <== NOT EXECUTED 3000c73c: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c740: e3a05001 mov r5, #1 <== NOT EXECUTED 3000c744: eaffffbd b 3000c640 <_Thread_queue_Enqueue_priority+0xa0> <== NOT EXECUTED
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
3000c748: e3e04000 mvn r4, #0 3000c74c: eaffffb7 b 3000c630 <_Thread_queue_Enqueue_priority+0x90>
30011048 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread
)
{
30011048: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3001104c: e24dd004 sub sp, sp, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30011050: e10f0000 mrs r0, CPSR 30011054: e3803080 orr r3, r0, #128 ; 0x80 30011058: e129f003 msr CPSR_fc, r3 3001105c: e59f3070 ldr r3, [pc, #112] ; 300110d4 <_Thread_queue_Extract_fifo+0x8c> 30011060: e5912010 ldr r2, [r1, #16] 30011064: e0023003 and r3, r2, r3
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
30011068: e3530000 cmp r3, #0
3001106c: 0a00000d beq 300110a8 <_Thread_queue_Extract_fifo+0x60>
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
30011070: e591c050 ldr ip, [r1, #80] ; 0x50
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
30011074: e891000c ldm r1, {r2, r3}
30011078: e35c0002 cmp ip, #2
next->previous = previous;
3001107c: e5823004 str r3, [r2, #4]
previous->next = next;
30011080: e5832000 str r2, [r3]
return;
}
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
30011084: e3a03000 mov r3, #0 30011088: e5813044 str r3, [r1, #68] ; 0x44
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3001108c: 0a000008 beq 300110b4 <_Thread_queue_Extract_fifo+0x6c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30011090: e129f000 msr CPSR_fc, r0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
30011094: e1a00001 mov r0, r1 30011098: e59f1038 ldr r1, [pc, #56] ; 300110d8 <_Thread_queue_Extract_fifo+0x90>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3001109c: e28dd004 add sp, sp, #4
300110a0: e49de004 pop {lr} ; (ldr lr, [sp], #4)
300110a4: eaffeb19 b 3000bd10 <_Thread_Clear_state>
300110a8: e129f000 msr CPSR_fc, r0
300110ac: e28dd004 add sp, sp, #4
300110b0: e8bd8000 pop {pc}
300110b4: e3a03003 mov r3, #3 <== NOT EXECUTED 300110b8: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 300110bc: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
300110c0: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 300110c4: e58d1000 str r1, [sp] <== NOT EXECUTED 300110c8: ebffefd6 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 300110cc: e59d1000 ldr r1, [sp] <== NOT EXECUTED 300110d0: eaffffef b 30011094 <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED
3000f8e8 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue __attribute__((unused)),
Thread_Control *the_thread,
bool requeuing
)
{
3000f8e8: e92d4070 push {r4, r5, r6, lr}
3000f8ec: e20220ff and r2, r2, #255 ; 0xff
3000f8f0: e24dd004 sub sp, sp, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000f8f4: e10fc000 mrs ip, CPSR 3000f8f8: e38c3080 orr r3, ip, #128 ; 0x80 3000f8fc: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_on_thread_queue (
States_Control the_states
)
{
return (the_states & STATES_WAITING_ON_THREAD_QUEUE);
3000f900: e59f30c4 ldr r3, [pc, #196] ; 3000f9cc <_Thread_queue_Extract_priority_helper+0xe4> 3000f904: e5910010 ldr r0, [r1, #16] 3000f908: e0003003 and r3, r0, r3
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000f90c: e3530000 cmp r3, #0
3000f910: 0a000023 beq 3000f9a4 <_Thread_queue_Extract_priority_helper+0xbc>
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000f914: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3000f918: e281003c add r0, r1, #60 ; 0x3c <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000f91c: e1530000 cmp r3, r0 <== NOT EXECUTED
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
previous_node = the_node->previous;
3000f920: e8910011 ldm r1, {r0, r4} <== NOT EXECUTED
head->next = new_second_node;
tail->previous = last_node;
last_node->next = tail;
}
} else {
previous_node->next = next_node;
3000f924: 05840000 streq r0, [r4] <== NOT EXECUTED
next_node->previous = previous_node;
3000f928: 05804004 streq r4, [r0, #4] <== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
3000f92c: 0a00000e beq 3000f96c <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000f930: e5915040 ldr r5, [r1, #64] ; 0x40 <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
3000f934: e5936000 ldr r6, [r3] <== NOT EXECUTED
previous_node->next = new_first_node;
next_node->previous = new_first_node;
3000f938: e5803004 str r3, [r0, #4] <== NOT EXECUTED
new_first_node = _Chain_First( &the_thread->Wait.Block2n );
new_first_thread = (Thread_Control *) new_first_node;
last_node = _Chain_Last( &the_thread->Wait.Block2n );
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
3000f93c: e5843000 str r3, [r4] <== NOT EXECUTED
next_node->previous = new_first_node;
new_first_node->next = next_node;
new_first_node->previous = previous_node;
3000f940: e8830011 stm r3, {r0, r4} <== NOT EXECUTED
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
3000f944: e5914038 ldr r4, [r1, #56] ; 0x38 <== NOT EXECUTED 3000f948: e5910040 ldr r0, [r1, #64] ; 0x40 <== NOT EXECUTED 3000f94c: e1540000 cmp r4, r0 <== NOT EXECUTED 3000f950: 0a000005 beq 3000f96c <_Thread_queue_Extract_priority_helper+0x84><== NOT EXECUTED
/* > two threads on 2-n */
head = _Chain_Head( &new_first_thread->Wait.Block2n );
3000f954: e2834038 add r4, r3, #56 ; 0x38 <== NOT EXECUTED
tail = _Chain_Tail( &new_first_thread->Wait.Block2n );
3000f958: e283003c add r0, r3, #60 ; 0x3c <== NOT EXECUTED
new_second_node->previous = head;
3000f95c: e5864004 str r4, [r6, #4] <== NOT EXECUTED
head->next = new_second_node;
3000f960: e5836038 str r6, [r3, #56] ; 0x38 <== NOT EXECUTED
tail->previous = last_node;
3000f964: e5835040 str r5, [r3, #64] ; 0x40 <== NOT EXECUTED
last_node->next = tail;
3000f968: e5850000 str r0, [r5] <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
3000f96c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000f970: 1a000008 bne 3000f998 <_Thread_queue_Extract_priority_helper+0xb0><== NOT EXECUTED
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
3000f974: e5913050 ldr r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000f978: e3530002 cmp r3, #2 <== NOT EXECUTED 3000f97c: 0a00000a beq 3000f9ac <_Thread_queue_Extract_priority_helper+0xc4><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000f980: e129f00c msr CPSR_fc, ip <== NOT EXECUTED 3000f984: e1a00001 mov r0, r1 <== NOT EXECUTED 3000f988: e59f1040 ldr r1, [pc, #64] ; 3000f9d0 <_Thread_queue_Extract_priority_helper+0xe8><== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
_Thread_MP_Free_proxy( the_thread );
#endif
}
3000f98c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000f990: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
3000f994: eafff0dd b 3000bd10 <_Thread_Clear_state> <== NOT EXECUTED
3000f998: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
3000f99c: e28dd004 add sp, sp, #4
3000f9a0: e8bd8070 pop {r4, r5, r6, pc}
3000f9a4: e129f00c msr CPSR_fc, ip
3000f9a8: eafffffb b 3000f99c <_Thread_queue_Extract_priority_helper+0xb4>
3000f9ac: e3a03003 mov r3, #3 <== NOT EXECUTED 3000f9b0: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED 3000f9b4: e129f00c msr CPSR_fc, ip <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
3000f9b8: e2810048 add r0, r1, #72 ; 0x48 <== NOT EXECUTED 3000f9bc: e58d1000 str r1, [sp] <== NOT EXECUTED 3000f9c0: ebfff598 bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED 3000f9c4: e59d1000 ldr r1, [sp] <== NOT EXECUTED 3000f9c8: eaffffed b 3000f984 <_Thread_queue_Extract_priority_helper+0x9c><== NOT EXECUTED
30021438 <_Thread_queue_First_priority>:
*/
Thread_Control *_Thread_queue_First_priority (
Thread_queue_Control *the_thread_queue
)
{
30021438: e3a03000 mov r3, #0 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
3002143c: e1a02003 mov r2, r3 <== NOT EXECUTED 30021440: e082c082 add ip, r2, r2, lsl #1 <== NOT EXECUTED
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
}
30021444: e7901003 ldr r1, [r0, r3] <== NOT EXECUTED 30021448: e080c10c add ip, r0, ip, lsl #2 <== NOT EXECUTED 3002144c: e28cc004 add ip, ip, #4 <== NOT EXECUTED
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
30021450: e151000c cmp r1, ip <== NOT EXECUTED
{
uint32_t index;
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
30021454: e2822001 add r2, r2, #1 <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
30021458: 1a000004 bne 30021470 <_Thread_queue_First_priority+0x38> <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
3002145c: e3520004 cmp r2, #4 <== NOT EXECUTED
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
30021460: e283300c add r3, r3, #12 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue
)
{
uint32_t index;
for( index=0 ;
30021464: 1afffff5 bne 30021440 <_Thread_queue_First_priority+0x8> <== NOT EXECUTED
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *) _Chain_First(
&the_thread_queue->Queues.Priority[ index ]
);
}
return NULL;
30021468: e3a00000 mov r0, #0 <== NOT EXECUTED
}
3002146c: e12fff1e bx lr <== NOT EXECUTED
for( index=0 ;
index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
index++ ) {
if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
return (Thread_Control *) _Chain_First(
30021470: e1a00001 mov r0, r1 <== NOT EXECUTED 30021474: e12fff1e bx lr <== NOT EXECUTED
3000f9d4 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
3000f9d4: e1a01000 mov r1, r0 <== NOT EXECUTED
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
3000f9d8: e5900044 ldr r0, [r0, #68] ; 0x44 <== NOT EXECUTED
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
3000f9dc: e5903030 ldr r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000f9e0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000f9e4: 0a000003 beq 3000f9f8 <_Thread_queue_Process_timeout+0x24> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000f9e8: e59f202c ldr r2, [pc, #44] ; 3000fa1c <_Thread_queue_Process_timeout+0x48><== NOT EXECUTED 3000f9ec: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 3000f9f0: e1510002 cmp r1, r2 <== NOT EXECUTED 3000f9f4: 0a000002 beq 3000fa04 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000f9f8: e590303c ldr r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000f9fc: e5813034 str r3, [r1, #52] ; 0x34 <== NOT EXECUTED
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
3000fa00: eaffffb2 b 3000f8d0 <_Thread_queue_Extract> <== NOT EXECUTED
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
3000fa04: e3530003 cmp r3, #3 <== NOT EXECUTED
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
3000fa08: 1590303c ldrne r3, [r0, #60] ; 0x3c <== NOT EXECUTED 3000fa0c: 15813034 strne r3, [r1, #52] ; 0x34 <== NOT EXECUTED
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
3000fa10: 13a03002 movne r3, #2 <== NOT EXECUTED 3000fa14: 15803030 strne r3, [r0, #48] ; 0x30 <== NOT EXECUTED 3000fa18: e12fff1e bx lr <== NOT EXECUTED
3000c818 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000c818: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000c81c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
3000c820: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000c824: e1a05001 mov r5, r1 <== NOT EXECUTED
/* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue )
3000c828: 0a000002 beq 3000c838 <_Thread_queue_Requeue+0x20> <== NOT EXECUTED
/*
* If queueing by FIFO, there is nothing to do. This only applies to
* priority blocking discipline.
*/
if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
3000c82c: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3000c830: e3530001 cmp r3, #1 <== NOT EXECUTED 3000c834: 0a000001 beq 3000c840 <_Thread_queue_Requeue+0x28> <== NOT EXECUTED
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
}
}
3000c838: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c83c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000c840: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000c844: e3862080 orr r2, r6, #128 ; 0x80 <== NOT EXECUTED 3000c848: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 3000c84c: e59f2034 ldr r2, [pc, #52] ; 3000c888 <_Thread_queue_Requeue+0x70><== NOT EXECUTED 3000c850: e591c010 ldr ip, [r1, #16] <== NOT EXECUTED 3000c854: e00c2002 and r2, ip, r2 <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
3000c858: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c85c: 1a000001 bne 3000c868 <_Thread_queue_Requeue+0x50> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000c860: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000c864: eafffff3 b 3000c838 <_Thread_queue_Requeue+0x20> <== NOT EXECUTED
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
3000c868: e1a02003 mov r2, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
3000c86c: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED 3000c870: eb000c1c bl 3000f8e8 <_Thread_queue_Extract_priority_helper><== NOT EXECUTED
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
3000c874: e1a00004 mov r0, r4 <== NOT EXECUTED 3000c878: e1a01005 mov r1, r5 <== NOT EXECUTED 3000c87c: e1a0200d mov r2, sp <== NOT EXECUTED 3000c880: ebffff46 bl 3000c5a0 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 3000c884: eafffff5 b 3000c860 <_Thread_queue_Requeue+0x48> <== NOT EXECUTED
3000c88c <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
3000c88c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000c890: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000c894: e1a0100d mov r1, sp <== NOT EXECUTED 3000c898: ebfffe02 bl 3000c0a8 <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
3000c89c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000c8a0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c8a4: 1a000004 bne 3000c8bc <_Thread_queue_Timeout+0x30> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
3000c8a8: eb000c49 bl 3000f9d4 <_Thread_queue_Process_timeout> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
3000c8ac: e59f3010 ldr r3, [pc, #16] ; 3000c8c4 <_Thread_queue_Timeout+0x38><== NOT EXECUTED 3000c8b0: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000c8b4: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000c8b8: e5832000 str r2, [r3] <== NOT EXECUTED
_Thread_Unnest_dispatch();
break;
}
}
3000c8bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000c8c0: e8bd8000 pop {pc} <== NOT EXECUTED
3001a5b4 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
3001a5b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a5b8: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5bc: e28d101c add r1, sp, #28 <== NOT EXECUTED 3001a5c0: e2812004 add r2, r1, #4 <== NOT EXECUTED 3001a5c4: e28d7010 add r7, sp, #16 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a5c8: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED 3001a5cc: e2801008 add r1, r0, #8 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001a5d0: e3a03000 mov r3, #0 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5d4: e287a004 add sl, r7, #4 <== NOT EXECUTED 3001a5d8: e58d1008 str r1, [sp, #8] <== NOT EXECUTED 3001a5dc: e59f91c0 ldr r9, [pc, #448] ; 3001a7a4 <_Timer_server_Body+0x1f0><== NOT EXECUTED 3001a5e0: e2801040 add r1, r0, #64 ; 0x40 <== NOT EXECUTED 3001a5e4: e59fb1bc ldr fp, [pc, #444] ; 3001a7a8 <_Timer_server_Body+0x1f4><== NOT EXECUTED 3001a5e8: e1a04000 mov r4, r0 <== NOT EXECUTED 3001a5ec: e58d201c str r2, [sp, #28] <== NOT EXECUTED
head->previous = NULL;
3001a5f0: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a5f4: e58da010 str sl, [sp, #16] <== NOT EXECUTED
head->previous = NULL;
3001a5f8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
tail->previous = head;
3001a5fc: e58d7018 str r7, [sp, #24] <== NOT EXECUTED 3001a600: e2806030 add r6, r0, #48 ; 0x30 <== NOT EXECUTED 3001a604: e2808068 add r8, r0, #104 ; 0x68 <== NOT EXECUTED 3001a608: e58d100c str r1, [sp, #12] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
3001a60c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
Chain_Control *tmp; /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain;
3001a610: e28d201c add r2, sp, #28 <== NOT EXECUTED 3001a614: e58da000 str sl, [sp] <== NOT EXECUTED 3001a618: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED 3001a61c: e5842078 str r2, [r4, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
3001a620: e5993000 ldr r3, [r9] <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
3001a624: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001a628: e1a02007 mov r2, r7 <== NOT EXECUTED 3001a62c: e1a00006 mov r0, r6 <== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
3001a630: e584303c str r3, [r4, #60] ; 0x3c <== NOT EXECUTED
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001a634: e0611003 rsb r1, r1, r3 <== NOT EXECUTED 3001a638: eb001166 bl 3001ebd8 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a63c: e59b5000 ldr r5, [fp] <== NOT EXECUTED
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
3001a640: e5942074 ldr r2, [r4, #116] ; 0x74 <== NOT EXECUTED
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
3001a644: e1550002 cmp r5, r2 <== NOT EXECUTED 3001a648: 8a00003c bhi 3001a740 <_Timer_server_Body+0x18c> <== NOT EXECUTED
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
3001a64c: 3a000032 bcc 3001a71c <_Timer_server_Body+0x168> <== NOT EXECUTED
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
3001a650: e5845074 str r5, [r4, #116] ; 0x74 <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001a654: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a658: eb0002be bl 3001b158 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001a65c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001a660: 0a00000b beq 3001a694 <_Timer_server_Body+0xe0> <== NOT EXECUTED
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a664: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 3001a668: e3530001 cmp r3, #1 <== NOT EXECUTED 3001a66c: 0a00002f beq 3001a730 <_Timer_server_Body+0x17c> <== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001a670: e3530003 cmp r3, #3 <== NOT EXECUTED 3001a674: 1afffff6 bne 3001a654 <_Timer_server_Body+0xa0> <== NOT EXECUTED
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001a678: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001a67c: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a680: eb00117f bl 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
3001a684: e5940078 ldr r0, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a688: eb0002b2 bl 3001b158 <_Chain_Get> <== NOT EXECUTED
if ( timer == NULL ) {
3001a68c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 3001a690: 1afffff3 bne 3001a664 <_Timer_server_Body+0xb0> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a694: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001a698: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 3001a69c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
3001a6a0: e5942078 ldr r2, [r4, #120] ; 0x78 <== NOT EXECUTED
if ( _Chain_Is_empty( insert_chain ) ) {
3001a6a4: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3001a6a8: e152000a cmp r2, sl <== NOT EXECUTED
ts->insert_chain = NULL;
3001a6ac: 05841078 streq r1, [r4, #120] ; 0x78 <== NOT EXECUTED
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
tmp = ts->insert_chain;
if ( _Chain_Is_empty( insert_chain ) ) {
3001a6b0: 13a01001 movne r1, #1 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a6b4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
while ( do_loop ) {
3001a6b8: e3510000 cmp r1, #0 <== NOT EXECUTED 3001a6bc: 1affffd7 bne 3001a620 <_Timer_server_Body+0x6c> <== NOT EXECUTED 3001a6c0: e59da000 ldr sl, [sp] <== NOT EXECUTED
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
3001a6c4: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3001a6c8: e153000a cmp r3, sl <== NOT EXECUTED 3001a6cc: 1a00000a bne 3001a6fc <_Timer_server_Body+0x148> <== NOT EXECUTED 3001a6d0: ea00001f b 3001a754 <_Timer_server_Body+0x1a0> <== NOT EXECUTED
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
3001a6d4: e5932000 ldr r2, [r3] <== NOT EXECUTED
head->next = new_first;
new_first->previous = head;
3001a6d8: e5827004 str r7, [r2, #4] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
3001a6dc: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
3001a6e0: e3a02000 mov r2, #0 <== NOT EXECUTED 3001a6e4: e5832008 str r2, [r3, #8] <== NOT EXECUTED 3001a6e8: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
3001a6ec: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3001a6f0: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3001a6f4: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a6f8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a6fc: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a700: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a704: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a708: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
3001a70c: e153000a cmp r3, sl <== NOT EXECUTED 3001a710: 1affffef bne 3001a6d4 <_Timer_server_Body+0x120> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a714: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 3001a718: eaffffbc b 3001a610 <_Timer_server_Body+0x5c> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
3001a71c: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a720: e3a01001 mov r1, #1 <== NOT EXECUTED 3001a724: e0652002 rsb r2, r5, r2 <== NOT EXECUTED 3001a728: eb0010f9 bl 3001eb14 <_Watchdog_Adjust> <== NOT EXECUTED 3001a72c: eaffffc7 b 3001a650 <_Timer_server_Body+0x9c> <== NOT EXECUTED
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
3001a730: e1a00006 mov r0, r6 <== NOT EXECUTED 3001a734: e2811010 add r1, r1, #16 <== NOT EXECUTED 3001a738: eb001151 bl 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED 3001a73c: eaffffc4 b 3001a654 <_Timer_server_Body+0xa0> <== NOT EXECUTED
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
3001a740: e0621005 rsb r1, r2, r5 <== NOT EXECUTED 3001a744: e1a00008 mov r0, r8 <== NOT EXECUTED 3001a748: e1a02007 mov r2, r7 <== NOT EXECUTED 3001a74c: eb001121 bl 3001ebd8 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 3001a750: eaffffbe b 3001a650 <_Timer_server_Body+0x9c> <== NOT EXECUTED
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
3001a754: e5c4107c strb r1, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a758: e59f104c ldr r1, [pc, #76] ; 3001a7ac <_Timer_server_Body+0x1f8><== NOT EXECUTED 3001a75c: e5913000 ldr r3, [r1] <== NOT EXECUTED 3001a760: e2833001 add r3, r3, #1 <== NOT EXECUTED 3001a764: e5813000 str r3, [r1] <== NOT EXECUTED
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
3001a768: e3a01008 mov r1, #8 <== NOT EXECUTED 3001a76c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3001a770: eb000f43 bl 3001e484 <_Thread_Set_state> <== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001a774: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a778: ebffff61 bl 3001a504 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001a77c: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a780: ebffff75 bl 3001a55c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED
_Thread_Enable_dispatch();
3001a784: eb000cf7 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
ts->active = true;
3001a788: e3a02001 mov r2, #1 <== NOT EXECUTED 3001a78c: e5c4207c strb r2, [r4, #124] ; 0x7c <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
3001a790: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3001a794: eb0011a9 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001a798: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 3001a79c: eb0011a7 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED 3001a7a0: eaffff9a b 3001a610 <_Timer_server_Body+0x5c> <== NOT EXECUTED
3001a504 <_Timer_server_Reset_interval_system_watchdog>:
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001a504: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
3001a508: e2805008 add r5, r0, #8 <== NOT EXECUTED
}
static void _Timer_server_Reset_interval_system_watchdog(
Timer_server_Control *ts
)
{
3001a50c: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
3001a510: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a514: eb001249 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a518: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a51c: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a520: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a524: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001a528: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_interval_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001a52c: e1530002 cmp r3, r2 <== NOT EXECUTED 3001a530: 0a000006 beq 3001a550 <_Timer_server_Reset_interval_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001a534: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a538: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001a53c: e59f0014 ldr r0, [pc, #20] ; 3001a558 <_Timer_server_Reset_interval_system_watchdog+0x54><== NOT EXECUTED 3001a540: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a544: e5843014 str r3, [r4, #20] <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001a548: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3001a54c: ea0011cc b 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED
3001a550: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001a554: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a55c <_Timer_server_Reset_tod_system_watchdog>:
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001a55c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001a560: e2805040 add r5, r0, #64 ; 0x40 <== NOT EXECUTED
}
static void _Timer_server_Reset_tod_system_watchdog(
Timer_server_Control *ts
)
{
3001a564: e1a04000 mov r4, r0 <== NOT EXECUTED
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
3001a568: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a56c: eb001233 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a570: e10f1000 mrs r1, CPSR <== NOT EXECUTED 3001a574: e3813080 orr r3, r1, #128 ; 0x80 <== NOT EXECUTED 3001a578: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a57c: e5943068 ldr r3, [r4, #104] ; 0x68 <== NOT EXECUTED 3001a580: e284206c add r2, r4, #108 ; 0x6c <== NOT EXECUTED
ISR_Level level;
_Timer_server_Stop_tod_system_watchdog( ts );
_ISR_Disable( level );
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001a584: e1530002 cmp r3, r2 <== NOT EXECUTED 3001a588: 0a000006 beq 3001a5a8 <_Timer_server_Reset_tod_system_watchdog+0x4c><== NOT EXECUTED
Watchdog_Interval delta_interval =
3001a58c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a590: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a594: e59f0014 ldr r0, [pc, #20] ; 3001a5b0 <_Timer_server_Reset_tod_system_watchdog+0x54><== NOT EXECUTED 3001a598: e1a01005 mov r1, r5 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a59c: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
delta_interval
);
} else {
_ISR_Enable( level );
}
}
3001a5a0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a5a4: ea0011b6 b 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED
3001a5a8: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
3001a5ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a7b0 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( ts->insert_chain == NULL ) {
3001a7b0: e5902078 ldr r2, [r0, #120] ; 0x78 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001a7b4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001a7b8: e3520000 cmp r2, #0 <== NOT EXECUTED
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
3001a7bc: e1a04000 mov r4, r0 <== NOT EXECUTED 3001a7c0: e1a03001 mov r3, r1 <== NOT EXECUTED
if ( ts->insert_chain == NULL ) {
3001a7c4: 0a000002 beq 3001a7d4 <_Timer_server_Schedule_operation_method+0x24><== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
3001a7c8: e5900078 ldr r0, [r0, #120] ; 0x78 <== NOT EXECUTED
} }
3001a7cc: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
* server is not preemptible, so we must be in interrupt context here. No
* thread dispatch will happen until the timer server finishes its
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
3001a7d0: ea00024d b 3001b10c <_Chain_Append> <== NOT EXECUTED 3001a7d4: e59f1104 ldr r1, [pc, #260] ; 3001a8e0 <_Timer_server_Schedule_operation_method+0x130><== NOT EXECUTED 3001a7d8: e5910000 ldr r0, [r1] <== NOT EXECUTED 3001a7dc: e2800001 add r0, r0, #1 <== NOT EXECUTED 3001a7e0: e5810000 str r0, [r1] <== NOT EXECUTED
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a7e4: e5931038 ldr r1, [r3, #56] ; 0x38 <== NOT EXECUTED 3001a7e8: e3510001 cmp r1, #1 <== NOT EXECUTED 3001a7ec: 0a000021 beq 3001a878 <_Timer_server_Schedule_operation_method+0xc8><== NOT EXECUTED
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
if ( !ts->active ) {
_Timer_server_Reset_interval_system_watchdog( ts );
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
3001a7f0: e3510003 cmp r1, #3 <== NOT EXECUTED 3001a7f4: 0a000001 beq 3001a800 <_Timer_server_Schedule_operation_method+0x50><== NOT EXECUTED
* critical section. We have to use the protected chain methods because
* we may be interrupted by a higher priority interrupt.
*/
_Chain_Append( ts->insert_chain, &timer->Object.Node );
}
}
3001a7f8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
if ( !ts->active ) {
_Timer_server_Reset_tod_system_watchdog( ts );
}
}
_Thread_Enable_dispatch();
3001a7fc: ea000cd9 b 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a800: e10fe000 mrs lr, CPSR <== NOT EXECUTED 3001a804: e38e1080 orr r1, lr, #128 ; 0x80 <== NOT EXECUTED 3001a808: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a80c: e5941068 ldr r1, [r4, #104] ; 0x68 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
3001a810: e284006c add r0, r4, #108 ; 0x6c <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001a814: e1510000 cmp r1, r0 <== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a818: e59f00c4 ldr r0, [pc, #196] ; 3001a8e4 <_Timer_server_Schedule_operation_method+0x134><== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
3001a81c: e594c074 ldr ip, [r4, #116] ; 0x74 <== NOT EXECUTED
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a820: e5900000 ldr r0, [r0] <== NOT EXECUTED
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
3001a824: 0a000008 beq 3001a84c <_Timer_server_Schedule_operation_method+0x9c><== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
3001a828: e5915010 ldr r5, [r1, #16] <== NOT EXECUTED
if ( snapshot > last_snapshot ) {
3001a82c: e150000c cmp r0, ip <== NOT EXECUTED
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
3001a830: 9085200c addls r2, r5, ip <== NOT EXECUTED
delta_interval += delta;
3001a834: 90602002 rsbls r2, r0, r2 <== NOT EXECUTED
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
3001a838: 9a000002 bls 3001a848 <_Timer_server_Schedule_operation_method+0x98><== NOT EXECUTED
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
3001a83c: e06cc000 rsb ip, ip, r0 <== NOT EXECUTED
if (delta_interval > delta) {
3001a840: e155000c cmp r5, ip <== NOT EXECUTED
delta_interval -= delta;
3001a844: 806c2005 rsbhi r2, ip, r5 <== NOT EXECUTED
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
3001a848: e5812010 str r2, [r1, #16] <== NOT EXECUTED
}
ts->TOD_watchdogs.last_snapshot = snapshot;
3001a84c: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a850: e129f00e msr CPSR_fc, lr <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
3001a854: e2831010 add r1, r3, #16 <== NOT EXECUTED 3001a858: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED 3001a85c: eb001108 bl 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001a860: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a864: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a868: 1affffe2 bne 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_tod_system_watchdog( ts );
3001a86c: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a870: ebffff39 bl 3001a55c <_Timer_server_Reset_tod_system_watchdog><== NOT EXECUTED 3001a874: eaffffdf b 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a878: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3001a87c: e3851080 orr r1, r5, #128 ; 0x80 <== NOT EXECUTED 3001a880: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001a884: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED 3001a888: e2840034 add r0, r4, #52 ; 0x34 <== NOT EXECUTED
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
last_snapshot = ts->Interval_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001a88c: e1510000 cmp r1, r0 <== NOT EXECUTED
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
snapshot = _Watchdog_Ticks_since_boot;
3001a890: e59f0050 ldr r0, [pc, #80] ; 3001a8e8 <_Timer_server_Schedule_operation_method+0x138><== NOT EXECUTED 3001a894: e5900000 ldr r0, [r0] <== NOT EXECUTED
last_snapshot = ts->Interval_watchdogs.last_snapshot;
3001a898: e594c03c ldr ip, [r4, #60] ; 0x3c <== NOT EXECUTED
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
3001a89c: 0a000004 beq 3001a8b4 <_Timer_server_Schedule_operation_method+0x104><== NOT EXECUTED
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
3001a8a0: e591e010 ldr lr, [r1, #16] <== NOT EXECUTED
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
3001a8a4: e06cc000 rsb ip, ip, r0 <== NOT EXECUTED
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
3001a8a8: e15c000e cmp ip, lr <== NOT EXECUTED
delta_interval -= delta;
3001a8ac: 306c200e rsbcc r2, ip, lr <== NOT EXECUTED
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
3001a8b0: e5812010 str r2, [r1, #16] <== NOT EXECUTED
}
ts->Interval_watchdogs.last_snapshot = snapshot;
3001a8b4: e584003c str r0, [r4, #60] ; 0x3c <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a8b8: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
3001a8bc: e2831010 add r1, r3, #16 <== NOT EXECUTED 3001a8c0: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 3001a8c4: eb0010ee bl 3001ec84 <_Watchdog_Insert> <== NOT EXECUTED
if ( !ts->active ) {
3001a8c8: e5d4307c ldrb r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3001a8cc: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a8d0: 1affffc8 bne 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
_Timer_server_Reset_interval_system_watchdog( ts );
3001a8d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a8d8: ebffff09 bl 3001a504 <_Timer_server_Reset_interval_system_watchdog><== NOT EXECUTED 3001a8dc: eaffffc5 b 3001a7f8 <_Timer_server_Schedule_operation_method+0x48><== NOT EXECUTED
3000cb00 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000cb00: e1a03000 mov r3, r0
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000cb04: e5902004 ldr r2, [r0, #4]
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
3000cb08: e52d4004 push {r4} ; (str r4, [sp, #-4]!)
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
3000cb0c: e8910011 ldm r1, {r0, r4}
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cb10: e59fc040 ldr ip, [pc, #64] ; 3000cb58 <_Timespec_Add_to+0x58>
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cb14: e5931000 ldr r1, [r3]
time->tv_nsec += add->tv_nsec;
3000cb18: e0844002 add r4, r4, r2
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cb1c: e0811000 add r1, r1, r0
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cb20: e154000c cmp r4, ip 3000cb24: e1a02004 mov r2, r4
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
3000cb28: e8830012 stm r3, {r1, r4}
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cb2c: 9a000007 bls 3000cb50 <_Timespec_Add_to+0x50>
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
3000cb30: e2822331 add r2, r2, #-1006632960 ; 0xc4000000 <== NOT EXECUTED 3000cb34: e2822865 add r2, r2, #6619136 ; 0x650000 <== NOT EXECUTED 3000cb38: e2822c36 add r2, r2, #13824 ; 0x3600 <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cb3c: e152000c cmp r2, ip <== NOT EXECUTED
*
* This routines adds two timespecs. The second argument is added
* to the first.
*/
uint32_t _Timespec_Add_to(
3000cb40: e2811001 add r1, r1, #1 <== NOT EXECUTED
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
seconds++;
3000cb44: e2800001 add r0, r0, #1 <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
3000cb48: 8afffff8 bhi 3000cb30 <_Timespec_Add_to+0x30> <== NOT EXECUTED
3000cb4c: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
time->tv_sec++;
seconds++;
}
return seconds;
}
3000cb50: e8bd0010 pop {r4}
3000cb54: e12fff1e bx lr
3000e7b8 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e7b8: e92d48f0 push {r4, r5, r6, r7, fp, lr}
* in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec;
3000e7bc: e5916004 ldr r6, [r1, #4]
* For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000e7c0: e591c000 ldr ip, [r1] 3000e7c4: e59f1074 ldr r1, [pc, #116] ; 3000e840 <_Timespec_Divide+0x88>
right += rhs->tv_nsec;
3000e7c8: e1a07fc6 asr r7, r6, #31 3000e7cc: e0e76c91 smlal r6, r7, r1, ip
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e7d0: e1a04003 mov r4, r3
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
3000e7d4: e196c007 orrs ip, r6, r7
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
3000e7d8: e8900808 ldm r0, {r3, fp}
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
3000e7dc: e1a05002 mov r5, r2
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
3000e7e0: 0582c000 streq ip, [r2]
*fval_percentage = 0;
3000e7e4: 0584c000 streq ip, [r4]
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
3000e7e8: 08bd88f0 popeq {r4, r5, r6, r7, fp, pc}
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; left += lhs->tv_nsec;
3000e7ec: e1a0cfcb asr ip, fp, #31 <== NOT EXECUTED 3000e7f0: e0ecb391 smlal fp, ip, r1, r3 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000e7f4: e59fe048 ldr lr, [pc, #72] ; 3000e844 <_Timespec_Divide+0x8c><== NOT EXECUTED 3000e7f8: e1a02006 mov r2, r6 <== NOT EXECUTED 3000e7fc: e0810e9b umull r0, r1, fp, lr <== NOT EXECUTED 3000e800: e1a03007 mov r3, r7 <== NOT EXECUTED 3000e804: e0211c9e mla r1, lr, ip, r1 <== NOT EXECUTED 3000e808: eb003d23 bl 3001dc9c <__udivdi3> <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000e80c: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED 3000e810: e3a03000 mov r3, #0 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
3000e814: e1a06000 mov r6, r0 <== NOT EXECUTED 3000e818: e1a07001 mov r7, r1 <== NOT EXECUTED
*ival_percentage = answer / 1000;
3000e81c: eb003d1e bl 3001dc9c <__udivdi3> <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000e820: e1a01007 mov r1, r7 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
3000e824: e5850000 str r0, [r5] <== NOT EXECUTED
*fval_percentage = answer % 1000;
3000e828: e3a02ffa mov r2, #1000 ; 0x3e8 <== NOT EXECUTED
3000e82c: e3a03000 mov r3, #0 <== NOT EXECUTED
3000e830: e1a00006 mov r0, r6 <== NOT EXECUTED
3000e834: eb003e2a bl 3001e0e4 <__umoddi3> <== NOT EXECUTED
3000e838: e5840000 str r0, [r4] <== NOT EXECUTED
3000e83c: e8bd88f0 pop {r4, r5, r6, r7, fp, pc} <== NOT EXECUTED
3000e7c8 <_Timespec_Divide_by_integer>:
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000e7c8: e590c000 ldr ip, [r0] <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000e7cc: e59f3068 ldr r3, [pc, #104] ; 3000e83c <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000e7d0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; t *= TOD_NANOSECONDS_PER_SECOND;
3000e7d4: e086539c umull r5, r6, ip, r3 <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
t = time->tv_sec;
3000e7d8: e1a0700c mov r7, ip <== NOT EXECUTED 3000e7dc: e1a08fc7 asr r8, r7, #31 <== NOT EXECUTED
t *= TOD_NANOSECONDS_PER_SECOND;
3000e7e0: e0266893 mla r6, r3, r8, r6 <== NOT EXECUTED
t += time->tv_nsec;
3000e7e4: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
void _Timespec_Divide_by_integer(
const struct timespec *time,
uint32_t iterations,
struct timespec *result
)
{
3000e7e8: e1a04002 mov r4, r2 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000e7ec: e0957000 adds r7, r5, r0 <== NOT EXECUTED 3000e7f0: e0a68fc0 adc r8, r6, r0, asr #31 <== NOT EXECUTED 3000e7f4: e1a02001 mov r2, r1 <== NOT EXECUTED 3000e7f8: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e7fc: e1a00007 mov r0, r7 <== NOT EXECUTED 3000e800: e1a01008 mov r1, r8 <== NOT EXECUTED 3000e804: eb003b5d bl 3001d580 <__udivdi3> <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e808: e59f202c ldr r2, [pc, #44] ; 3000e83c <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED 3000e80c: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Divide to get nanoseconds per iteration
*/
t /= iterations;
3000e810: e1a05000 mov r5, r0 <== NOT EXECUTED 3000e814: e1a06001 mov r6, r1 <== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e818: eb003b58 bl 3001d580 <__udivdi3> <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000e81c: e59f2018 ldr r2, [pc, #24] ; 3000e83c <_Timespec_Divide_by_integer+0x74><== NOT EXECUTED
/*
* Put it back in the timespec result
*/
result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND;
3000e820: e5840000 str r0, [r4] <== NOT EXECUTED
result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
3000e824: e3a03000 mov r3, #0 <== NOT EXECUTED 3000e828: e1a01006 mov r1, r6 <== NOT EXECUTED 3000e82c: e1a00005 mov r0, r5 <== NOT EXECUTED 3000e830: eb003c64 bl 3001d9c8 <__umoddi3> <== NOT EXECUTED 3000e834: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
3000e838: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001dfb0 <_Timespec_From_ticks>:
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3001dfb0: e59f3034 ldr r3, [pc, #52] ; 3001dfec <_Timespec_From_ticks+0x3c><== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001dfb4: e59f2034 ldr r2, [pc, #52] ; 3001dff0 <_Timespec_From_ticks+0x40><== NOT EXECUTED
struct timespec *time
)
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
3001dfb8: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3001dfbc: e0000093 mul r0, r3, r0 <== NOT EXECUTED
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001dfc0: e0823290 umull r3, r2, r0, r2 <== NOT EXECUTED 3001dfc4: e1a02922 lsr r2, r2, #18 <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
3001dfc8: e0623282 rsb r3, r2, r2, lsl #5 <== NOT EXECUTED 3001dfcc: e0633303 rsb r3, r3, r3, lsl #6 <== NOT EXECUTED 3001dfd0: e0823183 add r3, r2, r3, lsl #3 <== NOT EXECUTED 3001dfd4: e0403303 sub r3, r0, r3, lsl #6 <== NOT EXECUTED 3001dfd8: e0630283 rsb r0, r3, r3, lsl #5 <== NOT EXECUTED 3001dfdc: e0833100 add r3, r3, r0, lsl #2 <== NOT EXECUTED 3001dfe0: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED
{
uint32_t usecs;
usecs = ticks * rtems_configuration_get_microseconds_per_tick();
time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND;
3001dfe4: e881000c stm r1, {r2, r3} <== NOT EXECUTED
time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
TOD_NANOSECONDS_PER_MICROSECOND;
}
3001dfe8: e12fff1e bx lr <== NOT EXECUTED
3001dff4 <_Timespec_Is_valid>:
bool _Timespec_Is_valid(
const struct timespec *time
)
{
if ( !time )
3001dff4: e3500000 cmp r0, #0 <== NOT EXECUTED 3001dff8: 012fff1e bxeq lr <== NOT EXECUTED
return false;
if ( time->tv_sec < 0 )
3001dffc: e5903000 ldr r3, [r0] <== NOT EXECUTED 3001e000: e3530000 cmp r3, #0 <== NOT EXECUTED
return false;
3001e004: b3a00000 movlt r0, #0 <== NOT EXECUTED
)
{
if ( !time )
return false;
if ( time->tv_sec < 0 )
3001e008: b12fff1e bxlt lr <== NOT EXECUTED
return false;
if ( time->tv_nsec < 0 )
3001e00c: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3001e010: e3530000 cmp r3, #0 <== NOT EXECUTED 3001e014: ba000004 blt 3001e02c <_Timespec_Is_valid+0x38> <== NOT EXECUTED
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Is_valid(
3001e018: e59f0014 ldr r0, [pc, #20] ; 3001e034 <_Timespec_Is_valid+0x40><== NOT EXECUTED 3001e01c: e1530000 cmp r3, r0 <== NOT EXECUTED 3001e020: 83a00000 movhi r0, #0 <== NOT EXECUTED 3001e024: 93a00001 movls r0, #1 <== NOT EXECUTED 3001e028: e12fff1e bx lr <== NOT EXECUTED
if ( time->tv_sec < 0 )
return false;
if ( time->tv_nsec < 0 )
return false;
3001e02c: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
return false;
return true;
}
3001e030: e12fff1e bx lr <== NOT EXECUTED
3000e878 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000e878: e5902000 ldr r2, [r0] 3000e87c: e5913000 ldr r3, [r1] 3000e880: e1520003 cmp r2, r3
return true;
3000e884: b3a00001 movlt r0, #1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
3000e888: b12fff1e bxlt lr
return true;
if ( lhs->tv_sec > rhs->tv_sec )
3000e88c: ca000005 bgt 3000e8a8 <_Timespec_Less_than+0x30>
#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>
bool _Timespec_Less_than(
3000e890: e5900004 ldr r0, [r0, #4] 3000e894: e5913004 ldr r3, [r1, #4] 3000e898: e1500003 cmp r0, r3 3000e89c: a3a00000 movge r0, #0 3000e8a0: b3a00001 movlt r0, #1 3000e8a4: e12fff1e bx lr
{
if ( lhs->tv_sec < rhs->tv_sec )
return true;
if ( lhs->tv_sec > rhs->tv_sec )
return false;
3000e8a8: e3a00000 mov r0, #0 <== NOT EXECUTED
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
return true;
return false;
}
3000e8ac: e12fff1e bx lr <== NOT EXECUTED
3000cb5c <_Timespec_Subtract>:
const struct timespec *end,
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
3000cb5c: e591c004 ldr ip, [r1, #4] 3000cb60: e5903004 ldr r3, [r0, #4]
void _Timespec_Subtract(
const struct timespec *start,
const struct timespec *end,
struct timespec *result
)
{
3000cb64: e92d0030 push {r4, r5}
if (end->tv_nsec < start->tv_nsec) {
3000cb68: e15c0003 cmp ip, r3
3000cb6c: ba000006 blt 3000cb8c <_Timespec_Subtract+0x30>
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000cb70: e5914000 ldr r4, [r1] 3000cb74: e5901000 ldr r1, [r0]
result->tv_nsec = end->tv_nsec - start->tv_nsec;
3000cb78: e063300c rsb r3, r3, ip
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
} else {
result->tv_sec = end->tv_sec - start->tv_sec;
3000cb7c: e0611004 rsb r1, r1, r4
3000cb80: e882000a stm r2, {r1, r3}
result->tv_nsec = end->tv_nsec - start->tv_nsec;
}
}
3000cb84: e8bd0030 pop {r4, r5}
3000cb88: e12fff1e bx lr
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cb8c: e5915000 ldr r5, [r1] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cb90: e59f1018 ldr r1, [pc, #24] ; 3000cbb0 <_Timespec_Subtract+0x54><== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cb94: e5904000 ldr r4, [r0] <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cb98: e08c1001 add r1, ip, r1 <== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cb9c: e2450001 sub r0, r5, #1 <== NOT EXECUTED 3000cba0: e0640000 rsb r0, r4, r0 <== NOT EXECUTED
result->tv_nsec =
(TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
3000cba4: e0633001 rsb r3, r3, r1 <== NOT EXECUTED
struct timespec *result
)
{
if (end->tv_nsec < start->tv_nsec) {
result->tv_sec = end->tv_sec - start->tv_sec - 1;
3000cba8: e8820009 stm r2, {r0, r3} <== NOT EXECUTED
3000cbac: eafffff4 b 3000cb84 <_Timespec_Subtract+0x28> <== NOT EXECUTED
3001e038 <_Timespec_To_ticks>:
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
3001e038: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
3001e03c: e5904000 ldr r4, [r0] <== NOT EXECUTED
*/
uint32_t _Timespec_To_ticks(
const struct timespec *time
)
{
3001e040: e1a05000 mov r5, r0 <== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
3001e044: e3540000 cmp r4, #0 <== NOT EXECUTED
3001e048: 1a000002 bne 3001e058 <_Timespec_To_ticks+0x20> <== NOT EXECUTED
3001e04c: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
3001e050: e3500000 cmp r0, #0 <== NOT EXECUTED
3001e054: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
3001e058: eb000086 bl 3001e278 <TOD_TICKS_PER_SECOND_method> <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
3001e05c: e59f3024 ldr r3, [pc, #36] ; 3001e088 <_Timespec_To_ticks+0x50><== NOT EXECUTED
uint32_t ticks;
if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
return 0;
ticks = time->tv_sec * TOD_TICKS_PER_SECOND;
3001e060: e0040490 mul r4, r0, r4 <== NOT EXECUTED
ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick();
3001e064: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3001e068: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3001e06c: e0632283 rsb r2, r3, r3, lsl #5 <== NOT EXECUTED 3001e070: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 3001e074: e1a01183 lsl r1, r3, #3 <== NOT EXECUTED 3001e078: ebfff648 bl 3001b9a0 <__aeabi_uidiv> <== NOT EXECUTED
if (ticks)
3001e07c: e0940000 adds r0, r4, r0 <== NOT EXECUTED
return ticks;
return 1;
3001e080: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
3001e084: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000cce0 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cce0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000cce4: e59f5040 ldr r5, [pc, #64] ; 3000cd2c <_User_extensions_Fatal+0x4c>
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000cce8: e1a08000 mov r8, r0
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
}
}
3000ccec: e5954008 ldr r4, [r5, #8]
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ccf0: e1a07002 mov r7, r2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000ccf4: e1540005 cmp r4, r5
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
3000ccf8: e20160ff and r6, r1, #255 ; 0xff
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000ccfc: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
3000cd00: e5943030 ldr r3, [r4, #48] ; 0x30
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000cd04: e1a00008 mov r0, r8
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
3000cd08: e3530000 cmp r3, #0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
3000cd0c: e1a01006 mov r1, r6 3000cd10: e1a02007 mov r2, r7 3000cd14: 11a0e00f movne lr, pc 3000cd18: 112fff13 bxne r3
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
3000cd1c: e5944004 ldr r4, [r4, #4]
)
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _Chain_Last( &_User_extensions_List );
3000cd20: e1540005 cmp r4, r5
3000cd24: 1afffff5 bne 3000cd00 <_User_extensions_Fatal+0x20>
3000cd28: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000e4d0 <_User_extensions_Remove_set>:
#include <rtems/score/userext.h>
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
3000e4d0: e92d4010 push {r4, lr}
3000e4d4: e1a04000 mov r4, r0
_Chain_Extract( &the_extension->Node );
3000e4d8: ebfff5f1 bl 3000bca4 <_Chain_Extract>
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
3000e4dc: e5943024 ldr r3, [r4, #36] ; 0x24
3000e4e0: e3530000 cmp r3, #0
3000e4e4: 08bd8010 popeq {r4, pc}
_Chain_Extract( &the_extension->Switch.Node );
3000e4e8: e2840008 add r0, r4, #8 <== NOT EXECUTED
}
3000e4ec: e8bd4010 pop {r4, lr} <== NOT EXECUTED
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
_Chain_Extract( &the_extension->Switch.Node );
3000e4f0: eafff5eb b 3000bca4 <_Chain_Extract> <== NOT EXECUTED
3000cd30 <_User_extensions_Thread_create>:
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
3000cd30: e92d40f0 push {r4, r5, r6, r7, lr}
return false;
}
}
return true;
}
3000cd34: e59f5050 ldr r5, [pc, #80] ; 3000cd8c <_User_extensions_Thread_create+0x5c>
#include <rtems/score/userext.h>
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
3000cd38: e1a06000 mov r6, r0
return false;
}
}
return true;
}
3000cd3c: e4954004 ldr r4, [r5], #4
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
3000cd40: e1540005 cmp r4, r5
3000cd44: 0a00000e beq 3000cd84 <_User_extensions_Thread_create+0x54>
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
3000cd48: e59f7040 ldr r7, [pc, #64] ; 3000cd90 <_User_extensions_Thread_create+0x60>
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
3000cd4c: e5943014 ldr r3, [r4, #20]
status = (*the_extension->Callouts.thread_create)(
3000cd50: e1a01006 mov r1, r6
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_create != NULL ) {
3000cd54: e3530000 cmp r3, #0
3000cd58: 0a000004 beq 3000cd70 <_User_extensions_Thread_create+0x40>
status = (*the_extension->Callouts.thread_create)(
3000cd5c: e5970004 ldr r0, [r7, #4] 3000cd60: e1a0e00f mov lr, pc 3000cd64: e12fff13 bx r3
_Thread_Executing,
the_thread
);
if ( !status )
3000cd68: e3500000 cmp r0, #0
3000cd6c: 08bd80f0 popeq {r4, r5, r6, r7, pc}
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
3000cd70: e5944000 ldr r4, [r4]
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _Chain_First( &_User_extensions_List );
3000cd74: e1540005 cmp r4, r5
3000cd78: 1afffff3 bne 3000cd4c <_User_extensions_Thread_create+0x1c>
if ( !status )
return false;
}
}
return true;
3000cd7c: e3a00001 mov r0, #1
3000cd80: e8bd80f0 pop {r4, r5, r6, r7, pc}
3000cd84: e3a00001 mov r0, #1 <== NOT EXECUTED
}
3000cd88: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000eb94 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
3000eb94: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000eb98: e1a04000 mov r4, r0
3000eb9c: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000eba0: e10f0000 mrs r0, CPSR 3000eba4: e3803080 orr r3, r0, #128 ; 0x80 3000eba8: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
3000ebac: e1a07004 mov r7, r4 3000ebb0: e4973004 ldr r3, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
3000ebb4: e1530007 cmp r3, r7
3000ebb8: 0a00001a beq 3000ec28 <_Watchdog_Adjust+0x94>
switch ( direction ) {
3000ebbc: e3510000 cmp r1, #0 <== NOT EXECUTED 3000ebc0: 1a00001a bne 3000ec30 <_Watchdog_Adjust+0x9c> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000ebc4: e3520000 cmp r2, #0 <== NOT EXECUTED 3000ebc8: 0a000016 beq 3000ec28 <_Watchdog_Adjust+0x94> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ebcc: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000ebd0: e1520006 cmp r2, r6 <== NOT EXECUTED 3000ebd4: 21a01000 movcs r1, r0 <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ebd8: 23a08001 movcs r8, #1 <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ebdc: 2a000005 bcs 3000ebf8 <_Watchdog_Adjust+0x64> <== NOT EXECUTED 3000ebe0: ea000019 b 3000ec4c <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
3000ebe4: e0555006 subs r5, r5, r6 <== NOT EXECUTED 3000ebe8: 0a00000e beq 3000ec28 <_Watchdog_Adjust+0x94> <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
3000ebec: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED 3000ebf0: e1560005 cmp r6, r5 <== NOT EXECUTED 3000ebf4: 8a000014 bhi 3000ec4c <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
3000ebf8: e5838010 str r8, [r3, #16] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ebfc: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED
_ISR_Enable( level );
_Watchdog_Tickle( header );
3000ec00: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ec04: eb0000ad bl 3000eec0 <_Watchdog_Tickle> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ec08: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000ec0c: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000ec10: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
}
}
_ISR_Enable( level );
}
3000ec14: e5942000 ldr r2, [r4] <== NOT EXECUTED 3000ec18: e1a01000 mov r1, r0 <== NOT EXECUTED
_Watchdog_Tickle( header );
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000ec1c: e1570002 cmp r7, r2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000ec20: e1a03002 mov r3, r2 <== NOT EXECUTED 3000ec24: 1affffee bne 3000ebe4 <_Watchdog_Adjust+0x50> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ec28: e129f000 msr CPSR_fc, r0
}
}
_ISR_Enable( level );
}
3000ec2c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
3000ec30: e3510001 cmp r1, #1 <== NOT EXECUTED 3000ec34: 1afffffb bne 3000ec28 <_Watchdog_Adjust+0x94> <== NOT EXECUTED
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
3000ec38: e5932010 ldr r2, [r3, #16] <== NOT EXECUTED 3000ec3c: e0825005 add r5, r2, r5 <== NOT EXECUTED 3000ec40: e5835010 str r5, [r3, #16] <== NOT EXECUTED 3000ec44: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
}
}
_ISR_Enable( level );
}
3000ec48: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
3000ec4c: e0655006 rsb r5, r5, r6 <== NOT EXECUTED 3000ec50: e5835010 str r5, [r3, #16] <== NOT EXECUTED
break;
3000ec54: eafffff3 b 3000ec28 <_Watchdog_Adjust+0x94> <== NOT EXECUTED
3001ebd8 <_Watchdog_Adjust_to_chain>:
{
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001ebd8: e3510000 cmp r1, #0 <== NOT EXECUTED
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
3001ebdc: e92d05f0 push {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
Watchdog_Interval units = units_arg;
ISR_Level level;
Watchdog_Control *first;
if ( units <= 0 ) {
3001ebe0: 0a000022 beq 3001ec70 <_Watchdog_Adjust_to_chain+0x98> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001ebe4: e10f7000 mrs r7, CPSR <== NOT EXECUTED 3001ebe8: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 3001ebec: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
return;
}
_ISR_Disable( level );
3001ebf0: e1a06000 mov r6, r0 <== NOT EXECUTED 3001ebf4: e4963004 ldr r3, [r6], #4 <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
first->delta_interval = 0;
3001ebf8: e3a0a000 mov sl, #0 <== NOT EXECUTED 3001ebfc: e2828004 add r8, r2, #4 <== NOT EXECUTED
while ( 1 ) {
if ( units <= 0 ) {
break;
}
if ( _Chain_Is_empty( header ) ) {
3001ec00: e1530006 cmp r3, r6 <== NOT EXECUTED 3001ec04: 0a000018 beq 3001ec6c <_Watchdog_Adjust_to_chain+0x94> <== NOT EXECUTED
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
3001ec08: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001ec0c: e15c0001 cmp ip, r1 <== NOT EXECUTED 3001ec10: 8a000018 bhi 3001ec78 <_Watchdog_Adjust_to_chain+0xa0> <== NOT EXECUTED
/*
* The first set happens in less than units, so take all of them
* off the chain and adjust units to reflect this.
*/
units -= first->delta_interval;
3001ec14: e06c1001 rsb r1, ip, r1 <== NOT EXECUTED
first->delta_interval = 0;
3001ec18: e583a010 str sl, [r3, #16] <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
3001ec1c: e5935000 ldr r5, [r3] <== NOT EXECUTED
previous = the_node->previous;
3001ec20: e5934004 ldr r4, [r3, #4] <== NOT EXECUTED
next->previous = previous;
3001ec24: e5854004 str r4, [r5, #4] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
3001ec28: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
3001ec2c: e5845000 str r5, [r4] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
3001ec30: e5838000 str r8, [r3] <== NOT EXECUTED
tail->previous = the_node; old_last->next = the_node;
3001ec34: e58c3000 str r3, [ip] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
3001ec38: e5823008 str r3, [r2, #8] <== NOT EXECUTED
old_last->next = the_node; the_node->previous = old_last;
3001ec3c: e583c004 str ip, [r3, #4] <== NOT EXECUTED
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3001ec40: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3001ec44: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED 3001ec48: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001ec4c: e5903000 ldr r3, [r0] <== NOT EXECUTED
_Chain_Extract_unprotected( &first->Node );
_Chain_Append_unprotected( to_fire, &first->Node );
_ISR_Flash( level );
if ( _Chain_Is_empty( header ) )
3001ec50: e1560003 cmp r6, r3 <== NOT EXECUTED 3001ec54: 0a000002 beq 3001ec64 <_Watchdog_Adjust_to_chain+0x8c> <== NOT EXECUTED
break;
first = _Watchdog_First( header );
if ( first->delta_interval != 0 )
3001ec58: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED 3001ec5c: e35c0000 cmp ip, #0 <== NOT EXECUTED 3001ec60: 0affffed beq 3001ec1c <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED
}
_ISR_Disable( level );
while ( 1 ) {
if ( units <= 0 ) {
3001ec64: e3510000 cmp r1, #0 <== NOT EXECUTED 3001ec68: 1affffe4 bne 3001ec00 <_Watchdog_Adjust_to_chain+0x28> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001ec6c: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
break;
}
}
_ISR_Enable( level );
}
3001ec70: e8bd05f0 pop {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
3001ec74: e12fff1e bx lr <== NOT EXECUTED
/*
* If it is longer than "units" until the first element on the chain
* fires, then bump it and quit.
*/
if ( units < first->delta_interval ) {
first->delta_interval -= units;
3001ec78: e061100c rsb r1, r1, ip <== NOT EXECUTED 3001ec7c: e5831010 str r1, [r3, #16] <== NOT EXECUTED
break;
3001ec80: eafffff9 b 3001ec6c <_Watchdog_Adjust_to_chain+0x94> <== NOT EXECUTED
3000ce6c <_Watchdog_Insert>:
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000ce6c: e59f3140 ldr r3, [pc, #320] ; 3000cfb4 <_Watchdog_Insert+0x148>
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
3000ce70: e92d01f0 push {r4, r5, r6, r7, r8}
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
3000ce74: e5933000 ldr r3, [r3]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ce78: e10f6000 mrs r6, CPSR 3000ce7c: e3862080 orr r2, r6, #128 ; 0x80 3000ce80: e129f002 msr CPSR_fc, r2
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
3000ce84: e5912008 ldr r2, [r1, #8] 3000ce88: e3520000 cmp r2, #0
3000ce8c: 1a000041 bne 3000cf98 <_Watchdog_Insert+0x12c>
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
3000ce90: e59f8120 ldr r8, [pc, #288] ; 3000cfb8 <_Watchdog_Insert+0x14c>
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000ce94: e3a0c001 mov ip, #1
_Watchdog_Sync_count++;
3000ce98: e5982000 ldr r2, [r8] 3000ce9c: e59f7118 ldr r7, [pc, #280] ; 3000cfbc <_Watchdog_Insert+0x150> 3000cea0: e2822001 add r2, r2, #1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
3000cea4: e581c008 str ip, [r1, #8]
_Watchdog_Sync_count++;
3000cea8: e5882000 str r2, [r8]
restart:
delta_interval = the_watchdog->initial;
3000ceac: e591200c ldr r2, [r1, #12]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000ceb0: e590c000 ldr ip, [r0]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000ceb4: e3520000 cmp r2, #0
3000ceb8: 0a000023 beq 3000cf4c <_Watchdog_Insert+0xe0>
3000cebc: e59c4000 ldr r4, [ip] 3000cec0: e3540000 cmp r4, #0
3000cec4: 0a000020 beq 3000cf4c <_Watchdog_Insert+0xe0>
break;
if ( delta_interval < after->delta_interval ) {
3000cec8: e59c4010 ldr r4, [ip, #16] 3000cecc: e1520004 cmp r2, r4
3000ced0: 3a000032 bcc 3000cfa0 <_Watchdog_Insert+0x134>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000ced4: e10f5000 mrs r5, CPSR 3000ced8: e129f006 msr CPSR_fc, r6 3000cedc: e129f005 msr CPSR_fc, r5
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000cee0: e5915008 ldr r5, [r1, #8] 3000cee4: e3550001 cmp r5, #1
3000cee8: 1a000023 bne 3000cf7c <_Watchdog_Insert+0x110>
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000ceec: e5975000 ldr r5, [r7] 3000cef0: e1530005 cmp r3, r5
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000cef4: 20642002 rsbcs r2, r4, r2
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000cef8: 2a000010 bcs 3000cf40 <_Watchdog_Insert+0xd4>
3000cefc: ea00002a b 3000cfac <_Watchdog_Insert+0x140> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000cf00: e59c4000 ldr r4, [ip] <== NOT EXECUTED 3000cf04: e3540000 cmp r4, #0 <== NOT EXECUTED 3000cf08: 0a00000f beq 3000cf4c <_Watchdog_Insert+0xe0> <== NOT EXECUTED
break;
if ( delta_interval < after->delta_interval ) {
3000cf0c: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 3000cf10: e1540002 cmp r4, r2 <== NOT EXECUTED 3000cf14: 8a000021 bhi 3000cfa0 <_Watchdog_Insert+0x134> <== NOT EXECUTED 3000cf18: e10f5000 mrs r5, CPSR <== NOT EXECUTED 3000cf1c: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000cf20: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
delta_interval -= after->delta_interval;
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000cf24: e5915008 ldr r5, [r1, #8] <== NOT EXECUTED
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
break;
}
delta_interval -= after->delta_interval;
3000cf28: e0642002 rsb r2, r4, r2 <== NOT EXECUTED
_ISR_Flash( level );
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
3000cf2c: e3550001 cmp r5, #1 <== NOT EXECUTED 3000cf30: 1a000011 bne 3000cf7c <_Watchdog_Insert+0x110> <== NOT EXECUTED
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
3000cf34: e5974000 ldr r4, [r7] <== NOT EXECUTED 3000cf38: e1530004 cmp r3, r4 <== NOT EXECUTED 3000cf3c: 3a00001a bcc 3000cfac <_Watchdog_Insert+0x140> <== NOT EXECUTED
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000cf40: e3520000 cmp r2, #0
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
_Watchdog_Sync_count--;
_ISR_Enable( level );
}
3000cf44: e59cc000 ldr ip, [ip]
for ( after = _Watchdog_First( header ) ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
3000cf48: 1affffec bne 3000cf00 <_Watchdog_Insert+0x94>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
3000cf4c: e59c0004 ldr r0, [ip, #4]
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000cf50: e59f4068 ldr r4, [pc, #104] ; 3000cfc0 <_Watchdog_Insert+0x154>
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
3000cf54: e590c000 ldr ip, [r0] 3000cf58: e5944000 ldr r4, [r4]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
3000cf5c: e3a05002 mov r5, #2 3000cf60: e5815008 str r5, [r1, #8]
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
3000cf64: e5812010 str r2, [r1, #16]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
3000cf68: e5810004 str r0, [r1, #4]
before_node = after_node->next; after_node->next = the_node;
3000cf6c: e5801000 str r1, [r0]
the_node->next = before_node; before_node->previous = the_node;
3000cf70: e58c1004 str r1, [ip, #4]
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
3000cf74: e581c000 str ip, [r1]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
3000cf78: e5814014 str r4, [r1, #20]
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
3000cf7c: e5873000 str r3, [r7]
_Watchdog_Sync_count--;
3000cf80: e5983000 ldr r3, [r8] 3000cf84: e2433001 sub r3, r3, #1 3000cf88: e5883000 str r3, [r8]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000cf8c: e129f006 msr CPSR_fc, r6
_ISR_Enable( level ); }
3000cf90: e8bd01f0 pop {r4, r5, r6, r7, r8}
3000cf94: e12fff1e bx lr
3000cf98: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED 3000cf9c: eafffffb b 3000cf90 <_Watchdog_Insert+0x124> <== NOT EXECUTED
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
3000cfa0: e0624004 rsb r4, r2, r4 <== NOT EXECUTED 3000cfa4: e58c4010 str r4, [ip, #16] <== NOT EXECUTED
break;
3000cfa8: eaffffe7 b 3000cf4c <_Watchdog_Insert+0xe0> <== NOT EXECUTED
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
3000cfac: e5873000 str r3, [r7] <== NOT EXECUTED
goto restart;
3000cfb0: eaffffbd b 3000ceac <_Watchdog_Insert+0x40> <== NOT EXECUTED
3000e684 <_Watchdog_Report>:
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e684: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
printk(
3000e688: e250c000 subs ip, r0, #0 <== NOT EXECUTED 3000e68c: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
void _Watchdog_Report(
const char *name,
Watchdog_Control *watch
)
{
3000e690: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
printk(
3000e694: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
3000e698: e88d0003 stm sp, {r0, r1} <== NOT EXECUTED
3000e69c: e591e01c ldr lr, [r1, #28] <== NOT EXECUTED
3000e6a0: 059fc02c ldreq ip, [pc, #44] ; 3000e6d4 <_Watchdog_Report+0x50><== NOT EXECUTED
3000e6a4: e58de008 str lr, [sp, #8] <== NOT EXECUTED
3000e6a8: e591e020 ldr lr, [r1, #32] <== NOT EXECUTED
3000e6ac: 01a0200c moveq r2, ip <== NOT EXECUTED
3000e6b0: e58de00c str lr, [sp, #12] <== NOT EXECUTED
3000e6b4: e5911024 ldr r1, [r1, #36] ; 0x24 <== NOT EXECUTED
3000e6b8: 159f2018 ldrne r2, [pc, #24] ; 3000e6d8 <_Watchdog_Report+0x54><== NOT EXECUTED
3000e6bc: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
3000e6c0: e59f0014 ldr r0, [pc, #20] ; 3000e6dc <_Watchdog_Report+0x58><== NOT EXECUTED
3000e6c4: e1a0100c mov r1, ip <== NOT EXECUTED
3000e6c8: ebffe66a bl 30008078 <printk> <== NOT EXECUTED
watch,
watch->routine,
watch->id,
watch->user_data
);
}
3000e6cc: e28dd014 add sp, sp, #20 <== NOT EXECUTED
3000e6d0: e8bd8000 pop {pc} <== NOT EXECUTED
3000e60c <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
3000e60c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3000e610: e1a05000 mov r5, r0 <== NOT EXECUTED
3000e614: e1a04001 mov r4, r1 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000e618: e10f6000 mrs r6, CPSR <== NOT EXECUTED 3000e61c: e3863080 orr r3, r6, #128 ; 0x80 <== NOT EXECUTED 3000e620: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
3000e624: e59f004c ldr r0, [pc, #76] ; 3000e678 <_Watchdog_Report_chain+0x6c><== NOT EXECUTED 3000e628: e1a02004 mov r2, r4 <== NOT EXECUTED 3000e62c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e630: ebffe690 bl 30008078 <printk> <== NOT EXECUTED
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000e634: e4947004 ldr r7, [r4], #4 <== NOT EXECUTED
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
3000e638: e1570004 cmp r7, r4 <== NOT EXECUTED 3000e63c: 0a00000a beq 3000e66c <_Watchdog_Report_chain+0x60> <== NOT EXECUTED
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
3000e640: e1a01007 mov r1, r7 <== NOT EXECUTED 3000e644: e3a00000 mov r0, #0 <== NOT EXECUTED 3000e648: eb00000d bl 3000e684 <_Watchdog_Report> <== NOT EXECUTED
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
3000e64c: e5977000 ldr r7, [r7] <== NOT EXECUTED
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
3000e650: e1570004 cmp r7, r4 <== NOT EXECUTED 3000e654: 1afffff9 bne 3000e640 <_Watchdog_Report_chain+0x34> <== NOT EXECUTED
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
3000e658: e59f001c ldr r0, [pc, #28] ; 3000e67c <_Watchdog_Report_chain+0x70><== NOT EXECUTED 3000e65c: e1a01005 mov r1, r5 <== NOT EXECUTED 3000e660: ebffe684 bl 30008078 <printk> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000e664: e129f006 msr CPSR_fc, r6 <== NOT EXECUTED
} else {
printk( "Chain is empty\n" );
}
_ISR_Enable( level );
}
3000e668: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
3000e66c: e59f000c ldr r0, [pc, #12] ; 3000e680 <_Watchdog_Report_chain+0x74><== NOT EXECUTED 3000e670: ebffe680 bl 30008078 <printk> <== NOT EXECUTED 3000e674: eafffffa b 3000e664 <_Watchdog_Report_chain+0x58> <== NOT EXECUTED
3000d0d4 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
3000d0d4: e92d40f0 push {r4, r5, r6, r7, lr}
3000d0d8: e1a06000 mov r6, r0
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000d0dc: e10f7000 mrs r7, CPSR 3000d0e0: e3873080 orr r3, r7, #128 ; 0x80 3000d0e4: e129f003 msr CPSR_fc, r3
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d0e8: e1a05000 mov r5, r0 3000d0ec: e4953004 ldr r3, [r5], #4
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
3000d0f0: e1530005 cmp r3, r5
3000d0f4: 0a000007 beq 3000d118 <_Watchdog_Tickle+0x44>
* to be inserted has already had its delta_interval adjusted to 0, and
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
3000d0f8: e5931010 ldr r1, [r3, #16]
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) _Chain_First( header ) );
3000d0fc: e1a04003 mov r4, r3 3000d100: e3510000 cmp r1, #0
3000d104: 0a000015 beq 3000d160 <_Watchdog_Tickle+0x8c>
the_watchdog->delta_interval--;
3000d108: e2411001 sub r1, r1, #1
if ( the_watchdog->delta_interval != 0 )
3000d10c: e3510000 cmp r1, #0
* so is added to the head of the chain with a delta_interval of 0.
*
* Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc)
*/
if (the_watchdog->delta_interval != 0) {
the_watchdog->delta_interval--;
3000d110: e5831010 str r1, [r3, #16]
if ( the_watchdog->delta_interval != 0 )
3000d114: 0a000011 beq 3000d160 <_Watchdog_Tickle+0x8c>
* See the comment in watchdoginsert.c and watchdogadjust.c
* about why it's safe not to declare header a pointer to
* volatile data - till, 2003/7
*/
_ISR_Disable( level );
3000d118: e1a02007 mov r2, r7
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d11c: e129f002 msr CPSR_fc, r2
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d120: e8bd80f0 pop {r4, r5, r6, r7, pc}
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
3000d124: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED 3000d128: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 3000d12c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000d130: e594f01c ldr pc, [r4, #28] <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000d134: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3000d138: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3000d13c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
}
3000d140: e5963000 ldr r3, [r6] <== NOT EXECUTED 3000d144: e1a07002 mov r7, r2 <== NOT EXECUTED
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
3000d148: e1530005 cmp r3, r5 <== NOT EXECUTED 3000d14c: e1a04003 mov r4, r3 <== NOT EXECUTED 3000d150: 0afffff1 beq 3000d11c <_Watchdog_Tickle+0x48> <== NOT EXECUTED
}
_ISR_Disable( level );
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
3000d154: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 3000d158: e3530000 cmp r3, #0 <== NOT EXECUTED 3000d15c: 1affffee bne 3000d11c <_Watchdog_Tickle+0x48> <== NOT EXECUTED
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
3000d160: e1a00004 mov r0, r4 <== NOT EXECUTED 3000d164: ebffffaf bl 3000d028 <_Watchdog_Remove> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000d168: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
_ISR_Enable( level );
switch( watchdog_state ) {
3000d16c: e3500002 cmp r0, #2 <== NOT EXECUTED 3000d170: 1affffef bne 3000d134 <_Watchdog_Tickle+0x60> <== NOT EXECUTED 3000d174: eaffffea b 3000d124 <_Watchdog_Tickle+0x50> <== NOT EXECUTED
3000d200 <_Workspace_Allocate_or_fatal_error>:
3000d200: e3a02000 mov r2, #0
* _Workspace_Allocate_or_fatal_error
*/
void *_Workspace_Allocate_or_fatal_error(
size_t size
)
{
3000d204: e1a01000 mov r1, r0
3000d208: e52de004 push {lr} ; (str lr, [sp, #-4]!)
3000d20c: e59f0018 ldr r0, [pc, #24] ; 3000d22c <_Workspace_Allocate_or_fatal_error+0x2c>
3000d210: e1a03002 mov r3, r2
3000d214: eb000855 bl 3000f370 <_Heap_Allocate_aligned_with_boundary>
__builtin_return_address( 1 ),
memory
);
#endif
if ( memory == NULL )
3000d218: e3500000 cmp r0, #0
3000d21c: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
_Internal_error_Occurred(
3000d220: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d224: e3a02003 mov r2, #3 <== NOT EXECUTED 3000d228: ebfff6fd bl 3000ae24 <_Internal_error_Occurred> <== NOT EXECUTED
3000d178 <_Workspace_Handler_initialization>:
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000d178: e59f3050 ldr r3, [pc, #80] ; 3000d1d0 <_Workspace_Handler_initialization+0x58>
/*
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
3000d17c: e92d4030 push {r4, r5, lr}
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
3000d180: e5d32028 ldrb r2, [r3, #40] ; 0x28
* _Workspace_Handler_initialization
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
3000d184: e5935000 ldr r5, [r3]
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
3000d188: e3520000 cmp r2, #0
*/
void _Workspace_Handler_initialization(void)
{
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
3000d18c: e5934004 ldr r4, [r3, #4]
if ( Configuration.do_zero_of_workspace )
3000d190: 1a000009 bne 3000d1bc <_Workspace_Handler_initialization+0x44>
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
3000d194: e59f0038 ldr r0, [pc, #56] ; 3000d1d4 <_Workspace_Handler_initialization+0x5c> 3000d198: e1a01005 mov r1, r5 3000d19c: e1a02004 mov r2, r4 3000d1a0: e3a03008 mov r3, #8 3000d1a4: ebfff683 bl 3000abb8 <_Heap_Initialize>
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
3000d1a8: e3500000 cmp r0, #0
3000d1ac: 18bd8030 popne {r4, r5, pc}
_Internal_error_Occurred(
3000d1b0: e3a01001 mov r1, #1 <== NOT EXECUTED 3000d1b4: e3a02002 mov r2, #2 <== NOT EXECUTED 3000d1b8: ebfff719 bl 3000ae24 <_Internal_error_Occurred> <== NOT EXECUTED
uintptr_t memory_available = 0;
void *starting_address = Configuration.work_space_start;
uintptr_t size = Configuration.work_space_size;
if ( Configuration.do_zero_of_workspace )
memset( starting_address, 0, size );
3000d1bc: e1a00005 mov r0, r5 3000d1c0: e3a01000 mov r1, #0 3000d1c4: e1a02004 mov r2, r4 3000d1c8: eb00123b bl 30011abc <memset> 3000d1cc: eafffff0 b 3000d194 <_Workspace_Handler_initialization+0x1c>
300097d8 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097d8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097dc: e252e000 subs lr, r2, #0 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097e0: e1a0c001 mov ip, r1 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097e4: 059f102c ldreq r1, [pc, #44] ; 30009818 <__assert_func+0x40><== NOT EXECUTED 300097e8: 159f102c ldrne r1, [pc, #44] ; 3000981c <__assert_func+0x44><== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097ec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097f0: 01a0e001 moveq lr, r1 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
300097f4: e1a02000 mov r2, r0 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
300097f8: e58d1000 str r1, [sp] <== NOT EXECUTED 300097fc: e59f001c ldr r0, [pc, #28] ; 30009820 <__assert_func+0x48> <== NOT EXECUTED 30009800: e1a01003 mov r1, r3 <== NOT EXECUTED 30009804: e1a0300c mov r3, ip <== NOT EXECUTED 30009808: e58de004 str lr, [sp, #4] <== NOT EXECUTED 3000980c: eb000451 bl 3000a958 <printk> <== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
30009810: e3a00000 mov r0, #0 <== NOT EXECUTED 30009814: eb00113d bl 3000dd10 <rtems_fatal_error_occurred> <== NOT EXECUTED
30014670 <__env_lock>:
30014670: e12fff1e bx lr <== NOT EXECUTED
30014674 <__env_unlock>:
30014674: e12fff1e bx lr <== NOT EXECUTED
30006ba0 <__getpid>:
#include <unistd.h>
pid_t __getpid(void)
{
return getpid();
30006ba0: eaffffff b 30006ba4 <getpid> <== NOT EXECUTED
30025ab4 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
30025ab4: e3a00000 mov r0, #0 <== NOT EXECUTED 30025ab8: e12fff1e bx lr <== NOT EXECUTED
30007e98 <_chown_helper>:
const char *path,
uid_t owner,
gid_t group,
int follow_link
)
{
30007e98: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30007e9c: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
30007ea0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007ea4: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
30007ea8: e1a08003 mov r8, r3 <== NOT EXECUTED
30007eac: e1a05822 lsr r5, r2, #16 <== NOT EXECUTED
30007eb0: e1a07000 mov r7, r0 <== NOT EXECUTED
30007eb4: e1a06821 lsr r6, r1, #16 <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
30007eb8: eb003311 bl 30014b04 <strlen> <== NOT EXECUTED 30007ebc: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007ec0: e1a01000 mov r1, r0 <== NOT EXECUTED 30007ec4: e3a02000 mov r2, #0 <== NOT EXECUTED 30007ec8: e1a00007 mov r0, r7 <== NOT EXECUTED 30007ecc: e1a03004 mov r3, r4 <== NOT EXECUTED 30007ed0: e58d8000 str r8, [sp] <== NOT EXECUTED 30007ed4: eb000030 bl 30007f9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30007ed8: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007edc: 13e05000 mvnne r5, #0 <== NOT EXECUTED
)
{
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, follow_link ) )
30007ee0: 1a000008 bne 30007f08 <_chown_helper+0x70> <== NOT EXECUTED
return -1;
result = (*loc.ops->chown_h)( &loc, owner, group );
30007ee4: e1a02005 mov r2, r5 <== NOT EXECUTED 30007ee8: e1a00004 mov r0, r4 <== NOT EXECUTED 30007eec: e1a01006 mov r1, r6 <== NOT EXECUTED 30007ef0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30007ef4: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ef8: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30007efc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007f00: e1a00004 mov r0, r4 <== NOT EXECUTED 30007f04: eb00005e bl 30008084 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007f08: e1a00005 mov r0, r5 <== NOT EXECUTED
30007f0c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007f10: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007010 <_fcntl_r>:
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
30007010: e1a00001 mov r0, r1 <== NOT EXECUTED 30007014: e1a01002 mov r1, r2 <== NOT EXECUTED 30007018: e1a02003 mov r2, r3 <== NOT EXECUTED 3000701c: eaffff81 b 30006e28 <fcntl> <== NOT EXECUTED
30025a94 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
30025a94: e3a00001 mov r0, #1 <== NOT EXECUTED 30025a98: e12fff1e bx lr <== NOT EXECUTED
300065b0 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300065b0: eaffffe1 b 3000653c <gettimeofday> <== NOT EXECUTED
300065a4 <_gettimeofday_r>:
struct _reent *ignored_reentrancy_stuff __attribute__((unused)),
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
300065a4: e1a00001 mov r0, r1 <== NOT EXECUTED 300065a8: e1a01002 mov r1, r2 <== NOT EXECUTED 300065ac: eaffffe2 b 3000653c <gettimeofday> <== NOT EXECUTED
30025aac <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
30025aac: e3a00000 mov r0, #0 <== NOT EXECUTED 30025ab0: e12fff1e bx lr <== NOT EXECUTED
30009c7c <_link_r>:
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
30009c7c: e1a00001 mov r0, r1 <== NOT EXECUTED 30009c80: e1a01002 mov r1, r2 <== NOT EXECUTED 30009c84: eaffffbe b 30009b84 <link> <== NOT EXECUTED
30016904 <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
30016904: e1a00001 mov r0, r1 <== NOT EXECUTED 30016908: e1a01002 mov r1, r2 <== NOT EXECUTED 3001690c: e1a02003 mov r2, r3 <== NOT EXECUTED 30016910: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30016914: eaffffb7 b 300167f8 <lseek> <== NOT EXECUTED
30008734 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
30008734: e1a00001 mov r0, r1 <== NOT EXECUTED 30008738: e1a01002 mov r1, r2 <== NOT EXECUTED 3000873c: eaffffd9 b 300086a8 <lstat> <== NOT EXECUTED
30016a58 <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
30016a58: e1a00001 mov r0, r1 <== NOT EXECUTED 30016a5c: e1a01002 mov r1, r2 <== NOT EXECUTED 30016a60: e1a02003 mov r2, r3 <== NOT EXECUTED 30016a64: eaffffce b 300169a4 <read> <== NOT EXECUTED
30016a68 <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
30016a68: e1a00001 mov r0, r1 <== NOT EXECUTED 30016a6c: e1a01002 mov r1, r2 <== NOT EXECUTED 30016a70: ea000011 b 30016abc <realloc> <== NOT EXECUTED
3000ab1c <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000ab1c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
3000ab20: e1a00001 mov r0, r1 <== NOT EXECUTED
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
3000ab24: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED 3000ab28: e1a05001 mov r5, r1 <== NOT EXECUTED 3000ab2c: e1a06002 mov r6, r2 <== NOT EXECUTED
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
3000ab30: ebfffa29 bl 300093dc <rtems_filesystem_dirname> <== NOT EXECUTED
if ( old_parent_pathlen == 0 )
3000ab34: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3000ab38: 1a000059 bne 3000aca4 <_rename_r+0x188> <== NOT EXECUTED
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
3000ab3c: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000ab40: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ab44: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000ab48: e1a02004 mov r2, r4 <== NOT EXECUTED 3000ab4c: eb0000e8 bl 3000aef4 <rtems_filesystem_get_start_loc> <== NOT EXECUTED
rtems_filesystem_location_info_t old_parent_loc; rtems_filesystem_location_info_t new_parent_loc; int i; int result; const char *name; bool free_old_parentloc = false;
3000ab50: e1a08007 mov r8, r7 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000ab54: e28dc02c add ip, sp, #44 ; 0x2c <== NOT EXECUTED
3000ab58: e1a0e004 mov lr, r4 <== NOT EXECUTED
3000ab5c: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ab60: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000ab64: e59e3000 ldr r3, [lr] <== NOT EXECUTED
name = old + old_parent_pathlen;
3000ab68: e0855007 add r5, r5, r7 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
3000ab6c: e58c3000 str r3, [ip] <== NOT EXECUTED
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000ab70: e1a00005 mov r0, r5 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
3000ab74: e58d5040 str r5, [sp, #64] ; 0x40 <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000ab78: eb0035ca bl 300182a8 <strlen> <== NOT EXECUTED 3000ab7c: e1a01000 mov r1, r0 <== NOT EXECUTED 3000ab80: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ab84: ebfffa23 bl 30009418 <rtems_filesystem_prefix_separators> <== NOT EXECUTED 3000ab88: e0855000 add r5, r5, r0 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000ab8c: e1a00005 mov r0, r5 <== NOT EXECUTED
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000ab90: e58d5040 str r5, [sp, #64] ; 0x40 <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000ab94: eb0035c3 bl 300182a8 <strlen> <== NOT EXECUTED 3000ab98: e28d702c add r7, sp, #44 ; 0x2c <== NOT EXECUTED 3000ab9c: e1a01000 mov r1, r0 <== NOT EXECUTED 3000aba0: e3a02000 mov r2, #0 <== NOT EXECUTED 3000aba4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000aba8: e1a03007 mov r3, r7 <== NOT EXECUTED 3000abac: e58d2000 str r2, [sp] <== NOT EXECUTED 3000abb0: ebfff9d7 bl 30009314 <rtems_filesystem_evaluate_relative_path><== NOT EXECUTED
0, &old_loc, false );
if ( result != 0 ) {
3000abb4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000abb8: 1a000031 bne 3000ac84 <_rename_r+0x168> <== NOT EXECUTED
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
3000abbc: e28d5004 add r5, sp, #4 <== NOT EXECUTED 3000abc0: e1a00006 mov r0, r6 <== NOT EXECUTED 3000abc4: e1a02005 mov r2, r5 <== NOT EXECUTED 3000abc8: e28d1044 add r1, sp, #68 ; 0x44 <== NOT EXECUTED 3000abcc: eb0000c8 bl 3000aef4 <rtems_filesystem_get_start_loc> <== NOT EXECUTED
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
3000abd0: e59d0044 ldr r0, [sp, #68] ; 0x44 <== NOT EXECUTED 3000abd4: e1a01005 mov r1, r5 <== NOT EXECUTED 3000abd8: e0860000 add r0, r6, r0 <== NOT EXECUTED 3000abdc: e28d2040 add r2, sp, #64 ; 0x40 <== NOT EXECUTED 3000abe0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000abe4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000abe8: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( result != 0 ) {
3000abec: e3500000 cmp r0, #0 <== NOT EXECUTED 3000abf0: 1a000037 bne 3000acd4 <_rename_r+0x1b8> <== NOT EXECUTED
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
3000abf4: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3000abf8: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3000abfc: e1520003 cmp r2, r3 <== NOT EXECUTED 3000ac00: 1a000013 bne 3000ac54 <_rename_r+0x138> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
3000ac04: e1a01007 mov r1, r7 <== NOT EXECUTED 3000ac08: e1a02005 mov r2, r5 <== NOT EXECUTED 3000ac0c: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3000ac10: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED 3000ac14: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac18: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ac1c: e59cf040 ldr pc, [ip, #64] ; 0x40 <== NOT EXECUTED 3000ac20: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &new_parent_loc );
3000ac24: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac28: ebfffa8d bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000ac2c: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ac30: 1a000004 bne 3000ac48 <_rename_r+0x12c> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
3000ac34: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac38: ebfffa89 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000ac3c: e1a00006 mov r0, r6 <== NOT EXECUTED
3000ac40: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
3000ac44: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
3000ac48: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac4c: ebfffa84 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED 3000ac50: eafffff7 b 3000ac34 <_rename_r+0x118> <== NOT EXECUTED
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
rtems_filesystem_freenode( &new_parent_loc );
3000ac54: e1a00005 mov r0, r5 <== NOT EXECUTED 3000ac58: ebfffa81 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000ac5c: e3580000 cmp r8, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000ac60: 11a00004 movne r0, r4 <== NOT EXECUTED 3000ac64: 1bfffa7e blne 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000ac68: e1a00007 mov r0, r7 <== NOT EXECUTED 3000ac6c: ebfffa7c bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EXDEV );
3000ac70: eb002889 bl 30014e9c <__errno> <== NOT EXECUTED 3000ac74: e3a03012 mov r3, #18 <== NOT EXECUTED 3000ac78: e5803000 str r3, [r0] <== NOT EXECUTED 3000ac7c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ac80: eaffffed b 3000ac3c <_rename_r+0x120> <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
3000ac84: e3580000 cmp r8, #0 <== NOT EXECUTED 3000ac88: 1a000001 bne 3000ac94 <_rename_r+0x178> <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
return -1;
3000ac8c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000ac90: eaffffe9 b 3000ac3c <_rename_r+0x120> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
3000ac94: e1a00004 mov r0, r4 <== NOT EXECUTED 3000ac98: ebfffa71 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000ac9c: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000aca0: eaffffe5 b 3000ac3c <_rename_r+0x120> <== NOT EXECUTED
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
3000aca4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000aca8: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000acac: e58d3000 str r3, [sp] <== NOT EXECUTED 3000acb0: e3a02002 mov r2, #2 <== NOT EXECUTED 3000acb4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000acb8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000acbc: e1a03004 mov r3, r4 <== NOT EXECUTED 3000acc0: ebfff9af bl 30009384 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
3000acc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000acc8: 1affffef bne 3000ac8c <_rename_r+0x170> <== NOT EXECUTED
return -1;
free_old_parentloc = true;
3000accc: e3a08001 mov r8, #1 <== NOT EXECUTED 3000acd0: eaffff9f b 3000ab54 <_rename_r+0x38> <== NOT EXECUTED
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
3000acd4: e1a00005 mov r0, r5 <== NOT EXECUTED 3000acd8: ebfffa61 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_old_parentloc )
3000acdc: e3580000 cmp r8, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &old_parent_loc );
3000ace0: 11a00004 movne r0, r4 <== NOT EXECUTED 3000ace4: 1bfffa5e blne 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &old_loc );
3000ace8: e1a00007 mov r0, r7 <== NOT EXECUTED 3000acec: ebfffa5c bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000acf0: e3e06000 mvn r6, #0 <== NOT EXECUTED 3000acf4: eaffffd0 b 3000ac3c <_rename_r+0x120> <== NOT EXECUTED
300074ac <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
300074ac: e1a00001 mov r0, r1 <== NOT EXECUTED 300074b0: e1a01002 mov r1, r2 <== NOT EXECUTED 300074b4: eaffffd8 b 3000741c <stat> <== NOT EXECUTED
300093f8 <_times>:
#endif
clock_t _times(
struct tms *ptms
)
{
300093f8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_interval ticks;
if ( !ptms )
300093fc: e2504000 subs r4, r0, #0 <== NOT EXECUTED
#endif
clock_t _times(
struct tms *ptms
)
{
30009400: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
rtems_interval ticks;
if ( !ptms )
30009404: 0a000025 beq 300094a0 <_times+0xa8> <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30009408: eb000114 bl 30009860 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000940c: e59f30a0 ldr r3, [pc, #160] ; 300094b4 <_times+0xbc> <== NOT EXECUTED 30009410: e59f20a0 ldr r2, [pc, #160] ; 300094b8 <_times+0xc0> <== NOT EXECUTED 30009414: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
/*
* This call does not depend on TOD being initialized and can't fail.
*/
ticks = rtems_clock_get_ticks_since_boot();
30009418: e1a05000 mov r5, r0 <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000941c: e0631283 rsb r1, r3, r3, lsl #5 <== NOT EXECUTED 30009420: e0831101 add r1, r3, r1, lsl #2 <== NOT EXECUTED 30009424: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED 30009428: e1a004a1 lsr r0, r1, #9 <== NOT EXECUTED 3000942c: e082c290 umull ip, r2, r0, r2 <== NOT EXECUTED 30009430: e1a023a2 lsr r2, r2, #7 <== NOT EXECUTED 30009434: e062c282 rsb ip, r2, r2, lsl #5 <== NOT EXECUTED 30009438: e59fe07c ldr lr, [pc, #124] ; 300094bc <_times+0xc4> <== NOT EXECUTED 3000943c: e06cc30c rsb ip, ip, ip, lsl #6 <== NOT EXECUTED 30009440: e08e0e93 umull r0, lr, r3, lr <== NOT EXECUTED 30009444: e082c18c add ip, r2, ip, lsl #3 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009448: e59f3070 ldr r3, [pc, #112] ; 300094c0 <_times+0xc8> <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
3000944c: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009450: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30009454: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED 30009458: e08cc10c add ip, ip, ip, lsl #2 <== NOT EXECUTED 3000945c: e041c48c sub ip, r1, ip, lsl #9 <== NOT EXECUTED 30009460: e1a0e92e lsr lr, lr, #18 <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
30009464: e2800084 add r0, r0, #132 ; 0x84 <== NOT EXECUTED 30009468: e28d200c add r2, sp, #12 <== NOT EXECUTED 3000946c: e28d3008 add r3, sp, #8 <== NOT EXECUTED 30009470: e1a0100d mov r1, sp <== NOT EXECUTED
{
Timestamp_Control per_tick;
uint32_t ticks;
uint32_t fractional_ticks;
_Timestamp_Set(
30009474: e58de000 str lr, [sp] <== NOT EXECUTED 30009478: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
TOD_MICROSECONDS_PER_SECOND,
(rtems_configuration_get_nanoseconds_per_tick() %
TOD_NANOSECONDS_PER_SECOND)
);
_Timestamp_Divide(
3000947c: eb000e60 bl 3000ce04 <_Timespec_Divide> <== NOT EXECUTED
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
30009480: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
30009484: e3a03000 mov r3, #0 <== NOT EXECUTED
&_Thread_Executing->cpu_time_used,
&per_tick,
&ticks,
&fractional_ticks
);
ptms->tms_utime = ticks;
30009488: e8840024 stm r4, {r2, r5} <== NOT EXECUTED
}
#else
ptms->tms_utime = _Thread_Executing->cpu_time_used;
#endif
ptms->tms_stime = ticks;
ptms->tms_cutime = 0;
3000948c: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ptms->tms_cstime = 0;
30009490: e584300c str r3, [r4, #12] <== NOT EXECUTED
return ticks;
30009494: e1a00005 mov r0, r5 <== NOT EXECUTED
}
30009498: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000949c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
)
{
rtems_interval ticks;
if ( !ptms )
rtems_set_errno_and_return_minus_one( EFAULT );
300094a0: eb001fee bl 30011460 <__errno> <== NOT EXECUTED 300094a4: e3a0300e mov r3, #14 <== NOT EXECUTED 300094a8: e5803000 str r3, [r0] <== NOT EXECUTED 300094ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300094b0: eafffff8 b 30009498 <_times+0xa0> <== NOT EXECUTED
300094c8 <_times_r>:
clock_t _times_r(
struct _reent *ptr __attribute__((unused)),
struct tms *ptms
)
{
return _times( ptms );
300094c8: e1a00001 mov r0, r1 <== NOT EXECUTED 300094cc: eaffffc9 b 300093f8 <_times> <== NOT EXECUTED
3000a658 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
3000a658: e1a00001 mov r0, r1 <== NOT EXECUTED 3000a65c: eaffffa7 b 3000a500 <unlink> <== NOT EXECUTED
30008694 <access>:
int access(
const char *path,
int amode
)
{
30008694: e92d4010 push {r4, lr} <== NOT EXECUTED
30008698: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
3000869c: e1a04001 mov r4, r1 <== NOT EXECUTED
struct stat statbuf;
if ( stat(path, &statbuf) )
300086a0: e1a0100d mov r1, sp <== NOT EXECUTED 300086a4: eb000607 bl 30009ec8 <stat> <== NOT EXECUTED 300086a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300086ac: 1a00000a bne 300086dc <access+0x48> <== NOT EXECUTED
return -1;
if ( amode & R_OK ) {
300086b0: e3140004 tst r4, #4 <== NOT EXECUTED 300086b4: 1a00000a bne 300086e4 <access+0x50> <== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
300086b8: e3140002 tst r4, #2 <== NOT EXECUTED 300086bc: 1a000003 bne 300086d0 <access+0x3c> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
}
if ( amode & X_OK ) {
300086c0: e2140001 ands r0, r4, #1 <== NOT EXECUTED 300086c4: 1a00000b bne 300086f8 <access+0x64> <== NOT EXECUTED
if ( !( statbuf.st_mode & S_IEXEC ) )
return -1;
}
return 0;
}
300086c8: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
300086cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
300086d0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086d4: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED 300086d8: 1afffff8 bne 300086c0 <access+0x2c> <== NOT EXECUTED
return -1;
300086dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 300086e0: eafffff8 b 300086c8 <access+0x34> <== NOT EXECUTED
if ( stat(path, &statbuf) )
return -1;
if ( amode & R_OK ) {
if (!( statbuf.st_mode & S_IREAD ))
300086e4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086e8: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300086ec: 1afffff1 bne 300086b8 <access+0x24> <== NOT EXECUTED
return -1;
}
if ( amode & W_OK ) {
if ( !( statbuf.st_mode & S_IWRITE ) )
return -1;
300086f0: e3e00000 mvn r0, #0 <== NOT EXECUTED 300086f4: eafffff3 b 300086c8 <access+0x34> <== NOT EXECUTED
}
if ( amode & X_OK ) {
if ( !( statbuf.st_mode & S_IEXEC ) )
300086f8: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 300086fc: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
return -1;
}
return 0;
30008700: 03e00000 mvneq r0, #0 <== NOT EXECUTED 30008704: 13a00000 movne r0, #0 <== NOT EXECUTED 30008708: eaffffee b 300086c8 <access+0x34> <== NOT EXECUTED
30007c34 <cfgetispeed>:
speed_t cfgetispeed(
const struct termios *tp
)
{
return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
30007c34: e1d030ba ldrh r3, [r0, #10] <== NOT EXECUTED
}
30007c38: e59f0004 ldr r0, [pc, #4] ; 30007c44 <cfgetispeed+0x10> <== NOT EXECUTED 30007c3c: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007c40: e12fff1e bx lr <== NOT EXECUTED
30007c48 <cfgetospeed>:
speed_t cfgetospeed(
const struct termios *tp
)
{
return tp->c_cflag & CBAUD;
30007c48: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED
}
30007c4c: e59f0004 ldr r0, [pc, #4] ; 30007c58 <cfgetospeed+0x10> <== NOT EXECUTED 30007c50: e0030000 and r0, r3, r0 <== NOT EXECUTED 30007c54: e12fff1e bx lr <== NOT EXECUTED
30007c5c <cfsetispeed>:
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
30007c5c: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007c60: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
30007c64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007c68: e1a02000 mov r2, r0 <== NOT EXECUTED
if ( speed & ~CBAUD )
30007c6c: 1a000006 bne 30007c8c <cfsetispeed+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
30007c70: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
return 0;
30007c74: e1a00003 mov r0, r3 <== NOT EXECUTED
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
30007c78: e3cc3201 bic r3, ip, #268435456 ; 0x10000000 <== NOT EXECUTED 30007c7c: e3c3380f bic r3, r3, #983040 ; 0xf0000 <== NOT EXECUTED 30007c80: e1831801 orr r1, r3, r1, lsl #16 <== NOT EXECUTED 30007c84: e5821008 str r1, [r2, #8] <== NOT EXECUTED
return 0; }
30007c88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
30007c8c: eb002d75 bl 30013268 <__errno> <== NOT EXECUTED
30007c90: e3a03016 mov r3, #22 <== NOT EXECUTED
30007c94: e5803000 str r3, [r0] <== NOT EXECUTED
30007c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007c9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007ca0 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
30007ca0: e3c13a01 bic r3, r1, #4096 ; 0x1000 <== NOT EXECUTED 30007ca4: e3d3300f bics r3, r3, #15 <== NOT EXECUTED
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
30007ca8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007cac: e1a02000 mov r2, r0 <== NOT EXECUTED
if ( speed & ~CBAUD )
30007cb0: 1a000006 bne 30007cd0 <cfsetospeed+0x30> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
30007cb4: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
return 0;
30007cb8: e1a00003 mov r0, r3 <== NOT EXECUTED
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
30007cbc: e3cc3a01 bic r3, ip, #4096 ; 0x1000 <== NOT EXECUTED 30007cc0: e3c3300f bic r3, r3, #15 <== NOT EXECUTED 30007cc4: e1811003 orr r1, r1, r3 <== NOT EXECUTED 30007cc8: e5821008 str r1, [r2, #8] <== NOT EXECUTED
return 0; }
30007ccc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
struct termios *tp,
speed_t speed
)
{
if ( speed & ~CBAUD )
rtems_set_errno_and_return_minus_one( EINVAL );
30007cd0: eb002d64 bl 30013268 <__errno> <== NOT EXECUTED
30007cd4: e3a03016 mov r3, #22 <== NOT EXECUTED
30007cd8: e5803000 str r3, [r0] <== NOT EXECUTED
30007cdc: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007ce0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007e2c <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
30007e2c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007e30: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30007e34: e1a05001 mov r5, r1 <== NOT EXECUTED
30007e38: e1a06000 mov r6, r0 <== NOT EXECUTED
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
30007e3c: eb003330 bl 30014b04 <strlen> <== NOT EXECUTED 30007e40: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30007e44: e3a03001 mov r3, #1 <== NOT EXECUTED 30007e48: e1a01000 mov r1, r0 <== NOT EXECUTED 30007e4c: e58d3000 str r3, [sp] <== NOT EXECUTED 30007e50: e3a02000 mov r2, #0 <== NOT EXECUTED 30007e54: e1a00006 mov r0, r6 <== NOT EXECUTED 30007e58: e1a03004 mov r3, r4 <== NOT EXECUTED 30007e5c: eb00004e bl 30007f9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
if ( status != 0 )
30007e60: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30007e64: 13e05000 mvnne r5, #0 <== NOT EXECUTED
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
if ( status != 0 )
30007e68: 1a000007 bne 30007e8c <chmod+0x60> <== NOT EXECUTED
return -1;
result = (*loc.handlers->fchmod_h)( &loc, mode );
30007e6c: e1a01005 mov r1, r5 <== NOT EXECUTED 30007e70: e1a00004 mov r0, r4 <== NOT EXECUTED 30007e74: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30007e78: e1a0e00f mov lr, pc <== NOT EXECUTED 30007e7c: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED 30007e80: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30007e84: e1a00004 mov r0, r4 <== NOT EXECUTED 30007e88: eb00007d bl 30008084 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
30007e8c: e1a00005 mov r0, r5 <== NOT EXECUTED
30007e90: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30007e94: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30007f14 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
30007f14: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30007f18: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, true );
30007f1c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007f20: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30007f24: e3a03001 mov r3, #1 <== NOT EXECUTED 30007f28: eaffffda b 30007e98 <_chown_helper> <== NOT EXECUTED
30005e14 <devFS_Show>:
{
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
30005e14: e59f3078 ldr r3, [pc, #120] ; 30005e94 <devFS_Show+0x80> <== NOT EXECUTED
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_Show(void)
{
30005e18: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int i;
rtems_filesystem_location_info_t *temp_loc;
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
30005e1c: e5933000 ldr r3, [r3] <== NOT EXECUTED
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
30005e20: e5935018 ldr r5, [r3, #24] <== NOT EXECUTED
if (!device_name_table)
30005e24: e3550000 cmp r5, #0 <== NOT EXECUTED 30005e28: 0a000014 beq 30005e80 <devFS_Show+0x6c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
30005e2c: e59f6064 ldr r6, [pc, #100] ; 30005e98 <devFS_Show+0x84> <== NOT EXECUTED
30005e30: e5960000 ldr r0, [r6] <== NOT EXECUTED
30005e34: e3500000 cmp r0, #0 <== NOT EXECUTED
30005e38: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
30005e3c: e3a03000 mov r3, #0 <== NOT EXECUTED
30005e40: e1a04003 mov r4, r3 <== NOT EXECUTED
if (device_name_table[i].device_name){
30005e44: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED 30005e48: e7951103 ldr r1, [r5, r3, lsl #2] <== NOT EXECUTED
printk("/%s %d %d\n", device_name_table[i].device_name,
30005e4c: e59f0048 ldr r0, [pc, #72] ; 30005e9c <devFS_Show+0x88> <== NOT EXECUTED
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name){
30005e50: e3510000 cmp r1, #0 <== NOT EXECUTED 30005e54: e0853103 add r3, r5, r3, lsl #2 <== NOT EXECUTED
printk("/%s %d %d\n", device_name_table[i].device_name,
30005e58: 15932008 ldrne r2, [r3, #8] <== NOT EXECUTED 30005e5c: 1593300c ldrne r3, [r3, #12] <== NOT EXECUTED 30005e60: 1b0004b8 blne 30007148 <printk> <== NOT EXECUTED
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++){
30005e64: e5963000 ldr r3, [r6] <== NOT EXECUTED 30005e68: e2844001 add r4, r4, #1 <== NOT EXECUTED 30005e6c: e1540003 cmp r4, r3 <== NOT EXECUTED 30005e70: e1a03004 mov r3, r4 <== NOT EXECUTED 30005e74: 3afffff2 bcc 30005e44 <devFS_Show+0x30> <== NOT EXECUTED
if (device_name_table[i].device_name){
printk("/%s %d %d\n", device_name_table[i].device_name,
device_name_table[i].major, device_name_table[i].minor);
}
}
return 0;
30005e78: e3a00000 mov r0, #0 <== NOT EXECUTED
}
30005e7c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
rtems_device_name_t *device_name_table;
temp_loc = &rtems_filesystem_root;
device_name_table = (rtems_device_name_t *)temp_loc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
30005e80: eb0024b9 bl 3000f16c <__errno> <== NOT EXECUTED
30005e84: e3a0300e mov r3, #14 <== NOT EXECUTED
30005e88: e5803000 str r3, [r0] <== NOT EXECUTED
30005e8c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e90: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000d60c <devFS_evaluate_path>:
{
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000d60c: e3d22007 bics r2, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3000d610: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3000d614: e1a09000 mov r9, r0
3000d618: e1a04001 mov r4, r1
3000d61c: e1a0b003 mov fp, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
3000d620: 1a000028 bne 3000d6c8 <devFS_evaluate_path+0xbc>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
3000d624: e5937000 ldr r7, [r3]
if (!device_name_table)
3000d628: e3570000 cmp r7, #0
3000d62c: 0a00002a beq 3000d6dc <devFS_evaluate_path+0xd0>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000d630: e59f30b8 ldr r3, [pc, #184] ; 3000d6f0 <devFS_evaluate_path+0xe4> 3000d634: e5938000 ldr r8, [r3] 3000d638: e3580000 cmp r8, #0 3000d63c: 11a0a002 movne sl, r2 3000d640: 11a0500a movne r5, sl
3000d644: 0a000010 beq 3000d68c <devFS_evaluate_path+0x80>
if (!device_name_table[i].device_name)
3000d648: e08aa10a add sl, sl, sl, lsl #2 3000d64c: e797610a ldr r6, [r7, sl, lsl #2]
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d650: e1a00009 mov r0, r9
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
3000d654: e2561000 subs r1, r6, #0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d658: e1a02004 mov r2, r4
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
3000d65c: e087a10a add sl, r7, sl, lsl #2
3000d660: 0a000005 beq 3000d67c <devFS_evaluate_path+0x70>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
3000d664: eb000a47 bl 3000ff88 <strncmp> 3000d668: e3500000 cmp r0, #0
3000d66c: 1a000002 bne 3000d67c <devFS_evaluate_path+0x70>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
3000d670: e7d60004 ldrb r0, [r6, r4] 3000d674: e3500000 cmp r0, #0
3000d678: 0a000008 beq 3000d6a0 <devFS_evaluate_path+0x94>
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
3000d67c: e2855001 add r5, r5, #1 3000d680: e1580005 cmp r8, r5 3000d684: e1a0a005 mov sl, r5
3000d688: 8affffee bhi 3000d648 <devFS_evaluate_path+0x3c>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
3000d68c: eb0006b6 bl 3000f16c <__errno> 3000d690: e3a03002 mov r3, #2 3000d694: e5803000 str r3, [r0] 3000d698: e3e00000 mvn r0, #0
}
3000d69c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d6a0: e59f304c ldr r3, [pc, #76] ; 3000d6f4 <devFS_evaluate_path+0xe8>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000d6a4: e59f204c ldr r2, [pc, #76] ; 3000d6f8 <devFS_evaluate_path+0xec>
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d6a8: e5933000 ldr r3, [r3]
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
3000d6ac: e58b2008 str r2, [fp, #8]
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d6b0: e5933028 ldr r3, [r3, #40] ; 0x28
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
3000d6b4: e59f2040 ldr r2, [pc, #64] ; 3000d6fc <devFS_evaluate_path+0xf0>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
3000d6b8: e58ba000 str sl, [fp]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
3000d6bc: e58b200c str r2, [fp, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
3000d6c0: e58b3010 str r3, [fp, #16]
return 0;
3000d6c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
3000d6c8: eb0006a7 bl 3000f16c <__errno> <== NOT EXECUTED
3000d6cc: e3a03001 mov r3, #1 <== NOT EXECUTED
3000d6d0: e5803000 str r3, [r0] <== NOT EXECUTED
3000d6d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d6d8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
3000d6dc: eb0006a2 bl 3000f16c <__errno> <== NOT EXECUTED
3000d6e0: e3a0300e mov r3, #14 <== NOT EXECUTED
3000d6e4: e5803000 str r3, [r0] <== NOT EXECUTED
3000d6e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000d6ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30005c38 <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30005c38: e92d4070 push {r4, r5, r6, lr}
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
30005c3c: e59f605c ldr r6, [pc, #92] ; 30005ca0 <devFS_initialize+0x68>
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
30005c40: e1a04000 mov r4, r0
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
30005c44: e5960000 ldr r0, [r6] 30005c48: e0800100 add r0, r0, r0, lsl #2 30005c4c: e1a00100 lsl r0, r0, #2 30005c50: eb001ceb bl 3000d004 <_Workspace_Allocate>
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
30005c54: e2505000 subs r5, r0, #0
30005c58: 0a00000b beq 30005c8c <devFS_initialize+0x54>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(
30005c5c: e5962000 ldr r2, [r6] 30005c60: e3a01000 mov r1, #0 30005c64: e0822102 add r2, r2, r2, lsl #2 30005c68: e1a02102 lsl r2, r2, #2 30005c6c: eb0027a3 bl 3000fb00 <memset>
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
30005c70: e59f302c ldr r3, [pc, #44] ; 30005ca4 <devFS_initialize+0x6c>
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
30005c74: e584501c str r5, [r4, #28]
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
30005c78: e2832038 add r2, r3, #56 ; 0x38
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
30005c7c: e5843024 str r3, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
30005c80: e5842028 str r2, [r4, #40] ; 0x28
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
return 0;
30005c84: e3a00000 mov r0, #0
}
30005c88: e8bd8070 pop {r4, r5, r6, pc}
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
rtems_set_errno_and_return_minus_one( ENOMEM );
30005c8c: eb002536 bl 3000f16c <__errno> <== NOT EXECUTED
30005c90: e3a0300c mov r3, #12 <== NOT EXECUTED
30005c94: e5803000 str r3, [r0] <== NOT EXECUTED
30005c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005c9c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30005ea0 <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30005ea0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_ioctl_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30005ea4: e590c018 ldr ip, [r0, #24]
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30005ea8: e24dd010 sub sp, sp, #16 30005eac: e1a03000 mov r3, r0
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.command = command;
30005eb0: e98d0006 stmib sp, {r1, r2}
args.buffer = buffer;
status = rtems_io_control(
30005eb4: e59c0008 ldr r0, [ip, #8] 30005eb8: e59c100c ldr r1, [ip, #12] 30005ebc: e1a0200d mov r2, sp
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005ec0: e58d3000 str r3, [sp]
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
30005ec4: eb001049 bl 30009ff0 <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ec8: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
30005ecc: 059d000c ldreq r0, [sp, #12]
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ed0: 1a000001 bne 30005edc <devFS_ioctl+0x3c>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
30005ed4: e28dd010 add sp, sp, #16
30005ed8: e8bd8000 pop {pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005edc: eb001e0a bl 3000d70c <rtems_deviceio_errno> <== NOT EXECUTED 30005ee0: eafffffb b 30005ed4 <devFS_ioctl+0x34> <== NOT EXECUTED
30005ca8 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005ca8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30005cac: e1a04000 mov r4, r0
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
30005cb0: e5d00000 ldrb r0, [r0]
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005cb4: e1a05001 mov r5, r1
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
30005cb8: e3500064 cmp r0, #100 ; 0x64
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
30005cbc: e1a06002 mov r6, r2 30005cc0: e1a0b003 mov fp, r3
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
30005cc4: 0a000036 beq 30005da4 <devFS_mknod+0xfc>
(path[2] == 'v') && (path[3] == '\0'))
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
30005cc8: e2053a0f and r3, r5, #61440 ; 0xf000 30005ccc: e3530a02 cmp r3, #8192 ; 0x2000 30005cd0: 13530a06 cmpne r3, #24576 ; 0x6000 30005cd4: 03a03000 moveq r3, #0 30005cd8: 13a03001 movne r3, #1
30005cdc: 1a00003a bne 30005dcc <devFS_mknod+0x124>
rtems_set_errno_and_return_minus_one( EINVAL );
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
30005ce0: e59d2024 ldr r2, [sp, #36] ; 0x24 30005ce4: e5928000 ldr r8, [r2]
if (!device_name_table)
30005ce8: e3580000 cmp r8, #0
30005cec: 0a000040 beq 30005df4 <devFS_mknod+0x14c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
30005cf0: e59f2110 ldr r2, [pc, #272] ; 30005e08 <devFS_mknod+0x160> 30005cf4: e592a000 ldr sl, [r2] 30005cf8: e35a0000 cmp sl, #0 30005cfc: 13e09000 mvnne r9, #0 30005d00: 11a07003 movne r7, r3
30005d04: 1a000007 bne 30005d28 <devFS_mknod+0x80>
30005d08: ea000034 b 30005de0 <devFS_mknod+0x138> <== NOT EXECUTED
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
30005d0c: eb0027f9 bl 3000fcf8 <strcmp> 30005d10: e3500000 cmp r0, #0
30005d14: 0a00001d beq 30005d90 <devFS_mknod+0xe8>
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
30005d18: e2877001 add r7, r7, #1 30005d1c: e157000a cmp r7, sl 30005d20: e1a03007 mov r3, r7
30005d24: 2a000009 bcs 30005d50 <devFS_mknod+0xa8>
if (device_name_table[i].device_name == NULL)
30005d28: e0833103 add r3, r3, r3, lsl #2 30005d2c: e7983103 ldr r3, [r8, r3, lsl #2]
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
30005d30: e1a00004 mov r0, r4
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
30005d34: e2531000 subs r1, r3, #0
30005d38: 1afffff3 bne 30005d0c <devFS_mknod+0x64>
30005d3c: e1a09007 mov r9, r7
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
30005d40: e2877001 add r7, r7, #1 30005d44: e157000a cmp r7, sl 30005d48: e1a03007 mov r3, r7
30005d4c: 3afffff5 bcc 30005d28 <devFS_mknod+0x80>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
30005d50: e3790001 cmn r9, #1
30005d54: 0a000021 beq 30005de0 <devFS_mknod+0x138>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30005d58: e10f7000 mrs r7, CPSR 30005d5c: e3873080 orr r3, r7, #128 ; 0x80 30005d60: e129f003 msr CPSR_fc, r3
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
30005d64: e0899109 add r9, r9, r9, lsl #2 30005d68: e1a09109 lsl r9, r9, #2 30005d6c: e7884009 str r4, [r8, r9]
device_name_table[slot].device_name_length = strlen(path);
30005d70: e1a00004 mov r0, r4 30005d74: eb00286b bl 3000ff28 <strlen>
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
30005d78: e0888009 add r8, r8, r9
device_name_table[slot].device_name_length = strlen(path); device_name_table[slot].major = major;
30005d7c: e9880841 stmib r8, {r0, r6, fp}
device_name_table[slot].minor = minor; device_name_table[slot].mode = mode;
30005d80: e5885010 str r5, [r8, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30005d84: e129f007 msr CPSR_fc, r7
_ISR_Enable(level);
return 0;
30005d88: e3a00000 mov r0, #0
}
30005d8c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
30005d90: eb0024f5 bl 3000f16c <__errno> <== NOT EXECUTED
30005d94: e3a03011 mov r3, #17 <== NOT EXECUTED
30005d98: e5803000 str r3, [r0] <== NOT EXECUTED
30005d9c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005da0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
30005da4: e5d43001 ldrb r3, [r4, #1] 30005da8: e3530065 cmp r3, #101 ; 0x65
30005dac: 1affffc5 bne 30005cc8 <devFS_mknod+0x20>
30005db0: e5d43002 ldrb r3, [r4, #2] 30005db4: e3530076 cmp r3, #118 ; 0x76
30005db8: 1affffc2 bne 30005cc8 <devFS_mknod+0x20>
(path[2] == 'v') && (path[3] == '\0'))
30005dbc: e5d40003 ldrb r0, [r4, #3] 30005dc0: e3500000 cmp r0, #0
30005dc4: 1affffbf bne 30005cc8 <devFS_mknod+0x20>
30005dc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
rtems_set_errno_and_return_minus_one( EINVAL );
30005dcc: eb0024e6 bl 3000f16c <__errno> <== NOT EXECUTED
30005dd0: e3a03016 mov r3, #22 <== NOT EXECUTED
30005dd4: e5803000 str r3, [r0] <== NOT EXECUTED
30005dd8: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005ddc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
30005de0: eb0024e1 bl 3000f16c <__errno> <== NOT EXECUTED
30005de4: e3a0300c mov r3, #12 <== NOT EXECUTED
30005de8: e5803000 str r3, [r0] <== NOT EXECUTED
30005dec: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005df0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
30005df4: eb0024dc bl 3000f16c <__errno> <== NOT EXECUTED
30005df8: e3a0300e mov r3, #14 <== NOT EXECUTED
30005dfc: e5803000 str r3, [r0] <== NOT EXECUTED
30005e00: e3e00000 mvn r0, #0 <== NOT EXECUTED
30005e04: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30005f1c <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30005f1c: e92d4800 push {fp, lr} <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30005f20: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30005f24: e24dd01c sub sp, sp, #28 <== NOT EXECUTED 30005f28: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
30005f2c: e590e014 ldr lr, [r0, #20] <== NOT EXECUTED
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
30005f30: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30005f34: e59c0008 ldr r0, [ip, #8] <== NOT EXECUTED 30005f38: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
30005f3c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005f40: e283c00c add ip, r3, #12 <== NOT EXECUTED
30005f44: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005f48: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30005f4c: e1a0200d mov r2, sp <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30005f50: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005f54: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count; args.flags = iop->flags;
30005f58: e58de014 str lr, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
30005f5c: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
30005f60: eb001085 bl 3000a17c <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
30005f64: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30005f68: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
30005f6c: 1a000001 bne 30005f78 <devFS_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30005f70: e28dd01c add sp, sp, #28 <== NOT EXECUTED
30005f74: e8bd8800 pop {fp, pc} <== NOT EXECUTED
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005f78: eb001de3 bl 3000d70c <rtems_deviceio_errno> <== NOT EXECUTED 30005f7c: eafffffb b 30005f70 <devFS_read+0x54> <== NOT EXECUTED
30005fa0 <devFS_write>:
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30005fa0: e92d4800 push {fp, lr}
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
30005fa4: e590c018 ldr ip, [r0, #24]
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
30005fa8: e24dd01c sub sp, sp, #28 30005fac: e1a03000 mov r3, r0
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
30005fb0: e590e014 ldr lr, [r0, #20]
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
30005fb4: e58d100c str r1, [sp, #12]
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
30005fb8: e59c0008 ldr r0, [ip, #8] 30005fbc: e59c100c ldr r1, [ip, #12]
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
30005fc0: e58d2010 str r2, [sp, #16]
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005fc4: e283c00c add ip, r3, #12
30005fc8: e89c1800 ldm ip, {fp, ip}
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
30005fcc: e58d3000 str r3, [sp]
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
30005fd0: e1a0200d mov r2, sp
args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30005fd4: e3a03000 mov r3, #0
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30005fd8: e98d1800 stmib sp, {fp, ip}
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags;
30005fdc: e58de014 str lr, [sp, #20]
args.bytes_moved = 0;
30005fe0: e58d3018 str r3, [sp, #24]
status = rtems_io_write(
30005fe4: eb001079 bl 3000a1d0 <rtems_io_write>
np->major,
np->minor,
(void *) &args
);
if ( status )
30005fe8: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30005fec: 059d0018 ldreq r0, [sp, #24]
np->major,
np->minor,
(void *) &args
);
if ( status )
30005ff0: 1a000001 bne 30005ffc <devFS_write+0x5c>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30005ff4: e28dd01c add sp, sp, #28
30005ff8: e8bd8800 pop {fp, pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30005ffc: eb001dc2 bl 3000d70c <rtems_deviceio_errno> <== NOT EXECUTED 30006000: eafffffb b 30005ff4 <devFS_write+0x54> <== NOT EXECUTED
30010878 <device_ftruncate>:
rtems_libio_t *iop,
rtems_off64_t length
)
{
return 0;
}
30010878: e3a00000 mov r0, #0 <== NOT EXECUTED 3001087c: e12fff1e bx lr <== NOT EXECUTED
30010828 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30010828: e52de004 push {lr} ; (str lr, [sp, #-4]!)
args.iop = iop;
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
3001082c: e590c018 ldr ip, [r0, #24]
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
30010830: e24dd010 sub sp, sp, #16 30010834: e1a03000 mov r3, r0
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
args.command = command;
30010838: e98d0006 stmib sp, {r1, r2}
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
3001083c: e59c0050 ldr r0, [ip, #80] ; 0x50 30010840: e59c1054 ldr r1, [ip, #84] ; 0x54 30010844: e1a0200d mov r2, sp
{
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
30010848: e58d3000 str r3, [sp]
args.command = command;
args.buffer = buffer;
the_jnode = iop->pathinfo.node_access;
status = rtems_io_control(
3001084c: eb000187 bl 30010e70 <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
30010850: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
30010854: 059d000c ldreq r0, [sp, #12]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
30010858: 1a000001 bne 30010864 <device_ioctl+0x3c>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
3001085c: e28dd010 add sp, sp, #16
30010860: e8bd8000 pop {pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30010864: eb00021c bl 300110dc <rtems_deviceio_errno> <== NOT EXECUTED 30010868: eafffffb b 3001085c <device_ioctl+0x34> <== NOT EXECUTED
3001086c <device_lseek>:
rtems_off64_t offset,
int whence
)
{
return offset;
}
3001086c: e1a00001 mov r0, r1 <== NOT EXECUTED 30010870: e1a01002 mov r1, r2 <== NOT EXECUTED 30010874: e12fff1e bx lr <== NOT EXECUTED
30010760 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30010760: e92d4800 push {fp, lr} <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010764: e590c018 ldr ip, [r0, #24] <== NOT EXECUTED
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
30010768: e24dd01c sub sp, sp, #28 <== NOT EXECUTED 3001076c: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
30010770: e590e014 ldr lr, [r0, #20] <== NOT EXECUTED
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
30010774: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
30010778: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
3001077c: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED 30010780: e59c1054 ldr r1, [ip, #84] ; 0x54 <== NOT EXECUTED
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
30010784: e58d3000 str r3, [sp] <== NOT EXECUTED
args.offset = iop->offset;
30010788: e283c00c add ip, r3, #12 <== NOT EXECUTED
3001078c: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
30010790: e1a0200d mov r2, sp <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
30010794: e3a03000 mov r3, #0 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
30010798: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
args.buffer = buffer; args.count = count; args.flags = iop->flags;
3001079c: e58de014 str lr, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
300107a0: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
status = rtems_io_read(
300107a4: eb0001db bl 30010f18 <rtems_io_read> <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
300107a8: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
300107ac: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
300107b0: 1a000001 bne 300107bc <device_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
300107b4: e28dd01c add sp, sp, #28 <== NOT EXECUTED
300107b8: e8bd8800 pop {fp, pc} <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
300107bc: eb000246 bl 300110dc <rtems_deviceio_errno> <== NOT EXECUTED 300107c0: eafffffb b 300107b4 <device_read+0x54> <== NOT EXECUTED
300107c4 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
300107c4: e92d4800 push {fp, lr}
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
300107c8: e590c018 ldr ip, [r0, #24]
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
300107cc: e24dd01c sub sp, sp, #28 300107d0: e1a03000 mov r3, r0
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
300107d4: e590e014 ldr lr, [r0, #20]
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
300107d8: e58d100c str r1, [sp, #12]
args.count = count;
300107dc: e58d2010 str r2, [sp, #16]
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
300107e0: e59c0050 ldr r0, [ip, #80] ; 0x50 300107e4: e59c1054 ldr r1, [ip, #84] ; 0x54
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
300107e8: e58d3000 str r3, [sp]
args.offset = iop->offset;
300107ec: e283c00c add ip, r3, #12
300107f0: e89c1800 ldm ip, {fp, ip}
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
300107f4: e1a0200d mov r2, sp
args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
300107f8: e3a03000 mov r3, #0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
args.iop = iop;
args.offset = iop->offset;
300107fc: e98d1800 stmib sp, {fp, ip}
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags;
30010800: e58de014 str lr, [sp, #20]
args.bytes_moved = 0;
30010804: e58d3018 str r3, [sp, #24]
status = rtems_io_write(
30010808: eb0001d7 bl 30010f6c <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
3001080c: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
30010810: 059d0018 ldreq r0, [sp, #24]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
30010814: 1a000001 bne 30010820 <device_write+0x5c>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
30010818: e28dd01c add sp, sp, #28
3001081c: e8bd8800 pop {fp, pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
30010820: eb00022d bl 300110dc <rtems_deviceio_errno> <== NOT EXECUTED 30010824: eafffffb b 30010818 <device_write+0x54> <== NOT EXECUTED
30007408 <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007408: e59030b4 ldr r3, [r0, #180] ; 0xb4
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
3000740c: e92d4030 push {r4, r5, lr}
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007410: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
30007414: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
30007418: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000741c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007420: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007424: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007428: e5901084 ldr r1, [r0, #132] ; 0x84 <== NOT EXECUTED 3000742c: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 30007430: e1510002 cmp r1, r2 <== NOT EXECUTED 30007434: 0a00000f beq 30007478 <drainOutput+0x70> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007438: e3a05002 mov r5, #2 <== NOT EXECUTED 3000743c: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007440: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30007444: e3a01000 mov r1, #0 <== NOT EXECUTED 30007448: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 3000744c: e1a02001 mov r2, r1 <== NOT EXECUTED 30007450: eb0009bf bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007454: e3500000 cmp r0, #0 <== NOT EXECUTED 30007458: 1a000008 bne 30007480 <drainOutput+0x78> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000745c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007460: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007464: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
30007468: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED 3000746c: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED 30007470: e1510002 cmp r1, r2 <== NOT EXECUTED 30007474: 1afffff0 bne 3000743c <drainOutput+0x34> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007478: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3000747c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007480: eb000b5a bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
30006cc4 <dup>:
int dup(
int fildes
)
{
return fcntl( fildes, F_DUPFD, 0 );
30006cc4: e3a01000 mov r1, #0 <== NOT EXECUTED 30006cc8: e1a02001 mov r2, r1 <== NOT EXECUTED 30006ccc: ea000055 b 30006e28 <fcntl> <== NOT EXECUTED
30006c70 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
30006c70: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30006c74: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006c78: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c7c: e1a0100d mov r1, sp <== NOT EXECUTED
int dup2(
int fildes,
int fildes2
)
{
30006c80: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c84: eb000178 bl 3000726c <fstat> <== NOT EXECUTED
if ( status == -1 )
30006c88: e3700001 cmn r0, #1 <== NOT EXECUTED
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
30006c8c: e1a0400d mov r4, sp <== NOT EXECUTED
if ( status == -1 )
30006c90: 1a000001 bne 30006c9c <dup2+0x2c> <== NOT EXECUTED
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
}
30006c94: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
30006c98: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
30006c9c: e1a00005 mov r0, r5 <== NOT EXECUTED 30006ca0: e1a0100d mov r1, sp <== NOT EXECUTED 30006ca4: eb000170 bl 3000726c <fstat> <== NOT EXECUTED
if ( status == -1 )
30006ca8: e3700001 cmn r0, #1 <== NOT EXECUTED 30006cac: 0afffff8 beq 30006c94 <dup2+0x24> <== NOT EXECUTED
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
30006cb0: e1a00006 mov r0, r6 <== NOT EXECUTED 30006cb4: e3a01000 mov r1, #0 <== NOT EXECUTED 30006cb8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006cbc: eb000059 bl 30006e28 <fcntl> <== NOT EXECUTED 30006cc0: eafffff3 b 30006c94 <dup2+0x24> <== NOT EXECUTED
30008170 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008170: e92d4010 push {r4, lr} <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30008174: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008178: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
3000817c: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
30008180: e1a04001 mov r4, r1 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
30008184: 0a00000b beq 300081b8 <echo+0x48> <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
30008188: e59f3070 ldr r3, [pc, #112] ; 30008200 <echo+0x90> <== NOT EXECUTED 3000818c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008190: e0833000 add r3, r3, r0 <== NOT EXECUTED 30008194: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
30008198: e3130020 tst r3, #32 <== NOT EXECUTED 3000819c: 03a03000 moveq r3, #0 <== NOT EXECUTED 300081a0: 13a03001 movne r3, #1 <== NOT EXECUTED
iscntrl(c) && (c != '\t') && (c != '\n')) {
300081a4: e3500009 cmp r0, #9 <== NOT EXECUTED 300081a8: 03a03000 moveq r3, #0 <== NOT EXECUTED 300081ac: 12033001 andne r3, r3, #1 <== NOT EXECUTED 300081b0: e3530000 cmp r3, #0 <== NOT EXECUTED 300081b4: 1a000003 bne 300081c8 <echo+0x58> <== NOT EXECUTED
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
} else {
oproc (c, tty);
300081b8: e1a01004 mov r1, r4 <== NOT EXECUTED 300081bc: ebffff8f bl 30008000 <oproc> <== NOT EXECUTED
} }
300081c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300081c4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
300081c8: e350000a cmp r0, #10 <== NOT EXECUTED 300081cc: 0afffff9 beq 300081b8 <echo+0x48> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
300081d0: e2203040 eor r3, r0, #64 ; 0x40 <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
300081d4: e3a0c05e mov ip, #94 ; 0x5e <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
300081d8: e1a0000d mov r0, sp <== NOT EXECUTED 300081dc: e3a01002 mov r1, #2 <== NOT EXECUTED 300081e0: e1a02004 mov r2, r4 <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
300081e4: e5cd3001 strb r3, [sp, #1] <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
300081e8: e5cdc000 strb ip, [sp] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
300081ec: ebffff3c bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
300081f0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300081f4: e2833002 add r3, r3, #2 <== NOT EXECUTED 300081f8: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
300081fc: eaffffef b 300081c0 <echo+0x50> <== NOT EXECUTED
300075a0 <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
300075a0: e59f300c ldr r3, [pc, #12] ; 300075b4 <endgrent+0x14> <== NOT EXECUTED 300075a4: e59301c4 ldr r0, [r3, #452] ; 0x1c4 <== NOT EXECUTED 300075a8: e3500000 cmp r0, #0 <== NOT EXECUTED 300075ac: 012fff1e bxeq lr <== NOT EXECUTED
fclose(group_fp);
300075b0: ea002b2f b 30012274 <fclose> <== NOT EXECUTED
30007434 <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
30007434: e59f300c ldr r3, [pc, #12] ; 30007448 <endpwent+0x14> <== NOT EXECUTED 30007438: e59300e8 ldr r0, [r3, #232] ; 0xe8 <== NOT EXECUTED 3000743c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007440: 012fff1e bxeq lr <== NOT EXECUTED
fclose(passwd_fp);
30007444: ea002b8a b 30012274 <fclose> <== NOT EXECUTED
30008204 <erase>:
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
30008204: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
30008208: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
if (tty->ccount == 0)
3000820c: e3530000 cmp r3, #0 <== NOT EXECUTED
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
30008210: e1a04000 mov r4, r0 <== NOT EXECUTED 30008214: e1a06001 mov r6, r1 <== NOT EXECUTED
if (tty->ccount == 0)
30008218: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return;
if (lineFlag) {
3000821c: e3510000 cmp r1, #0 <== NOT EXECUTED 30008220: 0a000010 beq 30008268 <erase+0x64> <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
30008224: e590103c ldr r1, [r0, #60] ; 0x3c <== NOT EXECUTED 30008228: e2112008 ands r2, r1, #8 <== NOT EXECUTED
tty->ccount = 0;
3000822c: 05802020 streq r2, [r0, #32] <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
30008230: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
30008234: e2110010 ands r0, r1, #16 <== NOT EXECUTED 30008238: 1a00000c bne 30008270 <erase+0x6c> <== NOT EXECUTED
tty->ccount = 0;
3000823c: e5840020 str r0, [r4, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
30008240: e1a01004 mov r1, r4 <== NOT EXECUTED 30008244: e5d40044 ldrb r0, [r4, #68] ; 0x44 <== NOT EXECUTED 30008248: ebffffc8 bl 30008170 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
3000824c: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
30008250: e3130020 tst r3, #32 <== NOT EXECUTED
30008254: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
30008258: e3a0000a mov r0, #10 <== NOT EXECUTED 3000825c: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
30008260: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
30008264: eaffffc1 b 30008170 <echo> <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
30008268: e590103c ldr r1, [r0, #60] ; 0x3c <== NOT EXECUTED 3000826c: e2012008 and r2, r1, #8 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
30008270: e59f7198 ldr r7, [pc, #408] ; 30008410 <erase+0x20c> <== NOT EXECUTED 30008274: ea000008 b 3000829c <erase+0x98> <== NOT EXECUTED 30008278: e3110c02 tst r1, #512 ; 0x200 <== NOT EXECUTED 3000827c: 1a00004b bne 300083b0 <erase+0x1ac> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30008280: e3560000 cmp r6, #0 <== NOT EXECUTED
30008284: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
30008288: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3000828c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008290: 0a000045 beq 300083ac <erase+0x1a8> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
30008294: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED 30008298: e2012008 and r2, r1, #8 <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3000829c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 300082a0: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 300082a4: e5843020 str r3, [r4, #32] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
300082a8: e3520000 cmp r2, #0 <== NOT EXECUTED
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
300082ac: e7d05003 ldrb r5, [r0, r3] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
300082b0: 0afffff2 beq 30008280 <erase+0x7c> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
300082b4: e3560000 cmp r6, #0 <== NOT EXECUTED 300082b8: 1a000001 bne 300082c4 <erase+0xc0> <== NOT EXECUTED 300082bc: e3110010 tst r1, #16 <== NOT EXECUTED 300082c0: 0a000035 beq 3000839c <erase+0x198> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
300082c4: e3550009 cmp r5, #9 <== NOT EXECUTED 300082c8: 0a00000f beq 3000830c <erase+0x108> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
300082cc: e5973000 ldr r3, [r7] <== NOT EXECUTED 300082d0: e2855001 add r5, r5, #1 <== NOT EXECUTED 300082d4: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 300082d8: e3130020 tst r3, #32 <== NOT EXECUTED 300082dc: 1affffe5 bne 30008278 <erase+0x74> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
300082e0: e59f012c ldr r0, [pc, #300] ; 30008414 <erase+0x210> <== NOT EXECUTED 300082e4: e3a01003 mov r1, #3 <== NOT EXECUTED 300082e8: e1a02004 mov r2, r4 <== NOT EXECUTED 300082ec: ebfffefc bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300082f0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300082f4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
300082f8: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300082fc: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
}
}
if (!lineFlag)
30008300: e3560000 cmp r6, #0 <== NOT EXECUTED
30008304: 1affffdf bne 30008288 <erase+0x84> <== NOT EXECUTED
30008308: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3000830c: e3530000 cmp r3, #0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
30008310: e594502c ldr r5, [r4, #44] ; 0x2c <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30008314: 0a000011 beq 30008360 <erase+0x15c> <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30008318: e5978000 ldr r8, [r7] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
} else if (c == '\t') {
int col = tty->read_start_column;
int i = 0;
3000831c: e3a02000 mov r2, #0 <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
30008320: e201ac02 and sl, r1, #512 ; 0x200 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
30008324: e7d01002 ldrb r1, [r0, r2] <== NOT EXECUTED 30008328: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (c == '\t') {
3000832c: e3510009 cmp r1, #9 <== NOT EXECUTED
col = (col | 7) + 1;
30008330: 03855007 orreq r5, r5, #7 <== NOT EXECUTED
} else if (iscntrl (c)) {
30008334: e088c001 add ip, r8, r1 <== NOT EXECUTED
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
30008338: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
3000833c: 0a000005 beq 30008358 <erase+0x154> <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
30008340: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 30008344: e31c0020 tst ip, #32 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
30008348: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
3000834c: 0a000001 beq 30008358 <erase+0x154> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
30008350: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
30008354: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
30008358: e1530002 cmp r3, r2 <== NOT EXECUTED 3000835c: 1afffff0 bne 30008324 <erase+0x120> <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30008360: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008364: e1550003 cmp r5, r3 <== NOT EXECUTED 30008368: aaffffc4 bge 30008280 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
3000836c: e59f00a4 ldr r0, [pc, #164] ; 30008418 <erase+0x214> <== NOT EXECUTED 30008370: e3a01001 mov r1, #1 <== NOT EXECUTED 30008374: e1a02004 mov r2, r4 <== NOT EXECUTED 30008378: ebfffed9 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
3000837c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008380: e2433001 sub r3, r3, #1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
30008384: e1530005 cmp r3, r5 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
30008388: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3000838c: cafffff6 bgt 3000836c <erase+0x168> <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
30008390: e3560000 cmp r6, #0 <== NOT EXECUTED
30008394: 1affffbb bne 30008288 <erase+0x84> <== NOT EXECUTED
30008398: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
3000839c: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED 300083a0: e1a01004 mov r1, r4 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
300083a4: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
300083a8: eaffff70 b 30008170 <echo> <== NOT EXECUTED
300083ac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
300083b0: e59f005c ldr r0, [pc, #92] ; 30008414 <erase+0x210> <== NOT EXECUTED 300083b4: e3a01003 mov r1, #3 <== NOT EXECUTED 300083b8: e1a02004 mov r2, r4 <== NOT EXECUTED 300083bc: ebfffec8 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300083c0: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300083c4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
300083c8: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300083cc: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
300083d0: e5973000 ldr r3, [r7] <== NOT EXECUTED 300083d4: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED 300083d8: e3130020 tst r3, #32 <== NOT EXECUTED 300083dc: 0affffbf beq 300082e0 <erase+0xdc> <== NOT EXECUTED 300083e0: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 300083e4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 300083e8: 0affffa4 beq 30008280 <erase+0x7c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
300083ec: e59f0020 ldr r0, [pc, #32] ; 30008414 <erase+0x210> <== NOT EXECUTED 300083f0: e3a01003 mov r1, #3 <== NOT EXECUTED 300083f4: e1a02004 mov r2, r4 <== NOT EXECUTED 300083f8: ebfffeb9 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
300083fc: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008400: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30008404: 12433001 subne r3, r3, #1 <== NOT EXECUTED 30008408: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 3000840c: eaffffbb b 30008300 <erase+0xfc> <== NOT EXECUTED
30007360 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007360: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
30007364: e59f3138 ldr r3, [pc, #312] ; 300074a4 <fchdir+0x144> <== NOT EXECUTED
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
30007368: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
3000736c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007370: e1500003 cmp r0, r3 <== NOT EXECUTED 30007374: 2a000040 bcs 3000747c <fchdir+0x11c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007378: e59f3128 ldr r3, [pc, #296] ; 300074a8 <fchdir+0x148> <== NOT EXECUTED 3000737c: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 30007380: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007384: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007388: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000738c: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007390: 0a000039 beq 3000747c <fchdir+0x11c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30007394: e3130002 tst r3, #2 <== NOT EXECUTED 30007398: 0a00003c beq 30007490 <fchdir+0x130> <== NOT EXECUTED
/*
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
3000739c: e2805018 add r5, r0, #24 <== NOT EXECUTED 300073a0: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 300073a4: e1a00005 mov r0, r5 <== NOT EXECUTED 300073a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300073ac: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 300073b0: e3500001 cmp r0, #1 <== NOT EXECUTED 300073b4: e1a07000 mov r7, r0 <== NOT EXECUTED 300073b8: 1a000022 bne 30007448 <fchdir+0xe8> <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073bc: e59f60e8 ldr r6, [pc, #232] ; 300074ac <fchdir+0x14c> <== NOT EXECUTED
300073c0: e28d4004 add r4, sp, #4 <== NOT EXECUTED
300073c4: e596e000 ldr lr, [r6] <== NOT EXECUTED
300073c8: e1a09004 mov r9, r4 <== NOT EXECUTED
300073cc: e28ec004 add ip, lr, #4 <== NOT EXECUTED
300073d0: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
300073d4: e8a9000f stmia r9!, {r0, r1, r2, r3} <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073d8: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073dc: e59cb000 ldr fp, [ip] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073e0: e595a000 ldr sl, [r5] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300073e4: e28d8018 add r8, sp, #24 <== NOT EXECUTED 300073e8: e3a05000 mov r5, #0 <== NOT EXECUTED
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
rtems_filesystem_current = iop->pathinfo;
300073ec: e28ee004 add lr, lr, #4 <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
300073f0: e589b000 str fp, [r9] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
300073f4: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
300073f8: e58ca000 str sl, [ip] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
300073fc: e1a02005 mov r2, r5 <== NOT EXECUTED 30007400: e59f00a8 ldr r0, [pc, #168] ; 300074b0 <fchdir+0x150> <== NOT EXECUTED 30007404: e1a01007 mov r1, r7 <== NOT EXECUTED 30007408: e1a03008 mov r3, r8 <== NOT EXECUTED 3000740c: e58d5000 str r5, [sp] <== NOT EXECUTED 30007410: ebffff98 bl 30007278 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30007414: e2505000 subs r5, r0, #0 <== NOT EXECUTED 30007418: 1a00000f bne 3000745c <fchdir+0xfc> <== NOT EXECUTED
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
3000741c: e1a00004 mov r0, r4 <== NOT EXECUTED 30007420: eb000065 bl 300075bc <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_current = loc;
30007424: e8b8000f ldm r8!, {r0, r1, r2, r3} <== NOT EXECUTED
30007428: e596c000 ldr ip, [r6] <== NOT EXECUTED
3000742c: e5984000 ldr r4, [r8] <== NOT EXECUTED
30007430: e28cc004 add ip, ip, #4 <== NOT EXECUTED
30007434: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
return 0;
30007438: e1a00005 mov r0, r5 <== NOT EXECUTED
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
rtems_filesystem_current = loc;
3000743c: e58c4000 str r4, [ip] <== NOT EXECUTED
return 0;
}
30007440: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
30007444: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* Verify you can change directory into this node.
*/
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
30007448: eb002bdb bl 300123bc <__errno> <== NOT EXECUTED 3000744c: e3a03014 mov r3, #20 <== NOT EXECUTED 30007450: e5803000 str r3, [r0] <== NOT EXECUTED 30007454: e3e00000 mvn r0, #0 <== NOT EXECUTED 30007458: eafffff8 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
3000745c: e596c000 ldr ip, [r6] <== NOT EXECUTED
30007460: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
30007464: e28cc004 add ip, ip, #4 <== NOT EXECUTED
30007468: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3000746c: e5993000 ldr r3, [r9] <== NOT EXECUTED
return -1;
30007470: e3e00000 mvn r0, #0 <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
30007474: e58c3000 str r3, [ip] <== NOT EXECUTED
return -1;
30007478: eafffff0 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000747c: eb002bce bl 300123bc <__errno> <== NOT EXECUTED 30007480: e3a03009 mov r3, #9 <== NOT EXECUTED 30007484: e5803000 str r3, [r0] <== NOT EXECUTED 30007488: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000748c: eaffffeb b 30007440 <fchdir+0xe0> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30007490: eb002bc9 bl 300123bc <__errno> <== NOT EXECUTED 30007494: e3a03016 mov r3, #22 <== NOT EXECUTED 30007498: e5803000 str r3, [r0] <== NOT EXECUTED 3000749c: e3e00000 mvn r0, #0 <== NOT EXECUTED 300074a0: eaffffe6 b 30007440 <fchdir+0xe0> <== NOT EXECUTED
300074b4 <fchmod>:
mode_t mode
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300074b4: e59f306c ldr r3, [pc, #108] ; 30007528 <fchmod+0x74> <== NOT EXECUTED
int fchmod(
int fd,
mode_t mode
)
{
300074b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300074bc: e5933000 ldr r3, [r3] <== NOT EXECUTED 300074c0: e1500003 cmp r0, r3 <== NOT EXECUTED 300074c4: 2a00000d bcs 30007500 <fchmod+0x4c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
300074c8: e59f305c ldr r3, [pc, #92] ; 3000752c <fchmod+0x78> <== NOT EXECUTED 300074cc: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300074d0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300074d4: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
300074d8: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 300074dc: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300074e0: 0a000006 beq 30007500 <fchmod+0x4c> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300074e4: e3130004 tst r3, #4 <== NOT EXECUTED 300074e8: 0a000009 beq 30007514 <fchmod+0x60> <== NOT EXECUTED
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
300074ec: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 300074f0: e2800018 add r0, r0, #24 <== NOT EXECUTED 300074f4: e1a0e00f mov lr, pc <== NOT EXECUTED 300074f8: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
300074fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007500: eb002bad bl 300123bc <__errno> <== NOT EXECUTED
30007504: e3a03009 mov r3, #9 <== NOT EXECUTED
30007508: e5803000 str r3, [r0] <== NOT EXECUTED
3000750c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007510: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the fchmod().
*/
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007514: eb002ba8 bl 300123bc <__errno> <== NOT EXECUTED
30007518: e3a03016 mov r3, #22 <== NOT EXECUTED
3000751c: e5803000 str r3, [r0] <== NOT EXECUTED
30007520: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007524: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007530 <fchown>:
gid_t group
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007530: e59f307c ldr r3, [pc, #124] ; 300075b4 <fchown+0x84> <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
30007534: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007538: e5933000 ldr r3, [r3] <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
3000753c: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007540: e1500003 cmp r0, r3 <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
30007544: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007548: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
3000754c: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007550: 2a00000d bcs 3000758c <fchown+0x5c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007554: e59f305c ldr r3, [pc, #92] ; 300075b8 <fchown+0x88> <== NOT EXECUTED 30007558: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000755c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007560: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007564: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007568: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000756c: 0a000006 beq 3000758c <fchown+0x5c> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007570: e3130004 tst r3, #4 <== NOT EXECUTED 30007574: 0a000009 beq 300075a0 <fchown+0x70> <== NOT EXECUTED
return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
30007578: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 3000757c: e2800018 add r0, r0, #24 <== NOT EXECUTED 30007580: e1a0e00f mov lr, pc <== NOT EXECUTED 30007584: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED
}
30007588: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000758c: eb002b8a bl 300123bc <__errno> <== NOT EXECUTED
30007590: e3a03009 mov r3, #9 <== NOT EXECUTED
30007594: e5803000 str r3, [r0] <== NOT EXECUTED
30007598: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000759c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
300075a0: eb002b85 bl 300123bc <__errno> <== NOT EXECUTED
300075a4: e3a03016 mov r3, #22 <== NOT EXECUTED
300075a8: e5803000 str r3, [r0] <== NOT EXECUTED
300075ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
300075b0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006e28 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
30006e28: e92d000e push {r1, r2, r3}
30006e2c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e30: e59f31cc ldr r3, [pc, #460] ; 30007004 <fcntl+0x1dc>
int fcntl(
int fd,
int cmd,
...
)
{
30006e34: e24dd004 sub sp, sp, #4
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e38: e5932000 ldr r2, [r3]
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
30006e3c: e28d3028 add r3, sp, #40 ; 0x28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e40: e1500002 cmp r0, r2
int fcntl(
int fd,
int cmd,
...
)
{
30006e44: e59d4024 ldr r4, [sp, #36] ; 0x24
int ret; va_list ap; va_start( ap, cmd );
30006e48: e58d3000 str r3, [sp]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
30006e4c: 2a000060 bcs 30006fd4 <fcntl+0x1ac>
iop = rtems_libio_iop( fd );
30006e50: e59f71b0 ldr r7, [pc, #432] ; 30007008 <fcntl+0x1e0> 30006e54: e0600180 rsb r0, r0, r0, lsl #3 30006e58: e5976000 ldr r6, [r7] 30006e5c: e0865180 add r5, r6, r0, lsl #3
rtems_libio_check_is_open(iop);
30006e60: e595c014 ldr ip, [r5, #20] 30006e64: e31c0c01 tst ip, #256 ; 0x100
30006e68: 0a000059 beq 30006fd4 <fcntl+0x1ac>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
30006e6c: e3540009 cmp r4, #9 30006e70: 979ff104 ldrls pc, [pc, r4, lsl #2] 30006e74: ea000027 b 30006f18 <fcntl+0xf0> 30006e78: 30006f28 .word 0x30006f28 30006e7c: 30006f8c .word 0x30006f8c 30006e80: 30006f9c .word 0x30006f9c 30006e84: 30006fbc .word 0x30006fbc 30006e88: 30006ec4 .word 0x30006ec4 30006e8c: 30006ea0 .word 0x30006ea0 30006e90: 30006ea0 .word 0x30006ea0 30006e94: 30006ea0 .word 0x30006ea0 30006e98: 30006ea0 .word 0x30006ea0 30006e9c: 30006ea0 .word 0x30006ea0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
30006ea0: eb002cc8 bl 300121c8 <__errno> 30006ea4: e3a03086 mov r3, #134 ; 0x86 30006ea8: e5803000 str r3, [r0]
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30006eac: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
30006eb0: e1a00006 mov r0, r6
30006eb4: e28dd004 add sp, sp, #4
30006eb8: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
30006ebc: e28dd00c add sp, sp, #12
30006ec0: e12fff1e bx lr
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
30006ec4: e5930000 ldr r0, [r3] 30006ec8: eb000181 bl 300074d4 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
30006ecc: e5952014 ldr r2, [r5, #20] 30006ed0: e59f3134 ldr r3, [pc, #308] ; 3000700c <fcntl+0x1e4> 30006ed4: e3c22c02 bic r2, r2, #512 ; 0x200 30006ed8: e0003003 and r3, r0, r3 30006edc: e3c22001 bic r2, r2, #1 30006ee0: e1833002 orr r3, r3, r2 30006ee4: e5853014 str r3, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30006ee8: e3a06000 mov r6, #0
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
30006eec: e1a00004 mov r0, r4 30006ef0: e5953020 ldr r3, [r5, #32] 30006ef4: e1a01005 mov r1, r5 30006ef8: e1a0e00f mov lr, pc 30006efc: e593f030 ldr pc, [r3, #48] ; 0x30
if (err) {
30006f00: e2504000 subs r4, r0, #0
30006f04: 0affffe9 beq 30006eb0 <fcntl+0x88>
errno = err;
30006f08: eb002cae bl 300121c8 <__errno> <== NOT EXECUTED
ret = -1;
30006f0c: e3e06000 mvn r6, #0 <== NOT EXECUTED
*/
if (ret >= 0) {
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
if (err) {
errno = err;
30006f10: e5804000 str r4, [r0] <== NOT EXECUTED 30006f14: eaffffe5 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
30006f18: eb002caa bl 300121c8 <__errno> 30006f1c: e3a03016 mov r3, #22 30006f20: e5803000 str r3, [r0] 30006f24: eaffffe0 b 30006eac <fcntl+0x84>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
30006f28: e593a000 ldr sl, [r3] <== NOT EXECUTED
if ( fd2 )
30006f2c: e35a0000 cmp sl, #0 <== NOT EXECUTED 30006f30: 0a00002c beq 30006fe8 <fcntl+0x1c0> <== NOT EXECUTED
diop = rtems_libio_iop( fd2 );
30006f34: e152000a cmp r2, sl <== NOT EXECUTED 30006f38: 806aa18a rsbhi sl, sl, sl, lsl #3 <== NOT EXECUTED 30006f3c: 8086a18a addhi sl, r6, sl, lsl #3 <== NOT EXECUTED 30006f40: 81a0900a movhi r9, sl <== NOT EXECUTED 30006f44: 93a09000 movls r9, #0 <== NOT EXECUTED 30006f48: 91a0a009 movls sl, r9 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f4c: e28a8018 add r8, sl, #24 <== NOT EXECUTED
30006f50: e2857018 add r7, r5, #24 <== NOT EXECUTED
30006f54: e8b7000f ldm r7!, {r0, r1, r2, r3} <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f58: e0666009 rsb r6, r6, r9 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f5c: e8a8000f stmia r8!, {r0, r1, r2, r3} <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f60: e1a061c6 asr r6, r6, #3 <== NOT EXECUTED 30006f64: e0863186 add r3, r6, r6, lsl #3 <== NOT EXECUTED 30006f68: e0833303 add r3, r3, r3, lsl #6 <== NOT EXECUTED 30006f6c: e0863183 add r3, r6, r3, lsl #3 <== NOT EXECUTED
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
30006f70: e5972000 ldr r2, [r7] <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f74: e0833783 add r3, r3, r3, lsl #15 <== NOT EXECUTED 30006f78: e0866183 add r6, r6, r3, lsl #3 <== NOT EXECUTED
ret = -1;
break;
}
}
diop->flags = iop->flags;
30006f7c: e58ac014 str ip, [sl, #20] <== NOT EXECUTED
diop->pathinfo = iop->pathinfo;
30006f80: e5882000 str r2, [r8] <== NOT EXECUTED
ret = (int) (diop - rtems_libio_iops);
30006f84: e2666000 rsb r6, r6, #0 <== NOT EXECUTED 30006f88: ea00000e b 30006fc8 <fcntl+0x1a0> <== NOT EXECUTED
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
30006f8c: e31c0b02 tst ip, #2048 ; 0x800 30006f90: 03a06000 moveq r6, #0 30006f94: 13a06001 movne r6, #1 30006f98: eaffffd3 b 30006eec <fcntl+0xc4>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
30006f9c: e5936000 ldr r6, [r3] 30006fa0: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fa4: 138ccb02 orrne ip, ip, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fa8: 03cccb02 biceq ip, ip, #2048 ; 0x800
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fac: 1585c014 strne ip, [r5, #20]
rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0;
30006fb0: 13a06000 movne r6, #0
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
30006fb4: 0585c014 streq ip, [r5, #20] 30006fb8: eaffffcb b 30006eec <fcntl+0xc4>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
30006fbc: e1a0000c mov r0, ip 30006fc0: eb000150 bl 30007508 <rtems_libio_to_fcntl_flags> 30006fc4: e1a06000 mov r6, r0
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
30006fc8: e3560000 cmp r6, #0
30006fcc: aaffffc6 bge 30006eec <fcntl+0xc4>
30006fd0: eaffffb6 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30006fd4: eb002c7b bl 300121c8 <__errno> <== NOT EXECUTED 30006fd8: e3a03009 mov r3, #9 <== NOT EXECUTED 30006fdc: e5803000 str r3, [r0] <== NOT EXECUTED 30006fe0: e3e06000 mvn r6, #0 <== NOT EXECUTED 30006fe4: eaffffb1 b 30006eb0 <fcntl+0x88> <== NOT EXECUTED
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
30006fe8: eb000159 bl 30007554 <rtems_libio_allocate> <== NOT EXECUTED
if ( diop == 0 ) {
30006fec: e250a000 subs sl, r0, #0 <== NOT EXECUTED 30006ff0: 0affffad beq 30006eac <fcntl+0x84> <== NOT EXECUTED 30006ff4: e595c014 ldr ip, [r5, #20] <== NOT EXECUTED 30006ff8: e1a0900a mov r9, sl <== NOT EXECUTED 30006ffc: e5976000 ldr r6, [r7] <== NOT EXECUTED 30007000: eaffffd1 b 30006f4c <fcntl+0x124> <== NOT EXECUTED
30007020 <fdatasync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007020: e59f3068 ldr r3, [pc, #104] ; 30007090 <fdatasync+0x70> <== NOT EXECUTED
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
30007024: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007028: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000702c: e1500003 cmp r0, r3 <== NOT EXECUTED 30007030: 2a00000c bcs 30007068 <fdatasync+0x48> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
30007034: e59f3058 ldr r3, [pc, #88] ; 30007094 <fdatasync+0x74> <== NOT EXECUTED 30007038: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000703c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007040: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
30007044: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007048: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000704c: 0a000005 beq 30007068 <fdatasync+0x48> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007050: e3130004 tst r3, #4 <== NOT EXECUTED 30007054: 0a000008 beq 3000707c <fdatasync+0x5c> <== NOT EXECUTED
/*
* Now process the fdatasync().
*/
return (*iop->pathinfo.handlers->fdatasync_h)( iop );
30007058: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 3000705c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007060: e593f02c ldr pc, [r3, #44] ; 0x2c <== NOT EXECUTED
}
30007064: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007068: eb002c56 bl 300121c8 <__errno> <== NOT EXECUTED
3000706c: e3a03009 mov r3, #9 <== NOT EXECUTED
30007070: e5803000 str r3, [r0] <== NOT EXECUTED
30007074: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007078: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000707c: eb002c51 bl 300121c8 <__errno> <== NOT EXECUTED
30007080: e3a03016 mov r3, #22 <== NOT EXECUTED
30007084: e5803000 str r3, [r0] <== NOT EXECUTED
30007088: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000708c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30010674 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010674: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
30010678: e59f541c ldr r5, [pc, #1052] ; 30010a9c <fifo_open+0x428> <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3001067c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
30010680: e5958000 ldr r8, [r5] <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
30010684: e1a04000 mov r4, r0 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
30010688: e3580000 cmp r8, #0 <== NOT EXECUTED
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3001068c: e1a06001 mov r6, r1 <== NOT EXECUTED
static rtems_status_code pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
30010690: 0a000024 beq 30010728 <fifo_open+0xb4> <== NOT EXECUTED
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30010694: e3a01000 mov r1, #0 <== NOT EXECUTED 30010698: e1a00008 mov r0, r8 <== NOT EXECUTED 3001069c: e1a02001 mov r2, r1 <== NOT EXECUTED 300106a0: ebffed9d bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED
}
if (sc == RTEMS_SUCCESSFUL) {
300106a4: e250a000 subs sl, r0, #0 <== NOT EXECUTED 300106a8: 1a0000d0 bne 300109f0 <fifo_open+0x37c> <== NOT EXECUTED
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
300106ac: e5945000 ldr r5, [r4] <== NOT EXECUTED
if (pipe == NULL) {
300106b0: e3550000 cmp r5, #0 <== NOT EXECUTED 300106b4: 0a00007f beq 300108b8 <fifo_open+0x244> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
300106b8: e3a01000 mov r1, #0 <== NOT EXECUTED 300106bc: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 300106c0: e1a02001 mov r2, r1 <== NOT EXECUTED 300106c4: ebffed94 bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
300106c8: e5943000 ldr r3, [r4] <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
300106cc: e3500000 cmp r0, #0 <== NOT EXECUTED 300106d0: 01a07000 moveq r7, r0 <== NOT EXECUTED 300106d4: 13e07003 mvnne r7, #3 <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
300106d8: e3530000 cmp r3, #0 <== NOT EXECUTED 300106dc: 0a0000b3 beq 300109b0 <fifo_open+0x33c> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
300106e0: ebffffa9 bl 3001058c <pipe_unlock> <== NOT EXECUTED
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
300106e4: e3570000 cmp r7, #0 <== NOT EXECUTED 300106e8: 1a00000b bne 3001071c <fifo_open+0xa8> <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
300106ec: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
300106f0: e5945000 ldr r5, [r4] <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
300106f4: e2033006 and r3, r3, #6 <== NOT EXECUTED 300106f8: e3530004 cmp r3, #4 <== NOT EXECUTED 300106fc: 0a000015 beq 30010758 <fifo_open+0xe4> <== NOT EXECUTED 30010700: e3530006 cmp r3, #6 <== NOT EXECUTED 30010704: 0a000057 beq 30010868 <fifo_open+0x1f4> <== NOT EXECUTED 30010708: e3530002 cmp r3, #2 <== NOT EXECUTED 3001070c: 0a000035 beq 300107e8 <fifo_open+0x174> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
30010710: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010714: ebffedc9 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
30010718: e3a07000 mov r7, #0 <== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
return err;
}
3001071c: e1a00007 mov r0, r7 <== NOT EXECUTED
30010720: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010724: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
30010728: e59f7370 ldr r7, [pc, #880] ; 30010aa0 <fifo_open+0x42c> <== NOT EXECUTED 3001072c: e1a01008 mov r1, r8 <== NOT EXECUTED 30010730: e5970000 ldr r0, [r7] <== NOT EXECUTED 30010734: e1a02008 mov r2, r8 <== NOT EXECUTED 30010738: ebffed77 bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
3001073c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30010740: e3530000 cmp r3, #0 <== NOT EXECUTED 30010744: 0a00009e beq 300109c4 <fifo_open+0x350> <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30010748: e5970000 ldr r0, [r7] <== NOT EXECUTED 3001074c: ebffedbb bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED 30010750: e5958000 ldr r8, [r5] <== NOT EXECUTED 30010754: eaffffce b 30010694 <fifo_open+0x20> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
30010758: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3001075c: e5951024 ldr r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010760: e2832001 add r2, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
30010764: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010768: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
3001076c: e5851024 str r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010770: e5852014 str r2, [r5, #20] <== NOT EXECUTED 30010774: 0a00009f beq 300109f8 <fifo_open+0x384> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
30010778: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 3001077c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010780: 1affffe2 bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED 30010784: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 30010788: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
3001078c: 05957020 ldreq r7, [r5, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
30010790: 0a000007 beq 300107b4 <fifo_open+0x140> <== NOT EXECUTED 30010794: ea0000af b 30010a58 <fifo_open+0x3e4> <== NOT EXECUTED
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
30010798: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 3001079c: ebffed5e bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 300107a0: e3500000 cmp r0, #0 <== NOT EXECUTED 300107a4: 1a00000a bne 300107d4 <fifo_open+0x160> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
300107a8: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 300107ac: e1530007 cmp r3, r7 <== NOT EXECUTED 300107b0: 1affffd6 bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
300107b4: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 300107b8: ebffeda0 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
300107bc: e3a01000 mov r1, #0 <== NOT EXECUTED 300107c0: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 300107c4: eb0004c3 bl 30011ad8 <rtems_barrier_wait> <== NOT EXECUTED 300107c8: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
300107cc: e1a02001 mov r2, r1 <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
300107d0: 0afffff0 beq 30010798 <fifo_open+0x124> <== NOT EXECUTED
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
300107d4: e3e07003 mvn r7, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
300107d8: e1a00004 mov r0, r4 <== NOT EXECUTED 300107dc: e1a01006 mov r1, r6 <== NOT EXECUTED 300107e0: ebffff6d bl 3001059c <pipe_release> <== NOT EXECUTED
return err;
300107e4: eaffffcc b 3001071c <fifo_open+0xa8> <== NOT EXECUTED
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
300107e8: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
300107ec: e5951020 ldr r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
300107f0: e2832001 add r2, r3, #1 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
300107f4: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
300107f8: e3530000 cmp r3, #0 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
300107fc: e5851020 str r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010800: e5852010 str r2, [r5, #16] <== NOT EXECUTED 30010804: 0a000083 beq 30010a18 <fifo_open+0x3a4> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
30010808: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3001080c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010810: 1affffbe bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED
/* Not an error */
if (LIBIO_NODELAY(iop))
30010814: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 30010818: e3130001 tst r3, #1 <== NOT EXECUTED 3001081c: 1affffbb bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED
break;
prevCounter = pipe->writerCounter;
30010820: e5957024 ldr r7, [r5, #36] ; 0x24 <== NOT EXECUTED 30010824: ea000006 b 30010844 <fifo_open+0x1d0> <== NOT EXECUTED
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
30010828: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 3001082c: ebffed3a bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010830: e3500000 cmp r0, #0 <== NOT EXECUTED 30010834: 1affffe6 bne 300107d4 <fifo_open+0x160> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
30010838: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 3001083c: e1530007 cmp r3, r7 <== NOT EXECUTED 30010840: 1affffb2 bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
30010844: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010848: ebffed7c bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
3001084c: e3a01000 mov r1, #0 <== NOT EXECUTED 30010850: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010854: eb00049f bl 30011ad8 <rtems_barrier_wait> <== NOT EXECUTED 30010858: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
3001085c: e1a02001 mov r2, r1 <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010860: 0afffff0 beq 30010828 <fifo_open+0x1b4> <== NOT EXECUTED 30010864: eaffffda b 300107d4 <fifo_open+0x160> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
30010868: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3001086c: e5951020 ldr r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010870: e2832001 add r2, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
30010874: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010878: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
3001087c: e5851020 str r1, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
30010880: e5852010 str r2, [r5, #16] <== NOT EXECUTED 30010884: 0a00005f beq 30010a08 <fifo_open+0x394> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
30010888: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
3001088c: e5951024 ldr r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010890: e2832001 add r2, r3, #1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
30010894: e2811001 add r1, r1, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
30010898: e3530000 cmp r3, #0 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
3001089c: e5851024 str r1, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
300108a0: e5852014 str r2, [r5, #20] <== NOT EXECUTED 300108a4: 1affff99 bne 30010710 <fifo_open+0x9c> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
300108a8: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 300108ac: e28d1004 add r1, sp, #4 <== NOT EXECUTED 300108b0: eb000470 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 300108b4: eaffff95 b 30010710 <fifo_open+0x9c> <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
300108b8: e3a00034 mov r0, #52 ; 0x34 <== NOT EXECUTED 300108bc: ebffe005 bl 300088d8 <malloc> <== NOT EXECUTED
if (pipe == NULL)
300108c0: e3500000 cmp r0, #0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
300108c4: e1a05000 mov r5, r0 <== NOT EXECUTED 300108c8: e1a08000 mov r8, r0 <== NOT EXECUTED
if (pipe == NULL)
300108cc: 0a00006d beq 30010a88 <fifo_open+0x414> <== NOT EXECUTED
return err;
memset(pipe, 0, sizeof(pipe_control_t));
300108d0: e1a02000 mov r2, r0 <== NOT EXECUTED 300108d4: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108d8: e2822004 add r2, r2, #4 <== NOT EXECUTED 300108dc: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108e0: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108e4: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108e8: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108ec: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108f0: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108f4: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108f8: e482a004 str sl, [r2], #4 <== NOT EXECUTED 300108fc: e482a004 str sl, [r2], #4 <== NOT EXECUTED 30010900: e482a004 str sl, [r2], #4 <== NOT EXECUTED
pipe->Size = PIPE_BUF;
30010904: e3a03c02 mov r3, #512 ; 0x200 <== NOT EXECUTED
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
30010908: e582a000 str sl, [r2] <== NOT EXECUTED
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
3001090c: e1a00003 mov r0, r3 <== NOT EXECUTED
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
30010910: e5853004 str r3, [r5, #4] <== NOT EXECUTED
pipe->Buffer = malloc(pipe->Size);
30010914: ebffdfef bl 300088d8 <malloc> <== NOT EXECUTED
if (! pipe->Buffer)
30010918: e3500000 cmp r0, #0 <== NOT EXECUTED
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
3001091c: e5850000 str r0, [r5] <== NOT EXECUTED
if (! pipe->Buffer)
30010920: 0a000056 beq 30010a80 <fifo_open+0x40c> <== NOT EXECUTED
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
30010924: e59f7178 ldr r7, [pc, #376] ; 30010aa4 <fifo_open+0x430> <== NOT EXECUTED
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
30010928: e59f0178 ldr r0, [pc, #376] ; 30010aa8 <fifo_open+0x434> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'r', c),
3001092c: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
30010930: e1a0100a mov r1, sl <== NOT EXECUTED 30010934: e1830000 orr r0, r3, r0 <== NOT EXECUTED 30010938: e1a0200a mov r2, sl <== NOT EXECUTED 3001093c: e285302c add r3, r5, #44 ; 0x2c <== NOT EXECUTED 30010940: eb0003ee bl 30011900 <rtems_barrier_create> <== NOT EXECUTED 30010944: e2501000 subs r1, r0, #0 <== NOT EXECUTED 30010948: 1a00004a bne 30010a78 <fifo_open+0x404> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
3001094c: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
30010950: e59f0154 ldr r0, [pc, #340] ; 30010aac <fifo_open+0x438> <== NOT EXECUTED 30010954: e1a02001 mov r2, r1 <== NOT EXECUTED 30010958: e1830000 orr r0, r3, r0 <== NOT EXECUTED 3001095c: e2853030 add r3, r5, #48 ; 0x30 <== NOT EXECUTED 30010960: eb0003e6 bl 30011900 <rtems_barrier_create> <== NOT EXECUTED 30010964: e2503000 subs r3, r0, #0 <== NOT EXECUTED 30010968: 1a000040 bne 30010a70 <fifo_open+0x3fc> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
rtems_build_name ('P', 'I', 's', c), 1,
3001096c: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
30010970: e59f0138 ldr r0, [pc, #312] ; 30010ab0 <fifo_open+0x43c> <== NOT EXECUTED 30010974: e285c028 add ip, r5, #40 ; 0x28 <== NOT EXECUTED 30010978: e1820000 orr r0, r2, r0 <== NOT EXECUTED 3001097c: e3a01001 mov r1, #1 <== NOT EXECUTED 30010980: e3a02010 mov r2, #16 <== NOT EXECUTED 30010984: e58dc000 str ip, [sp] <== NOT EXECUTED 30010988: ebffec49 bl 3000bab4 <rtems_semaphore_create> <== NOT EXECUTED 3001098c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010990: 1a000034 bne 30010a68 <fifo_open+0x3f4> <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
30010994: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 30010998: e353007a cmp r3, #122 ; 0x7a <== NOT EXECUTED 3001099c: e2832001 add r2, r3, #1 <== NOT EXECUTED
c = 'a';
300109a0: 03a03061 moveq r3, #97 ; 0x61 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
300109a4: e5c72000 strb r2, [r7] <== NOT EXECUTED
c = 'a';
300109a8: 05c73000 strbeq r3, [r7] <== NOT EXECUTED 300109ac: eaffff41 b 300106b8 <fifo_open+0x44> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
300109b0: e3570000 cmp r7, #0 <== NOT EXECUTED 300109b4: 1a00001b bne 30010a28 <fifo_open+0x3b4> <== NOT EXECUTED
pipe_free(pipe);
else
*pipep = pipe;
300109b8: e5845000 str r5, [r4] <== NOT EXECUTED
}
out:
pipe_unlock();
300109bc: ebfffef2 bl 3001058c <pipe_unlock> <== NOT EXECUTED 300109c0: eaffff49 b 300106ec <fifo_open+0x78> <== NOT EXECUTED
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
sc = rtems_semaphore_create(
300109c4: e1a03008 mov r3, r8 <== NOT EXECUTED 300109c8: e3a01001 mov r1, #1 <== NOT EXECUTED 300109cc: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 300109d0: e59f00dc ldr r0, [pc, #220] ; 30010ab4 <fifo_open+0x440> <== NOT EXECUTED 300109d4: e58d5000 str r5, [sp] <== NOT EXECUTED 300109d8: ebffec35 bl 3000bab4 <rtems_semaphore_create> <== NOT EXECUTED 300109dc: e1a08000 mov r8, r0 <== NOT EXECUTED 300109e0: e5970000 ldr r0, [r7] <== NOT EXECUTED 300109e4: ebffed15 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
300109e8: e3580000 cmp r8, #0 <== NOT EXECUTED 300109ec: 0a000028 beq 30010a94 <fifo_open+0x420> <== NOT EXECUTED
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
300109f0: e3e0700b mvn r7, #11 <== NOT EXECUTED 300109f4: eaffff48 b 3001071c <fifo_open+0xa8> <== NOT EXECUTED
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
300109f8: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 300109fc: e28d1004 add r1, sp, #4 <== NOT EXECUTED 30010a00: eb00041c bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010a04: eaffff5b b 30010778 <fifo_open+0x104> <== NOT EXECUTED
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
30010a08: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010a0c: e28d1004 add r1, sp, #4 <== NOT EXECUTED 30010a10: eb000418 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010a14: eaffff9b b 30010888 <fifo_open+0x214> <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
30010a18: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010a1c: e28d1004 add r1, sp, #4 <== NOT EXECUTED 30010a20: eb000414 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010a24: eaffff77 b 30010808 <fifo_open+0x194> <== NOT EXECUTED
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
30010a28: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010a2c: eb0003e5 bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
30010a30: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010a34: eb0003e3 bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
30010a38: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010a3c: ebffec8d bl 3000bc78 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
30010a40: e5950000 ldr r0, [r5] <== NOT EXECUTED 30010a44: ebffdd93 bl 30008098 <free> <== NOT EXECUTED
free(pipe);
30010a48: e1a00005 mov r0, r5 <== NOT EXECUTED 30010a4c: ebffdd91 bl 30008098 <free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
30010a50: ebfffecd bl 3001058c <pipe_unlock> <== NOT EXECUTED 30010a54: eaffff30 b 3001071c <fifo_open+0xa8> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
30010a58: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010a5c: ebffecf7 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
err = -ENXIO;
30010a60: e3e07005 mvn r7, #5 <== NOT EXECUTED
goto out_error;
30010a64: eaffff5b b 300107d8 <fifo_open+0x164> <== NOT EXECUTED
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
30010a68: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010a6c: eb0003d5 bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
err_wbar: rtems_barrier_delete(pipe->readBarrier);
30010a70: e598002c ldr r0, [r8, #44] ; 0x2c <== NOT EXECUTED 30010a74: eb0003d3 bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
err_rbar: free(pipe->Buffer);
30010a78: e5980000 ldr r0, [r8] <== NOT EXECUTED 30010a7c: ebffdd85 bl 30008098 <free> <== NOT EXECUTED
err_buf: free(pipe);
30010a80: e1a00008 mov r0, r8 <== NOT EXECUTED 30010a84: ebffdd83 bl 30008098 <free> <== NOT EXECUTED
)
{
pipe_control_t *pipe;
int err = 0;
err = pipe_lock();
30010a88: e3e0700b mvn r7, #11 <== NOT EXECUTED
else
*pipep = pipe;
}
out:
pipe_unlock();
30010a8c: ebfffebe bl 3001058c <pipe_unlock> <== NOT EXECUTED 30010a90: eaffff21 b 3001071c <fifo_open+0xa8> <== NOT EXECUTED
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
30010a94: e5958000 ldr r8, [r5] <== NOT EXECUTED 30010a98: eafffefd b 30010694 <fifo_open+0x20> <== NOT EXECUTED
3000655c <flockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void flockfile(FILE* file)
{
}
3000655c: e12fff1e bx lr <== NOT EXECUTED
30007098 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
30007098: e59f310c ldr r3, [pc, #268] ; 300071ac <fpathconf+0x114> <== NOT EXECUTED
long fpathconf(
int fd,
int name
)
{
3000709c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
300070a0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300070a4: e1500003 cmp r0, r3 <== NOT EXECUTED 300070a8: 2a000035 bcs 30007184 <fpathconf+0xec> <== NOT EXECUTED
iop = rtems_libio_iop(fd);
300070ac: e59f30fc ldr r3, [pc, #252] ; 300071b0 <fpathconf+0x118> <== NOT EXECUTED 300070b0: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300070b4: e5933000 ldr r3, [r3] <== NOT EXECUTED 300070b8: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
300070bc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 300070c0: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300070c4: 0a00002e beq 30007184 <fpathconf+0xec> <== NOT EXECUTED
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
300070c8: e3130002 tst r3, #2 <== NOT EXECUTED 300070cc: 0a000031 beq 30007198 <fpathconf+0x100> <== NOT EXECUTED
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
300070d0: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
switch ( name ) {
300070d4: e351000b cmp r1, #11 <== NOT EXECUTED 300070d8: 979ff101 ldrls pc, [pc, r1, lsl #2] <== NOT EXECUTED 300070dc: ea00000d b 30007118 <fpathconf+0x80> <== NOT EXECUTED 300070e0: 3000712c .word 0x3000712c <== NOT EXECUTED 300070e4: 30007134 .word 0x30007134 <== NOT EXECUTED 300070e8: 3000713c .word 0x3000713c <== NOT EXECUTED 300070ec: 30007144 .word 0x30007144 <== NOT EXECUTED 300070f0: 3000714c .word 0x3000714c <== NOT EXECUTED 300070f4: 30007154 .word 0x30007154 <== NOT EXECUTED 300070f8: 3000715c .word 0x3000715c <== NOT EXECUTED 300070fc: 30007164 .word 0x30007164 <== NOT EXECUTED 30007100: 3000716c .word 0x3000716c <== NOT EXECUTED 30007104: 30007174 .word 0x30007174 <== NOT EXECUTED 30007108: 3000717c .word 0x3000717c <== NOT EXECUTED 3000710c: 30007110 .word 0x30007110 <== NOT EXECUTED
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
30007110: e5930060 ldr r0, [r3, #96] ; 0x60 <== NOT EXECUTED
break;
30007114: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
30007118: eb002c2a bl 300121c8 <__errno> <== NOT EXECUTED 3000711c: e3a03016 mov r3, #22 <== NOT EXECUTED 30007120: e5803000 str r3, [r0] <== NOT EXECUTED 30007124: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return return_value;
}
30007128: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
3000712c: e5930038 ldr r0, [r3, #56] ; 0x38 <== NOT EXECUTED
break;
30007130: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
30007134: e593003c ldr r0, [r3, #60] ; 0x3c <== NOT EXECUTED
break;
30007138: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
3000713c: e5930040 ldr r0, [r3, #64] ; 0x40 <== NOT EXECUTED
break;
30007140: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
30007144: e5930044 ldr r0, [r3, #68] ; 0x44 <== NOT EXECUTED
break;
30007148: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
3000714c: e5930048 ldr r0, [r3, #72] ; 0x48 <== NOT EXECUTED
break;
30007150: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
30007154: e593004c ldr r0, [r3, #76] ; 0x4c <== NOT EXECUTED
break;
30007158: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
3000715c: e5930054 ldr r0, [r3, #84] ; 0x54 <== NOT EXECUTED
break;
30007160: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
30007164: e5930058 ldr r0, [r3, #88] ; 0x58 <== NOT EXECUTED
break;
30007168: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
3000716c: e5930064 ldr r0, [r3, #100] ; 0x64 <== NOT EXECUTED
break;
30007170: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
30007174: e5930050 ldr r0, [r3, #80] ; 0x50 <== NOT EXECUTED
break;
30007178: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
3000717c: e593005c ldr r0, [r3, #92] ; 0x5c <== NOT EXECUTED
break;
30007180: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
30007184: eb002c0f bl 300121c8 <__errno> <== NOT EXECUTED
30007188: e3a03009 mov r3, #9 <== NOT EXECUTED
3000718c: e5803000 str r3, [r0] <== NOT EXECUTED
30007190: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007194: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ);
30007198: eb002c0a bl 300121c8 <__errno> <== NOT EXECUTED
3000719c: e3a03016 mov r3, #22 <== NOT EXECUTED
300071a0: e5803000 str r3, [r0] <== NOT EXECUTED
300071a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300071a8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006498 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
30006498: e59f3088 ldr r3, [pc, #136] ; 30006528 <free+0x90>
#include <stdlib.h>
void free(
void *ptr
)
{
3000649c: e92d4030 push {r4, r5, lr}
MSBUMP(free_calls, 1);
300064a0: e593200c ldr r2, [r3, #12]
if ( !ptr )
300064a4: e2504000 subs r4, r0, #0
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
300064a8: e2822001 add r2, r2, #1 300064ac: e583200c str r2, [r3, #12]
if ( !ptr )
300064b0: 08bd8030 popeq {r4, r5, pc}
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
300064b4: e59f3070 ldr r3, [pc, #112] ; 3000652c <free+0x94> 300064b8: e5933000 ldr r3, [r3] 300064bc: e3530003 cmp r3, #3
300064c0: 0a000012 beq 30006510 <free+0x78>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
300064c4: e59f3064 ldr r3, [pc, #100] ; 30006530 <free+0x98> 300064c8: e5933000 ldr r3, [r3] 300064cc: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_free)(ptr);
300064d0: 11a00004 movne r0, r4 300064d4: 11a0e00f movne lr, pc 300064d8: 1593f008 ldrne pc, [r3, #8]
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
300064dc: e59f5050 ldr r5, [pc, #80] ; 30006534 <free+0x9c>
300064e0: e1a01004 mov r1, r4
300064e4: e5950000 ldr r0, [r5]
300064e8: eb001455 bl 3000b644 <_Protected_heap_Free>
300064ec: e3500000 cmp r0, #0
300064f0: 18bd8030 popne {r4, r5, pc}
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
300064f4: e5953000 ldr r3, [r5]
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
300064f8: e59f0038 ldr r0, [pc, #56] ; 30006538 <free+0xa0> 300064fc: e5932018 ldr r2, [r3, #24] 30006500: e593301c ldr r3, [r3, #28] 30006504: e1a01004 mov r1, r4
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
30006508: e8bd4030 pop {r4, r5, lr}
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
3000650c: ea00037b b 30007300 <printk>
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
30006510: eb00005e bl 30006690 <malloc_is_system_state_OK>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30006514: e3500000 cmp r0, #0
30006518: 1affffe9 bne 300064c4 <free+0x2c>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
3000651c: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
30006520: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
30006524: ea000076 b 30006704 <malloc_deferred_free> <== NOT EXECUTED
30007ba0 <free_user_env>:
static void
free_user_env(void *venv)
{
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007ba0: e59f3028 ldr r3, [pc, #40] ; 30007bd0 <free_user_env+0x30> <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
30007ba4: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007ba8: e1500003 cmp r0, r3 <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
30007bac: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
30007bb0: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
30007bb4: e2800004 add r0, r0, #4 <== NOT EXECUTED 30007bb8: ebfffb7e bl 300069b8 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
30007bbc: e2840018 add r0, r4, #24 <== NOT EXECUTED 30007bc0: ebfffb7c bl 300069b8 <rtems_filesystem_freenode> <== NOT EXECUTED
free(env);
30007bc4: e1a00004 mov r0, r4 <== NOT EXECUTED
} }
30007bc8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
30007bcc: eafffb7e b 300069cc <free> <== NOT EXECUTED
30016754 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
30016754: e92d4030 push {r4, r5, lr}
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
30016758: e2514000 subs r4, r1, #0
3001675c: 0a000019 beq 300167c8 <fstat+0x74>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
30016760: e59f3074 ldr r3, [pc, #116] ; 300167dc <fstat+0x88> 30016764: e5933000 ldr r3, [r3] 30016768: e1500003 cmp r0, r3
3001676c: 2a000010 bcs 300167b4 <fstat+0x60>
30016770: e59f3068 ldr r3, [pc, #104] ; 300167e0 <fstat+0x8c> 30016774: e0600180 rsb r0, r0, r0, lsl #3 30016778: e5933000 ldr r3, [r3] 3001677c: e0835180 add r5, r3, r0, lsl #3
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
30016780: e5953014 ldr r3, [r5, #20] 30016784: e3130c01 tst r3, #256 ; 0x100
30016788: 0a000009 beq 300167b4 <fstat+0x60>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
3001678c: e1a00004 mov r0, r4 30016790: e3a01000 mov r1, #0 30016794: e3a02048 mov r2, #72 ; 0x48 30016798: ebffecc7 bl 30011abc <memset>
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
3001679c: e5953020 ldr r3, [r5, #32] 300167a0: e2850018 add r0, r5, #24 300167a4: e1a01004 mov r1, r4 300167a8: e1a0e00f mov lr, pc 300167ac: e593f018 ldr pc, [r3, #24]
}
300167b0: e8bd8030 pop {r4, r5, pc}
/* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
300167b4: ebffea5b bl 30011128 <__errno> <== NOT EXECUTED
300167b8: e3a03009 mov r3, #9 <== NOT EXECUTED
300167bc: e5803000 str r3, [r0] <== NOT EXECUTED
300167c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300167c4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
300167c8: ebffea56 bl 30011128 <__errno> <== NOT EXECUTED
300167cc: e3a0300e mov r3, #14 <== NOT EXECUTED
300167d0: e5803000 str r3, [r0] <== NOT EXECUTED
300167d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300167d8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007308 <fsync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007308: e59f3068 ldr r3, [pc, #104] ; 30007378 <fsync+0x70> <== NOT EXECUTED
#include <rtems/seterr.h>
int fsync(
int fd
)
{
3000730c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30007310: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007314: e1500003 cmp r0, r3 <== NOT EXECUTED 30007318: 2a00000c bcs 30007350 <fsync+0x48> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000731c: e59f3058 ldr r3, [pc, #88] ; 3000737c <fsync+0x74> <== NOT EXECUTED 30007320: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 30007324: e5933000 ldr r3, [r3] <== NOT EXECUTED 30007328: e0830180 add r0, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
3000732c: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 30007330: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007334: 0a000005 beq 30007350 <fsync+0x48> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007338: e3130004 tst r3, #4 <== NOT EXECUTED 3000733c: 0a000008 beq 30007364 <fsync+0x5c> <== NOT EXECUTED
/*
* Now process the fsync().
*/
return (*iop->pathinfo.handlers->fsync_h)( iop );
30007340: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 30007344: e1a0e00f mov lr, pc <== NOT EXECUTED 30007348: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
}
3000734c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
30007350: eb002b9c bl 300121c8 <__errno> <== NOT EXECUTED
30007354: e3a03009 mov r3, #9 <== NOT EXECUTED
30007358: e5803000 str r3, [r0] <== NOT EXECUTED
3000735c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007360: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30007364: eb002b97 bl 300121c8 <__errno> <== NOT EXECUTED
30007368: e3a03016 mov r3, #22 <== NOT EXECUTED
3000736c: e5803000 str r3, [r0] <== NOT EXECUTED
30007370: e3e00000 mvn r0, #0 <== NOT EXECUTED
30007374: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000e4dc <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
3000e4dc: e92d4070 push {r4, r5, r6, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e4e0: e59f30c8 ldr r3, [pc, #200] ; 3000e5b0 <ftruncate+0xd4>
int ftruncate(
int fd,
off_t length
)
{
3000e4e4: e24dd014 sub sp, sp, #20
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e4e8: e5933000 ldr r3, [r3]
int ftruncate(
int fd,
off_t length
)
{
3000e4ec: e1a05001 mov r5, r1
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e4f0: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
3000e4f4: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
3000e4f8: 2a00001d bcs 3000e574 <ftruncate+0x98>
iop = rtems_libio_iop( fd );
3000e4fc: e59f30b0 ldr r3, [pc, #176] ; 3000e5b4 <ftruncate+0xd8> 3000e500: e0600180 rsb r0, r0, r0, lsl #3 3000e504: e5933000 ldr r3, [r3] 3000e508: e0834180 add r4, r3, r0, lsl #3
rtems_libio_check_is_open(iop);
3000e50c: e5943014 ldr r3, [r4, #20] 3000e510: e3130c01 tst r3, #256 ; 0x100
3000e514: 0a000016 beq 3000e574 <ftruncate+0x98>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000e518: e1a0c00d mov ip, sp
3000e51c: e284e018 add lr, r4, #24
3000e520: e8be000f ldm lr!, {r0, r1, r2, r3}
3000e524: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000e528: e59e3000 ldr r3, [lr]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000e52c: e1a0000d mov r0, sp
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
3000e530: e58c3000 str r3, [ip]
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
3000e534: e59d300c ldr r3, [sp, #12] 3000e538: e1a0e00f mov lr, pc 3000e53c: e593f010 ldr pc, [r3, #16] 3000e540: e3500001 cmp r0, #1
3000e544: 0a000014 beq 3000e59c <ftruncate+0xc0>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000e548: e5943014 ldr r3, [r4, #20] 3000e54c: e3130004 tst r3, #4
3000e550: 0a00000c beq 3000e588 <ftruncate+0xac>
return (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
3000e554: e5943020 ldr r3, [r4, #32] 3000e558: e1a00004 mov r0, r4 3000e55c: e1a01005 mov r1, r5 3000e560: e1a02006 mov r2, r6 3000e564: e1a0e00f mov lr, pc 3000e568: e593f020 ldr pc, [r3, #32]
}
3000e56c: e28dd014 add sp, sp, #20
3000e570: e8bd8070 pop {r4, r5, r6, pc}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3000e574: eb000aeb bl 30011128 <__errno> <== NOT EXECUTED 3000e578: e3a03009 mov r3, #9 <== NOT EXECUTED 3000e57c: e5803000 str r3, [r0] <== NOT EXECUTED 3000e580: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e584: eafffff8 b 3000e56c <ftruncate+0x90> <== NOT EXECUTED
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000e588: eb000ae6 bl 30011128 <__errno> <== NOT EXECUTED 3000e58c: e3a03016 mov r3, #22 <== NOT EXECUTED 3000e590: e5803000 str r3, [r0] <== NOT EXECUTED 3000e594: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e598: eafffff3 b 3000e56c <ftruncate+0x90> <== NOT EXECUTED
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
3000e59c: eb000ae1 bl 30011128 <__errno> <== NOT EXECUTED 3000e5a0: e3a03015 mov r3, #21 <== NOT EXECUTED 3000e5a4: e5803000 str r3, [r0] <== NOT EXECUTED 3000e5a8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000e5ac: eaffffee b 3000e56c <ftruncate+0x90> <== NOT EXECUTED
30006618 <ftrylockfile>:
#include <rtems/seterr.h>
#include <errno.h>
/* This is a non-functional stub */
int ftrylockfile(FILE* file)
{
30006618: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000661c: eb002ac6 bl 3001113c <__errno> <== NOT EXECUTED 30006620: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 30006624: e5803000 str r3, [r0] <== NOT EXECUTED
}
30006628: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000662c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006630 <funlockfile>:
#include <stdio.h>
/* This is a non-functional stub */
void funlockfile(FILE* file)
{
}
30006630: e12fff1e bx lr <== NOT EXECUTED
30006ae0 <getegid>:
* P1003.1b-1993, p. 84
*/
gid_t getegid( void )
{
return _POSIX_types_Egid;
30006ae0: e59f3008 ldr r3, [pc, #8] ; 30006af0 <getegid+0x10> <== NOT EXECUTED 30006ae4: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30006ae8: e1d303b8 ldrh r0, [r3, #56] ; 0x38 <== NOT EXECUTED 30006aec: e12fff1e bx lr <== NOT EXECUTED
30006af4 <geteuid>:
* P1003.1b-1993, p. 84
*/
uid_t geteuid( void )
{
return _POSIX_types_Euid;
30006af4: e59f3008 ldr r3, [pc, #8] ; 30006b04 <geteuid+0x10> <== NOT EXECUTED 30006af8: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30006afc: e1d303b6 ldrh r0, [r3, #54] ; 0x36 <== NOT EXECUTED 30006b00: e12fff1e bx lr <== NOT EXECUTED
30006b08 <getgid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
gid_t getgid( void )
{
return _POSIX_types_Gid;
30006b08: e59f3008 ldr r3, [pc, #8] ; 30006b18 <getgid+0x10> <== NOT EXECUTED 30006b0c: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30006b10: e1d303b4 ldrh r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30006b14: e12fff1e bx lr <== NOT EXECUTED
30007128 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
30007128: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000712c: e59d801c ldr r8, [sp, #28] <== NOT EXECUTED
30007130: e1a05000 mov r5, r0 <== NOT EXECUTED
30007134: e1a0a001 mov sl, r1 <== NOT EXECUTED
30007138: e1a04002 mov r4, r2 <== NOT EXECUTED
3000713c: e1a07003 mov r7, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
30007140: ebffffc0 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
30007144: e59f00b0 ldr r0, [pc, #176] ; 300071fc <getgr_r+0xd4> <== NOT EXECUTED 30007148: e59f10b0 ldr r1, [pc, #176] ; 30007200 <getgr_r+0xd8> <== NOT EXECUTED 3000714c: eb002e1f bl 300129d0 <fopen> <== NOT EXECUTED 30007150: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007154: 1a000006 bne 30007174 <getgr_r+0x4c> <== NOT EXECUTED 30007158: ea000022 b 300071e8 <getgr_r+0xc0> <== NOT EXECUTED
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
3000715c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30007160: eb0031cb bl 30013894 <strcmp> <== NOT EXECUTED 30007164: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30007168: 33a00000 movcc r0, #0 <== NOT EXECUTED
} else {
match = (grp->gr_gid == gid);
}
if (match) {
3000716c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007170: 1a00000f bne 300071b4 <getgr_r+0x8c> <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
30007174: e1a01004 mov r1, r4 <== NOT EXECUTED 30007178: e1a02007 mov r2, r7 <== NOT EXECUTED 3000717c: e1a03008 mov r3, r8 <== NOT EXECUTED 30007180: e1a00006 mov r0, r6 <== NOT EXECUTED 30007184: ebffff10 bl 30006dcc <scangr> <== NOT EXECUTED 30007188: e3500000 cmp r0, #0 <== NOT EXECUTED
goto error_einval;
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
3000718c: e1a01005 mov r1, r5 <== NOT EXECUTED
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scangr(fp, grp, buffer, bufsize))
30007190: 0a00000d beq 300071cc <getgr_r+0xa4> <== NOT EXECUTED
goto error_einval;
if (name) {
30007194: e3550000 cmp r5, #0 <== NOT EXECUTED 30007198: 1affffef bne 3000715c <getgr_r+0x34> <== NOT EXECUTED
match = (strcmp(grp->gr_name, name) == 0);
} else {
match = (grp->gr_gid == gid);
3000719c: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 300071a0: e150000a cmp r0, sl <== NOT EXECUTED 300071a4: 13a00000 movne r0, #0 <== NOT EXECUTED 300071a8: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
300071ac: e3500000 cmp r0, #0 <== NOT EXECUTED 300071b0: 0affffef beq 30007174 <getgr_r+0x4c> <== NOT EXECUTED
fclose(fp);
300071b4: e1a00006 mov r0, r6 <== NOT EXECUTED 300071b8: eb002c2d bl 30012274 <fclose> <== NOT EXECUTED
*result = grp;
300071bc: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
300071c0: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (grp->gr_gid == gid);
}
if (match) {
fclose(fp);
*result = grp;
300071c4: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
300071c8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
300071cc: e1a00006 mov r0, r6 <== NOT EXECUTED 300071d0: eb002c27 bl 30012274 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300071d4: eb002bd8 bl 3001213c <__errno> <== NOT EXECUTED 300071d8: e3a03016 mov r3, #22 <== NOT EXECUTED 300071dc: e5803000 str r3, [r0] <== NOT EXECUTED 300071e0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300071e4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/group", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
300071e8: eb002bd3 bl 3001213c <__errno> <== NOT EXECUTED
300071ec: e3a03016 mov r3, #22 <== NOT EXECUTED
300071f0: e5803000 str r3, [r0] <== NOT EXECUTED
300071f4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300071f8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
30007534 <getgrent>:
struct group *getgrent(void)
{
30007534: e92d4010 push {r4, lr} <== NOT EXECUTED
if (group_fp == NULL)
30007538: e59f4024 ldr r4, [pc, #36] ; 30007564 <getgrent+0x30> <== NOT EXECUTED
3000753c: e59401c4 ldr r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED
30007540: e3500000 cmp r0, #0 <== NOT EXECUTED
30007544: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
30007548: e28410ec add r1, r4, #236 ; 0xec <== NOT EXECUTED 3000754c: e28420fc add r2, r4, #252 ; 0xfc <== NOT EXECUTED 30007550: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007554: ebfffe1c bl 30006dcc <scangr> <== NOT EXECUTED
return NULL;
30007558: e3500000 cmp r0, #0 <== NOT EXECUTED 3000755c: 128400ec addne r0, r4, #236 ; 0xec <== NOT EXECUTED
return &grent; }
30007560: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300074f4 <getgrgid>:
struct group *getgrgid(
gid_t gid
)
{
300074f4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
300074f8: e59f1030 ldr r1, [pc, #48] ; 30007530 <getgrgid+0x3c> <== NOT EXECUTED
}
struct group *getgrgid(
gid_t gid
)
{
300074fc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30007500: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
30007504: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007508: e2812010 add r2, r1, #16 <== NOT EXECUTED 3000750c: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007510: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 30007514: e58dc000 str ip, [sp] <== NOT EXECUTED 30007518: ebffffe6 bl 300074b8 <getgrgid_r> <== NOT EXECUTED 3000751c: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
30007520: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
return NULL;
30007524: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007528: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000752c: e8bd8000 pop {pc} <== NOT EXECUTED
300074b8 <getgrgid_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300074b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300074bc: e1a0c002 mov ip, r2 <== NOT EXECUTED
300074c0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300074c4: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300074c8: e58d3000 str r3, [sp] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
300074cc: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
300074d0: e1a0300c mov r3, ip <== NOT EXECUTED 300074d4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 300074d8: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 300074dc: e1a0200e mov r2, lr <== NOT EXECUTED 300074e0: e3a00000 mov r0, #0 <== NOT EXECUTED 300074e4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 300074e8: ebffff0e bl 30007128 <getgr_r> <== NOT EXECUTED
}
300074ec: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300074f0: e8bd8000 pop {pc} <== NOT EXECUTED
30007480 <getgrnam>:
struct group *getgrnam(
const char *name
)
{
30007480: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
30007484: e59f1028 ldr r1, [pc, #40] ; 300074b4 <getgrnam+0x34> <== NOT EXECUTED
}
struct group *getgrnam(
const char *name
)
{
30007488: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
3000748c: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007490: e2812010 add r2, r1, #16 <== NOT EXECUTED 30007494: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 30007498: e58dc000 str ip, [sp] <== NOT EXECUTED 3000749c: ebffffea bl 3000744c <getgrnam_r> <== NOT EXECUTED 300074a0: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300074a4: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct group *p;
if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p))
return NULL;
300074a8: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300074ac: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300074b0: e8bd8000 pop {pc} <== NOT EXECUTED
3000744c <getgrnam_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
3000744c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007450: e1a0c002 mov ip, r2 <== NOT EXECUTED
30007454: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30007458: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(name, 0, grp, buffer, bufsize, result);
3000745c: e58d3000 str r3, [sp] <== NOT EXECUTED 30007460: e1a0300c mov r3, ip <== NOT EXECUTED 30007464: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 30007468: e3a01000 mov r1, #0 <== NOT EXECUTED 3000746c: e1a0200e mov r2, lr <== NOT EXECUTED 30007470: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 30007474: ebffff2b bl 30007128 <getgr_r> <== NOT EXECUTED
}
30007478: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000747c: e8bd8000 pop {pc} <== NOT EXECUTED
30006b1c <getgroups>:
int gidsetsize __attribute__((unused)),
gid_t grouplist[] __attribute__((unused))
)
{
return 0; /* no supplemental group ids */
}
30006b1c: e3a00000 mov r0, #0 <== NOT EXECUTED 30006b20: e12fff1e bx lr <== NOT EXECUTED
30006b70 <getlogin>:
* 4.2.4 Get User Name, P1003.1b-1993, p. 87
*
* NOTE: P1003.1c/D10, p. 49 adds getlogin_r().
*/
char *getlogin( void )
{
30006b70: e92d4010 push {r4, lr} <== NOT EXECUTED
(void) getlogin_r( _POSIX_types_Getlogin_buffer, LOGIN_NAME_MAX );
30006b74: e59f4018 ldr r4, [pc, #24] ; 30006b94 <getlogin+0x24> <== NOT EXECUTED 30006b78: e3a01009 mov r1, #9 <== NOT EXECUTED 30006b7c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30006b80: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED 30006b84: ebffffe6 bl 30006b24 <getlogin_r> <== NOT EXECUTED
return _POSIX_types_Getlogin_buffer;
30006b88: e5940000 ldr r0, [r4] <== NOT EXECUTED
}
30006b8c: e280003a add r0, r0, #58 ; 0x3a <== NOT EXECUTED
30006b90: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006b24 <getlogin_r>:
*/
int getlogin_r(
char *name,
size_t namesize
)
{
30006b24: e92d4010 push {r4, lr} <== NOT EXECUTED
struct passwd *pw;
char *pname;
if ( !name )
30006b28: e2504000 subs r4, r0, #0 <== NOT EXECUTED
return EFAULT;
30006b2c: 03a0000e moveq r0, #14 <== NOT EXECUTED
)
{
struct passwd *pw;
char *pname;
if ( !name )
30006b30: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return EFAULT;
if ( namesize < LOGIN_NAME_MAX )
30006b34: e3510008 cmp r1, #8 <== NOT EXECUTED 30006b38: 8a000001 bhi 30006b44 <getlogin_r+0x20> <== NOT EXECUTED
return ERANGE;
30006b3c: e3a00022 mov r0, #34 ; 0x22 <== NOT EXECUTED
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
return 0;
}
30006b40: e8bd8010 pop {r4, pc} <== NOT EXECUTED
return ERANGE;
/* Set the pointer to a default name */
pname = "";
pw = getpwuid(getuid());
30006b44: eb0002b9 bl 30007630 <getuid> <== NOT EXECUTED 30006b48: eb00020e bl 30007388 <getpwuid> <== NOT EXECUTED
if ( pw )
30006b4c: e3500000 cmp r0, #0 <== NOT EXECUTED
pname = pw->pw_name;
30006b50: 15901000 ldrne r1, [r0] <== NOT EXECUTED
if ( namesize < LOGIN_NAME_MAX )
return ERANGE;
/* Set the pointer to a default name */
pname = "";
30006b54: 059f1010 ldreq r1, [pc, #16] ; 30006b6c <getlogin_r+0x48> <== NOT EXECUTED
pw = getpwuid(getuid());
if ( pw )
pname = pw->pw_name;
strncpy( name, pname, LOGIN_NAME_MAX );
30006b58: e1a00004 mov r0, r4 <== NOT EXECUTED 30006b5c: e3a02009 mov r2, #9 <== NOT EXECUTED 30006b60: eb00343f bl 30013c64 <strncpy> <== NOT EXECUTED
return 0;
30006b64: e3a00000 mov r0, #0 <== NOT EXECUTED
30006b68: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006b98 <getpgrp>:
* This always succeeds and returns the process group id. For rtems,
* this will always be the local node;
*/
return _Objects_Local_node;
}
30006b98: e3a00001 mov r0, #1 <== NOT EXECUTED 30006b9c: e12fff1e bx lr <== NOT EXECUTED
30006bb4 <getppid>:
*
* 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83
*/
pid_t getppid( void )
{
30006bb4: e59f3004 ldr r3, [pc, #4] ; 30006bc0 <getppid+0xc> <== NOT EXECUTED
return _POSIX_types_Ppid; }
30006bb8: e5930000 ldr r0, [r3] <== NOT EXECUTED 30006bbc: e12fff1e bx lr <== NOT EXECUTED
30007204 <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007204: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
30007208: e59d801c ldr r8, [sp, #28] <== NOT EXECUTED
3000720c: e1a05000 mov r5, r0 <== NOT EXECUTED
30007210: e1a0a001 mov sl, r1 <== NOT EXECUTED
30007214: e1a04002 mov r4, r2 <== NOT EXECUTED
30007218: e1a07003 mov r7, r3 <== NOT EXECUTED
FILE *fp;
int match;
init_etc_passwd_group();
3000721c: ebffff89 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
30007220: e59f00b0 ldr r0, [pc, #176] ; 300072d8 <getpw_r+0xd4> <== NOT EXECUTED 30007224: e59f10b0 ldr r1, [pc, #176] ; 300072dc <getpw_r+0xd8> <== NOT EXECUTED 30007228: eb002de8 bl 300129d0 <fopen> <== NOT EXECUTED 3000722c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007230: 1a000006 bne 30007250 <getpw_r+0x4c> <== NOT EXECUTED 30007234: ea000022 b 300072c4 <getpw_r+0xc0> <== NOT EXECUTED
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
goto error_einval;
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
30007238: e5940000 ldr r0, [r4] <== NOT EXECUTED 3000723c: eb003194 bl 30013894 <strcmp> <== NOT EXECUTED 30007240: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED 30007244: 33a00000 movcc r0, #0 <== NOT EXECUTED
} else {
match = (pwd->pw_uid == uid);
}
if (match) {
30007248: e3500000 cmp r0, #0 <== NOT EXECUTED 3000724c: 1a00000f bne 30007290 <getpw_r+0x8c> <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
30007250: e1a01004 mov r1, r4 <== NOT EXECUTED 30007254: e1a02007 mov r2, r7 <== NOT EXECUTED 30007258: e1a03008 mov r3, r8 <== NOT EXECUTED 3000725c: e1a00006 mov r0, r6 <== NOT EXECUTED 30007260: ebffff2f bl 30006f24 <scanpw> <== NOT EXECUTED 30007264: e3500000 cmp r0, #0 <== NOT EXECUTED
goto error_einval;
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
30007268: e1a01005 mov r1, r5 <== NOT EXECUTED
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize))
3000726c: 0a00000d beq 300072a8 <getpw_r+0xa4> <== NOT EXECUTED
goto error_einval;
if (name) {
30007270: e3550000 cmp r5, #0 <== NOT EXECUTED 30007274: 1affffef bne 30007238 <getpw_r+0x34> <== NOT EXECUTED
match = (strcmp(pwd->pw_name, name) == 0);
} else {
match = (pwd->pw_uid == uid);
30007278: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 3000727c: e150000a cmp r0, sl <== NOT EXECUTED 30007280: 13a00000 movne r0, #0 <== NOT EXECUTED 30007284: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
30007288: e3500000 cmp r0, #0 <== NOT EXECUTED 3000728c: 0affffef beq 30007250 <getpw_r+0x4c> <== NOT EXECUTED
fclose(fp);
30007290: e1a00006 mov r0, r6 <== NOT EXECUTED 30007294: eb002bf6 bl 30012274 <fclose> <== NOT EXECUTED
*result = pwd;
30007298: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
return 0;
3000729c: e3a00000 mov r0, #0 <== NOT EXECUTED
match = (pwd->pw_uid == uid);
}
if (match) {
fclose(fp);
*result = pwd;
300072a0: e5834000 str r4, [r3] <== NOT EXECUTED
return 0;
300072a4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
}
error_einval:
fclose(fp);
300072a8: e1a00006 mov r0, r6 <== NOT EXECUTED 300072ac: eb002bf0 bl 30012274 <fclose> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
300072b0: eb002ba1 bl 3001213c <__errno> <== NOT EXECUTED 300072b4: e3a03016 mov r3, #22 <== NOT EXECUTED 300072b8: e5803000 str r3, [r0] <== NOT EXECUTED 300072bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300072c0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/passwd", "r")) == NULL)
rtems_set_errno_and_return_minus_one( EINVAL );
300072c4: eb002b9c bl 3001213c <__errno> <== NOT EXECUTED
300072c8: e3a03016 mov r3, #22 <== NOT EXECUTED
300072cc: e5803000 str r3, [r0] <== NOT EXECUTED
300072d0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300072d4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
300073c8 <getpwent>:
struct passwd *getpwent(void)
{
300073c8: e92d4010 push {r4, lr} <== NOT EXECUTED
if (passwd_fp == NULL)
300073cc: e59f4024 ldr r4, [pc, #36] ; 300073f8 <getpwent+0x30> <== NOT EXECUTED
300073d0: e59400e8 ldr r0, [r4, #232] ; 0xe8 <== NOT EXECUTED
300073d4: e3500000 cmp r0, #0 <== NOT EXECUTED
300073d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
300073dc: e2841004 add r1, r4, #4 <== NOT EXECUTED 300073e0: e2842020 add r2, r4, #32 <== NOT EXECUTED 300073e4: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300073e8: ebfffecd bl 30006f24 <scanpw> <== NOT EXECUTED
return NULL;
300073ec: e3500000 cmp r0, #0 <== NOT EXECUTED 300073f0: 12840004 addne r0, r4, #4 <== NOT EXECUTED
return &pwent; }
300073f4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007314 <getpwnam>:
struct passwd *getpwnam(
const char *name
)
{
30007314: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
30007318: e59f1028 ldr r1, [pc, #40] ; 30007348 <getpwnam+0x34> <== NOT EXECUTED
}
struct passwd *getpwnam(
const char *name
)
{
3000731c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
30007320: e28dc004 add ip, sp, #4 <== NOT EXECUTED 30007324: e281201c add r2, r1, #28 <== NOT EXECUTED 30007328: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 3000732c: e58dc000 str ip, [sp] <== NOT EXECUTED 30007330: ebffffea bl 300072e0 <getpwnam_r> <== NOT EXECUTED 30007334: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
30007338: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
3000733c: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
30007340: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007344: e8bd8000 pop {pc} <== NOT EXECUTED
300072e0 <getpwnam_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
300072e0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
300072e4: e1a0c002 mov ip, r2 <== NOT EXECUTED
300072e8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
300072ec: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(name, 0, pwd, buffer, bufsize, result);
300072f0: e58d3000 str r3, [sp] <== NOT EXECUTED 300072f4: e1a0300c mov r3, ip <== NOT EXECUTED 300072f8: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 300072fc: e3a01000 mov r1, #0 <== NOT EXECUTED 30007300: e1a0200e mov r2, lr <== NOT EXECUTED 30007304: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 30007308: ebffffbd bl 30007204 <getpw_r> <== NOT EXECUTED
}
3000730c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007310: e8bd8000 pop {pc} <== NOT EXECUTED
30007388 <getpwuid>:
struct passwd *getpwuid(
uid_t uid
)
{
30007388: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
3000738c: e59f1030 ldr r1, [pc, #48] ; 300073c4 <getpwuid+0x3c> <== NOT EXECUTED
}
struct passwd *getpwuid(
uid_t uid
)
{
30007390: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30007394: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
30007398: e28dc004 add ip, sp, #4 <== NOT EXECUTED 3000739c: e281201c add r2, r1, #28 <== NOT EXECUTED 300073a0: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 300073a4: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 300073a8: e58dc000 str ip, [sp] <== NOT EXECUTED 300073ac: ebffffe6 bl 3000734c <getpwuid_r> <== NOT EXECUTED 300073b0: e3500000 cmp r0, #0 <== NOT EXECUTED
return NULL;
return p;
300073b4: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
)
{
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
return NULL;
300073b8: 13a00000 movne r0, #0 <== NOT EXECUTED
return p; }
300073bc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
300073c0: e8bd8000 pop {pc} <== NOT EXECUTED
3000734c <getpwuid_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
3000734c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007350: e1a0c002 mov ip, r2 <== NOT EXECUTED
30007354: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30007358: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
3000735c: e58d3000 str r3, [sp] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
30007360: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
30007364: e1a0300c mov r3, ip <== NOT EXECUTED 30007368: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 3000736c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30007370: e1a0200e mov r2, lr <== NOT EXECUTED 30007374: e3a00000 mov r0, #0 <== NOT EXECUTED 30007378: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3000737c: ebffffa0 bl 30007204 <getpw_r> <== NOT EXECUTED
}
30007380: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30007384: e8bd8000 pop {pc} <== NOT EXECUTED
3000681c <getrusage>:
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
3000681c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
30006820: e2515000 subs r5, r1, #0 <== NOT EXECUTED
#include <rtems.h>
#include <rtems/seterr.h>
int getrusage(int who, struct rusage *usage)
{
30006824: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30006828: e1a04000 mov r4, r0 <== NOT EXECUTED
struct timespec uptime;
struct timeval rtime;
if ( !usage )
3000682c: 0a00001b beq 300068a0 <getrusage+0x84> <== NOT EXECUTED
* RTEMS only has a single process so there are no children.
* The single process has been running since the system
* was booted and since there is no distinction between system
* and user time, we will just report the uptime.
*/
if (who == RUSAGE_SELF) {
30006830: e3500000 cmp r0, #0 <== NOT EXECUTED 30006834: 0a00000c beq 3000686c <getrusage+0x50> <== NOT EXECUTED
usage->ru_stime = rtime;
return 0;
}
if (who == RUSAGE_CHILDREN) {
30006838: e3700001 cmn r0, #1 <== NOT EXECUTED 3000683c: 0a000005 beq 30006858 <getrusage+0x3c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
}
rtems_set_errno_and_return_minus_one( EINVAL );
30006840: eb002aef bl 30011404 <__errno> <== NOT EXECUTED 30006844: e3a03016 mov r3, #22 <== NOT EXECUTED 30006848: e5803000 str r3, [r0] <== NOT EXECUTED 3000684c: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
30006850: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30006854: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
return 0;
}
if (who == RUSAGE_CHILDREN) {
rtems_set_errno_and_return_minus_one( ENOSYS );
30006858: eb002ae9 bl 30011404 <__errno> <== NOT EXECUTED 3000685c: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 30006860: e5803000 str r3, [r0] <== NOT EXECUTED 30006864: e1a00004 mov r0, r4 <== NOT EXECUTED 30006868: eafffff8 b 30006850 <getrusage+0x34> <== NOT EXECUTED
* The single process has been running since the system
* was booted and since there is no distinction between system
* and user time, we will just report the uptime.
*/
if (who == RUSAGE_SELF) {
rtems_clock_get_uptime( &uptime );
3000686c: e1a0000d mov r0, sp <== NOT EXECUTED 30006870: eb000bfa bl 30009860 <rtems_clock_get_uptime> <== NOT EXECUTED
rtime.tv_sec = uptime.tv_sec;
rtime.tv_usec = uptime.tv_nsec / 1000;
30006874: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 30006878: e59f3034 ldr r3, [pc, #52] ; 300068b4 <getrusage+0x98> <== NOT EXECUTED
* and user time, we will just report the uptime.
*/
if (who == RUSAGE_SELF) {
rtems_clock_get_uptime( &uptime );
rtime.tv_sec = uptime.tv_sec;
3000687c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
rtime.tv_usec = uptime.tv_nsec / 1000;
30006880: e0c30391 smull r0, r3, r1, r3 <== NOT EXECUTED
30006884: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED
30006888: e0613343 rsb r3, r1, r3, asr #6 <== NOT EXECUTED
3000688c: e885000c stm r5, {r2, r3} <== NOT EXECUTED
30006890: e5852008 str r2, [r5, #8] <== NOT EXECUTED
30006894: e585300c str r3, [r5, #12] <== NOT EXECUTED
usage->ru_utime = rtime;
usage->ru_stime = rtime;
return 0;
30006898: e1a00004 mov r0, r4 <== NOT EXECUTED 3000689c: eaffffeb b 30006850 <getrusage+0x34> <== NOT EXECUTED
{
struct timespec uptime;
struct timeval rtime;
if ( !usage )
rtems_set_errno_and_return_minus_one( EFAULT );
300068a0: eb002ad7 bl 30011404 <__errno> <== NOT EXECUTED 300068a4: e3a0300e mov r3, #14 <== NOT EXECUTED 300068a8: e5803000 str r3, [r0] <== NOT EXECUTED 300068ac: e3e00000 mvn r0, #0 <== NOT EXECUTED 300068b0: eaffffe6 b 30006850 <getrusage+0x34> <== NOT EXECUTED
3000653c <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
3000653c: e92d4030 push {r4, r5, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp )
30006540: e2504000 subs r4, r0, #0
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
30006544: e24dd008 sub sp, sp, #8
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
30006548: 0a00000f beq 3000658c <gettimeofday+0x50>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000654c: e10f5000 mrs r5, CPSR 30006550: e3853080 orr r3, r5, #128 ; 0x80 30006554: e129f003 msr CPSR_fc, r3
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
30006558: e1a0000d mov r0, sp 3000655c: eb0010e6 bl 3000a8fc <_TOD_Get>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30006560: e129f005 msr CPSR_fc, r5
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30006564: e59f2034 ldr r2, [pc, #52] ; 300065a0 <gettimeofday+0x64>
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
30006568: e59d3004 ldr r3, [sp, #4]
* Timezone information ignored by the OS proper. Per email
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
3000656c: e3a00000 mov r0, #0
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30006570: e0c21293 smull r1, r2, r3, r2 30006574: e1a03fc3 asr r3, r3, #31 30006578: e0633342 rsb r3, r3, r2, asr #6
time->tv_sec = now.tv_sec;
3000657c: e59d2000 ldr r2, [sp]
time->tv_usec = useconds;
30006580: e884000c stm r4, {r2, r3}
}
30006584: e28dd008 add sp, sp, #8
30006588: e8bd8030 pop {r4, r5, pc}
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
rtems_set_errno_and_return_minus_one( EFAULT );
3000658c: eb002ae5 bl 30011128 <__errno> <== NOT EXECUTED 30006590: e3a0300e mov r3, #14 <== NOT EXECUTED 30006594: e5803000 str r3, [r0] <== NOT EXECUTED 30006598: e3e00000 mvn r0, #0 <== NOT EXECUTED 3000659c: eafffff8 b 30006584 <gettimeofday+0x48> <== NOT EXECUTED
30007630 <getuid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
uid_t getuid( void )
{
return _POSIX_types_Uid;
30007630: e59f3008 ldr r3, [pc, #8] ; 30007640 <getuid+0x10> <== NOT EXECUTED 30007634: e5933000 ldr r3, [r3] <== NOT EXECUTED
}
30007638: e1d303b2 ldrh r0, [r3, #50] ; 0x32 <== NOT EXECUTED 3000763c: e12fff1e bx lr <== NOT EXECUTED
30010b04 <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
30010b04: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
30010b08: e5914000 ldr r4, [r1]
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
30010b0c: e5942050 ldr r2, [r4, #80] ; 0x50
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
30010b10: e2843054 add r3, r4, #84 ; 0x54 30010b14: e1520003 cmp r2, r3
30010b18: 1a000011 bne 30010b64 <imfs_dir_rmnod+0x60>
/*
* You cannot remove the file system root node.
*/
if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access )
30010b1c: e5913010 ldr r3, [r1, #16] 30010b20: e593301c ldr r3, [r3, #28] 30010b24: e1540003 cmp r4, r3
30010b28: 0a000008 beq 30010b50 <imfs_dir_rmnod+0x4c>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
30010b2c: e594505c ldr r5, [r4, #92] ; 0x5c 30010b30: e3550000 cmp r5, #0
30010b34: 1a000005 bne 30010b50 <imfs_dir_rmnod+0x4c>
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
30010b38: e1a00004 mov r0, r4 30010b3c: ebfff5d6 bl 3000e29c <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
30010b40: e1a00004 mov r0, r4 30010b44: ebfff5e7 bl 3000e2e8 <IMFS_check_node_remove>
return 0;
30010b48: e1a00005 mov r0, r5
}
30010b4c: e8bd8030 pop {r4, r5, pc}
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
rtems_set_errno_and_return_minus_one( EBUSY );
30010b50: eb000174 bl 30011128 <__errno> <== NOT EXECUTED
30010b54: e3a03010 mov r3, #16 <== NOT EXECUTED
30010b58: e5803000 str r3, [r0] <== NOT EXECUTED
30010b5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
30010b60: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* You cannot remove a node that still has children
*/
if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) )
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
30010b64: eb00016f bl 30011128 <__errno> <== NOT EXECUTED
30010b68: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED
30010b6c: e5803000 str r3, [r0] <== NOT EXECUTED
30010b70: e3e00000 mvn r0, #0 <== NOT EXECUTED
30010b74: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007048 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
30007048: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
3000704c: e59f30b0 ldr r3, [pc, #176] ; 30007104 <init_etc_passwd_group+0xbc><== NOT EXECUTED
30007050: e5d32000 ldrb r2, [r3] <== NOT EXECUTED
30007054: e3520000 cmp r2, #0 <== NOT EXECUTED
30007058: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
return;
etc_passwd_initted = 1;
3000705c: e3a05001 mov r5, #1 <== NOT EXECUTED
mkdir("/etc", 0777);
30007060: e59f10a0 ldr r1, [pc, #160] ; 30007108 <init_etc_passwd_group+0xc0><== NOT EXECUTED
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
30007064: e5c35000 strb r5, [r3] <== NOT EXECUTED
mkdir("/etc", 0777);
30007068: e59f009c ldr r0, [pc, #156] ; 3000710c <init_etc_passwd_group+0xc4><== NOT EXECUTED 3000706c: eb000246 bl 3000798c <mkdir> <== NOT EXECUTED
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
30007070: e59f0098 ldr r0, [pc, #152] ; 30007110 <init_etc_passwd_group+0xc8><== NOT EXECUTED 30007074: e59f1098 ldr r1, [pc, #152] ; 30007114 <init_etc_passwd_group+0xcc><== NOT EXECUTED 30007078: eb002e54 bl 300129d0 <fopen> <== NOT EXECUTED 3000707c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007080: 0a000007 beq 300070a4 <init_etc_passwd_group+0x5c> <== NOT EXECUTED
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
30007084: eb002c7a bl 30012274 <fclose> <== NOT EXECUTED
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
30007088: e59f0088 ldr r0, [pc, #136] ; 30007118 <init_etc_passwd_group+0xd0><== NOT EXECUTED 3000708c: e59f1080 ldr r1, [pc, #128] ; 30007114 <init_etc_passwd_group+0xcc><== NOT EXECUTED 30007090: eb002e4e bl 300129d0 <fopen> <== NOT EXECUTED 30007094: e3500000 cmp r0, #0 <== NOT EXECUTED 30007098: 0a00000d beq 300070d4 <init_etc_passwd_group+0x8c> <== NOT EXECUTED
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
}
}
3000709c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
fprintf( fp, "root:x:0:root\n"
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
300070a0: ea002c73 b 30012274 <fclose> <== NOT EXECUTED
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
300070a4: e59f0064 ldr r0, [pc, #100] ; 30007110 <init_etc_passwd_group+0xc8><== NOT EXECUTED 300070a8: e59f106c ldr r1, [pc, #108] ; 3000711c <init_etc_passwd_group+0xd4><== NOT EXECUTED 300070ac: eb002e47 bl 300129d0 <fopen> <== NOT EXECUTED 300070b0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 300070b4: 0afffff3 beq 30007088 <init_etc_passwd_group+0x40> <== NOT EXECUTED
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
300070b8: e59f0060 ldr r0, [pc, #96] ; 30007120 <init_etc_passwd_group+0xd8><== NOT EXECUTED 300070bc: e1a01005 mov r1, r5 <== NOT EXECUTED 300070c0: e3a02066 mov r2, #102 ; 0x66 <== NOT EXECUTED 300070c4: e1a03004 mov r3, r4 <== NOT EXECUTED 300070c8: eb003048 bl 300131f0 <fwrite> <== NOT EXECUTED
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
300070cc: e1a00004 mov r0, r4 <== NOT EXECUTED 300070d0: eaffffeb b 30007084 <init_etc_passwd_group+0x3c> <== NOT EXECUTED
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
300070d4: e59f003c ldr r0, [pc, #60] ; 30007118 <init_etc_passwd_group+0xd0><== NOT EXECUTED
300070d8: e59f103c ldr r1, [pc, #60] ; 3000711c <init_etc_passwd_group+0xd4><== NOT EXECUTED
300070dc: eb002e3b bl 300129d0 <fopen> <== NOT EXECUTED
300070e0: e2504000 subs r4, r0, #0 <== NOT EXECUTED
300070e4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
fprintf( fp, "root:x:0:root\n"
300070e8: e59f0034 ldr r0, [pc, #52] ; 30007124 <init_etc_passwd_group+0xdc><== NOT EXECUTED 300070ec: e3a01001 mov r1, #1 <== NOT EXECUTED 300070f0: e3a0202a mov r2, #42 ; 0x2a <== NOT EXECUTED 300070f4: e1a03004 mov r3, r4 <== NOT EXECUTED 300070f8: eb00303c bl 300131f0 <fwrite> <== NOT EXECUTED
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
300070fc: e1a00004 mov r0, r4 <== NOT EXECUTED 30007100: eaffffe5 b 3000709c <init_etc_passwd_group+0x54> <== NOT EXECUTED
3000841c <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
3000841c: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008420: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
30008424: e3130020 tst r3, #32 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008428: e20040ff and r4, r0, #255 ; 0xff <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
3000842c: 1200407f andne r4, r0, #127 ; 0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
30008430: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008434: e1a05001 mov r5, r1 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
30008438: 0a000007 beq 3000845c <iproc+0x40> <== NOT EXECUTED
c = tolower (c);
3000843c: e59f21a0 ldr r2, [pc, #416] ; 300085e4 <iproc+0x1c8> <== NOT EXECUTED 30008440: e5922000 ldr r2, [r2] <== NOT EXECUTED 30008444: e0822004 add r2, r2, r4 <== NOT EXECUTED 30008448: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 3000844c: e2022003 and r2, r2, #3 <== NOT EXECUTED 30008450: e3520001 cmp r2, #1 <== NOT EXECUTED 30008454: 02844020 addeq r4, r4, #32 <== NOT EXECUTED 30008458: e20440ff and r4, r4, #255 ; 0xff <== NOT EXECUTED
if (c == '\r') {
3000845c: e354000d cmp r4, #13 <== NOT EXECUTED 30008460: 0a000014 beq 300084b8 <iproc+0x9c> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
30008464: e354000a cmp r4, #10 <== NOT EXECUTED 30008468: 0a000036 beq 30008548 <iproc+0x12c> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
3000846c: e3540000 cmp r4, #0 <== NOT EXECUTED 30008470: 1a000016 bne 300084d0 <iproc+0xb4> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
30008474: e59f216c ldr r2, [pc, #364] ; 300085e8 <iproc+0x1cc> <== NOT EXECUTED 30008478: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 3000847c: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30008480: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30008484: e1530002 cmp r3, r2 <== NOT EXECUTED 30008488: aa000008 bge 300084b0 <iproc+0x94> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
3000848c: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED 30008490: e3120008 tst r2, #8 <== NOT EXECUTED 30008494: 1a00002e bne 30008554 <iproc+0x138> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008498: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 3000849c: e2832001 add r2, r3, #1 <== NOT EXECUTED 300084a0: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
300084a4: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
300084a8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
300084ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
} return 0;
300084b0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
300084b4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
300084b8: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED
return 0;
300084bc: 13a00000 movne r0, #0 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
300084c0: 18bd8030 popne {r4, r5, pc} <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
300084c4: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300084c8: 03a0400d moveq r4, #13 <== NOT EXECUTED 300084cc: 13a0400a movne r4, #10 <== NOT EXECUTED
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
300084d0: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED 300084d4: e3130002 tst r3, #2 <== NOT EXECUTED 300084d8: 0affffe5 beq 30008474 <iproc+0x58> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
300084dc: e5d52043 ldrb r2, [r5, #67] ; 0x43 <== NOT EXECUTED 300084e0: e1520004 cmp r2, r4 <== NOT EXECUTED 300084e4: 0a000039 beq 300085d0 <iproc+0x1b4> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
300084e8: e5d52044 ldrb r2, [r5, #68] ; 0x44 <== NOT EXECUTED 300084ec: e1520004 cmp r2, r4 <== NOT EXECUTED 300084f0: 0a000025 beq 3000858c <iproc+0x170> <== NOT EXECUTED
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
300084f4: e5d52045 ldrb r2, [r5, #69] ; 0x45 <== NOT EXECUTED 300084f8: e1520004 cmp r2, r4 <== NOT EXECUTED
return 1;
300084fc: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
30008500: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return 1;
} else if (c == '\n') {
30008504: e354000a cmp r4, #10 <== NOT EXECUTED 30008508: 0a000024 beq 300085a0 <iproc+0x184> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
3000850c: e5d5204c ldrb r2, [r5, #76] ; 0x4c <== NOT EXECUTED 30008510: e1520004 cmp r2, r4 <== NOT EXECUTED 30008514: 0a000002 beq 30008524 <iproc+0x108> <== NOT EXECUTED 30008518: e5d52051 ldrb r2, [r5, #81] ; 0x51 <== NOT EXECUTED 3000851c: e1520004 cmp r2, r4 <== NOT EXECUTED 30008520: 1affffd3 bne 30008474 <iproc+0x58> <== NOT EXECUTED
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
30008524: e3130008 tst r3, #8 <== NOT EXECUTED 30008528: 1a000013 bne 3000857c <iproc+0x160> <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
3000852c: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 30008530: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30008534: e2832001 add r2, r3, #1 <== NOT EXECUTED 30008538: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
return 1;
3000853c: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008540: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
30008544: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
30008548: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 3000854c: 13a0400d movne r4, #13 <== NOT EXECUTED 30008550: eaffffde b 300084d0 <iproc+0xb4> <== NOT EXECUTED
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
30008554: e1a00004 mov r0, r4 <== NOT EXECUTED 30008558: e1a01005 mov r1, r5 <== NOT EXECUTED 3000855c: ebffff03 bl 30008170 <echo> <== NOT EXECUTED 30008560: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
30008564: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 30008568: e2832001 add r2, r3, #1 <== NOT EXECUTED 3000856c: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
} return 0;
30008570: e3a00000 mov r0, #0 <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
30008574: e5852020 str r2, [r5, #32] <== NOT EXECUTED
30008578: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
3000857c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008580: e1a01005 mov r1, r5 <== NOT EXECUTED 30008584: ebfffef9 bl 30008170 <echo> <== NOT EXECUTED 30008588: eaffffe7 b 3000852c <iproc+0x110> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
3000858c: e1a00005 mov r0, r5 <== NOT EXECUTED 30008590: e3a01001 mov r1, #1 <== NOT EXECUTED 30008594: ebffff1a bl 30008204 <erase> <== NOT EXECUTED
return 0;
30008598: e3a00000 mov r0, #0 <== NOT EXECUTED
3000859c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
300085a0: e3130048 tst r3, #72 ; 0x48 <== NOT EXECUTED
echo (c, tty);
300085a4: 11a00004 movne r0, r4 <== NOT EXECUTED 300085a8: 11a01005 movne r1, r5 <== NOT EXECUTED 300085ac: 1bfffeef blne 30008170 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
300085b0: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED 300085b4: e595101c ldr r1, [r5, #28] <== NOT EXECUTED 300085b8: e3a0000a mov r0, #10 <== NOT EXECUTED 300085bc: e2832001 add r2, r3, #1 <== NOT EXECUTED 300085c0: e7c10003 strb r0, [r1, r3] <== NOT EXECUTED
return 1;
300085c4: e3a00001 mov r0, #1 <== NOT EXECUTED
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
} else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
300085c8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
300085cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
300085d0: e1a00005 mov r0, r5 <== NOT EXECUTED 300085d4: e3a01000 mov r1, #0 <== NOT EXECUTED 300085d8: ebffff09 bl 30008204 <erase> <== NOT EXECUTED
return 0;
300085dc: e3a00000 mov r0, #0 <== NOT EXECUTED
300085e0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30007644 <issetugid>:
#if defined(RTEMS_NEWLIB) && !defined(HAVE_ISSETUGID)
int issetugid (void)
{
return 0;
}
30007644: e3a00000 mov r0, #0 <== NOT EXECUTED 30007648: e12fff1e bx lr <== NOT EXECUTED
30025aa4 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
30025aa4: e3a00000 mov r0, #0 <== NOT EXECUTED 30025aa8: e12fff1e bx lr <== NOT EXECUTED
30008d78 <lchown>:
int lchown(
const char *path,
uid_t owner,
gid_t group
)
{
30008d78: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 30008d7c: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
return _chown_helper( path, owner, group, false );
30008d80: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 30008d84: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 30008d88: e3a03000 mov r3, #0 <== NOT EXECUTED 30008d8c: eaffff01 b 30008998 <_chown_helper> <== NOT EXECUTED
30009b84 <link>:
int link(
const char *existing,
const char *new
)
{
30009b84: e92d4070 push {r4, r5, r6, lr}
30009b88: e24dd034 sub sp, sp, #52 ; 0x34
30009b8c: e1a05001 mov r5, r1
30009b90: e1a06000 mov r6, r0
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
30009b94: eb0039c3 bl 300182a8 <strlen> 30009b98: e28d4018 add r4, sp, #24 30009b9c: e3a03001 mov r3, #1 30009ba0: e1a01000 mov r1, r0 30009ba4: e58d3000 str r3, [sp] 30009ba8: e3a02000 mov r2, #0 30009bac: e1a00006 mov r0, r6 30009bb0: e1a03004 mov r3, r4 30009bb4: ebfffdf2 bl 30009384 <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
30009bb8: e3500000 cmp r0, #0
return -1;
30009bbc: 13e05000 mvnne r5, #0
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
0, &existing_loc, true );
if ( result != 0 )
30009bc0: 0a000002 beq 30009bd0 <link+0x4c>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
30009bc4: e1a00005 mov r0, r5
30009bc8: e28dd034 add sp, sp, #52 ; 0x34
30009bcc: e8bd8070 pop {r4, r5, r6, pc}
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
30009bd0: e28d6004 add r6, sp, #4 30009bd4: e1a00005 mov r0, r5 30009bd8: e1a02006 mov r2, r6 30009bdc: e28d1030 add r1, sp, #48 ; 0x30 30009be0: eb0004c3 bl 3000aef4 <rtems_filesystem_get_start_loc>
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
30009be4: e59d0030 ldr r0, [sp, #48] ; 0x30 30009be8: e1a01006 mov r1, r6 30009bec: e0850000 add r0, r5, r0 30009bf0: e28d202c add r2, sp, #44 ; 0x2c 30009bf4: e59d3010 ldr r3, [sp, #16] 30009bf8: e1a0e00f mov lr, pc 30009bfc: e593f004 ldr pc, [r3, #4]
if ( result != 0 ) {
30009c00: e3500000 cmp r0, #0
30009c04: 1a000018 bne 30009c6c <link+0xe8>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
30009c08: e59d3028 ldr r3, [sp, #40] ; 0x28 30009c0c: e59d2014 ldr r2, [sp, #20] 30009c10: e1520003 cmp r2, r3
30009c14: 1a00000b bne 30009c48 <link+0xc4>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
30009c18: e1a01006 mov r1, r6 <== NOT EXECUTED 30009c1c: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 30009c20: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009c24: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c28: e1a0e00f mov lr, pc <== NOT EXECUTED 30009c2c: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED 30009c30: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &existing_loc );
30009c34: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c38: ebfffe89 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
30009c3c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009c40: ebfffe87 bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
30009c44: eaffffde b 30009bc4 <link+0x40> <== NOT EXECUTED
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
rtems_filesystem_freenode( &existing_loc );
30009c48: e1a00004 mov r0, r4 30009c4c: ebfffe84 bl 30009664 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &parent_loc );
30009c50: e1a00006 mov r0, r6 30009c54: ebfffe82 bl 30009664 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
30009c58: eb002c8f bl 30014e9c <__errno> 30009c5c: e3a03012 mov r3, #18 30009c60: e5803000 str r3, [r0] 30009c64: e3e05000 mvn r5, #0 30009c68: eaffffd5 b 30009bc4 <link+0x40>
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
if ( result != 0 ) {
rtems_filesystem_freenode( &existing_loc );
30009c6c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009c70: ebfffe7b bl 30009664 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
30009c74: e3e05000 mvn r5, #0 <== NOT EXECUTED 30009c78: eaffffd1 b 30009bc4 <link+0x40> <== NOT EXECUTED
300167f8 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
300167f8: e59fc0fc ldr ip, [pc, #252] ; 300168fc <lseek+0x104>
off_t lseek(
int fd,
off_t offset,
int whence
)
{
300167fc: e92d4870 push {r4, r5, r6, fp, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
30016800: e59cc000 ldr ip, [ip] 30016804: e150000c cmp r0, ip
30016808: 2a000035 bcs 300168e4 <lseek+0xec> iop = rtems_libio_iop( fd );
3001680c: e59fc0ec ldr ip, [pc, #236] ; 30016900 <lseek+0x108> 30016810: e0600180 rsb r0, r0, r0, lsl #3 30016814: e59cc000 ldr ip, [ip] 30016818: e08c4180 add r4, ip, r0, lsl #3
rtems_libio_check_is_open(iop);
3001681c: e5940014 ldr r0, [r4, #20] 30016820: e3100c01 tst r0, #256 ; 0x100
30016824: 0a00002e beq 300168e4 <lseek+0xec>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
30016828: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
3001682c: e284600c add r6, r4, #12
30016830: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
30016834: 0a00001d beq 300168b0 <lseek+0xb8>
30016838: e3530002 cmp r3, #2
3001683c: 0a00000e beq 3001687c <lseek+0x84>
30016840: e3530000 cmp r3, #0
30016844: 1a00001e bne 300168c4 <lseek+0xcc>
case SEEK_SET:
iop->offset = offset;
30016848: e584100c str r1, [r4, #12] 3001684c: e5842010 str r2, [r4, #16]
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
30016850: e594c020 ldr ip, [r4, #32] 30016854: e1a00004 mov r0, r4 30016858: e1a0e00f mov lr, pc 3001685c: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
30016860: e3700001 cmn r0, #1
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
30016864: e1a02000 mov r2, r0 30016868: e1a03001 mov r3, r1
if ( status == (off_t) -1 )
3001686c: 0a000008 beq 30016894 <lseek+0x9c>
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
30016870: e1a00002 mov r0, r2
30016874: e1a01003 mov r1, r3
30016878: e8bd8870 pop {r4, r5, r6, fp, pc}
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
3001687c: e9941800 ldmib r4, {fp, ip}
30016880: e09bb001 adds fp, fp, r1
30016884: e0acc002 adc ip, ip, r2
30016888: e584b00c str fp, [r4, #12]
3001688c: e584c010 str ip, [r4, #16]
break;
30016890: eaffffee b 30016850 <lseek+0x58>
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
if ( status == (off_t) -1 )
30016894: e3710001 cmn r1, #1
30016898: 1afffff4 bne 30016870 <lseek+0x78>
iop->offset = old_offset;
3001689c: e584500c str r5, [r4, #12] 300168a0: e5846010 str r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
300168a4: e1a00002 mov r0, r2
300168a8: e1a01003 mov r1, r3
300168ac: e8bd8870 pop {r4, r5, r6, fp, pc}
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
300168b0: e091b005 adds fp, r1, r5 300168b4: e0a2c006 adc ip, r2, r6 300168b8: e584b00c str fp, [r4, #12] 300168bc: e584c010 str ip, [r4, #16]
break;
300168c0: eaffffe2 b 30016850 <lseek+0x58>
case SEEK_END:
iop->offset = iop->size + offset;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
300168c4: ebffea17 bl 30011128 <__errno> 300168c8: e3a03016 mov r3, #22 300168cc: e5803000 str r3, [r0] 300168d0: e3e02000 mvn r2, #0 300168d4: e3e03000 mvn r3, #0
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
300168d8: e1a00002 mov r0, r2
300168dc: e1a01003 mov r1, r3
300168e0: e8bd8870 pop {r4, r5, r6, fp, pc}
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
300168e4: ebffea0f bl 30011128 <__errno> <== NOT EXECUTED 300168e8: e3a03009 mov r3, #9 <== NOT EXECUTED 300168ec: e5803000 str r3, [r0] <== NOT EXECUTED 300168f0: e3e02000 mvn r2, #0 <== NOT EXECUTED 300168f4: e3e03000 mvn r3, #0 <== NOT EXECUTED 300168f8: eaffffdc b 30016870 <lseek+0x78> <== NOT EXECUTED
300086a8 <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
300086a8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
300086ac: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
300086b0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 300086b4: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
300086b8: 0a000018 beq 30008720 <lstat+0x78> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
300086bc: eb003110 bl 30014b04 <strlen> <== NOT EXECUTED 300086c0: e28d4004 add r4, sp, #4 <== NOT EXECUTED 300086c4: e1a01000 mov r1, r0 <== NOT EXECUTED 300086c8: e3a02000 mov r2, #0 <== NOT EXECUTED 300086cc: e1a00006 mov r0, r6 <== NOT EXECUTED 300086d0: e1a03004 mov r3, r4 <== NOT EXECUTED 300086d4: e58d2000 str r2, [sp] <== NOT EXECUTED 300086d8: ebfffe2f bl 30007f9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
300086dc: e2501000 subs r1, r0, #0 <== NOT EXECUTED
return -1;
300086e0: 13e05000 mvnne r5, #0 <== NOT EXECUTED
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
300086e4: 1a00000a bne 30008714 <lstat+0x6c> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
300086e8: e1a00005 mov r0, r5 <== NOT EXECUTED 300086ec: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED 300086f0: eb002eef bl 300142b4 <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
300086f4: e1a01005 mov r1, r5 <== NOT EXECUTED 300086f8: e1a00004 mov r0, r4 <== NOT EXECUTED 300086fc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 30008700: e1a0e00f mov lr, pc <== NOT EXECUTED 30008704: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED 30008708: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
3000870c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008710: ebfffe5b bl 30008084 <rtems_filesystem_freenode> <== NOT EXECUTED
return status;
}
30008714: e1a00005 mov r0, r5 <== NOT EXECUTED
30008718: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000871c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
30008720: eb002a2f bl 30012fe4 <__errno> <== NOT EXECUTED 30008724: e3a0300e mov r3, #14 <== NOT EXECUTED 30008728: e5803000 str r3, [r0] <== NOT EXECUTED 3000872c: e3e05000 mvn r5, #0 <== NOT EXECUTED 30008730: eafffff7 b 30008714 <lstat+0x6c> <== NOT EXECUTED
30006800 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
30006800: e59f30d4 ldr r3, [pc, #212] ; 300068dc <malloc+0xdc>
#include "malloc_p.h"
void *malloc(
size_t size
)
{
30006804: e92d4030 push {r4, r5, lr}
void *return_this;
MSBUMP(malloc_calls, 1);
30006808: e5932004 ldr r2, [r3, #4]
#include "malloc_p.h"
void *malloc(
size_t size
)
{
3000680c: e1a04000 mov r4, r0
void *return_this;
MSBUMP(malloc_calls, 1);
30006810: e2822001 add r2, r2, #1 30006814: e5832004 str r2, [r3, #4]
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30006818: ebffffb0 bl 300066e0 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
3000681c: e3540000 cmp r4, #0
return (void *) 0;
30006820: 01a05004 moveq r5, r4
malloc_deferred_frees_process();
/*
* Validate the parameters
*/
if ( !size )
30006824: 0a000018 beq 3000688c <malloc+0x8c>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30006828: e59f30b0 ldr r3, [pc, #176] ; 300068e0 <malloc+0xe0> 3000682c: e5933000 ldr r3, [r3] 30006830: e3530003 cmp r3, #3
30006834: 0a000024 beq 300068cc <malloc+0xcc>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
30006838: e59f30a4 ldr r3, [pc, #164] ; 300068e4 <malloc+0xe4> 3000683c: e3a02000 mov r2, #0 30006840: e5930000 ldr r0, [r3] 30006844: e1a01004 mov r1, r4 30006848: e1a03002 mov r3, r2 3000684c: eb001369 bl 3000b5f8 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
30006850: e2505000 subs r5, r0, #0
30006854: 0a00000e beq 30006894 <malloc+0x94>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
30006858: e59f3088 ldr r3, [pc, #136] ; 300068e8 <malloc+0xe8> 3000685c: e5933000 ldr r3, [r3] 30006860: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
30006864: 11a00005 movne r0, r5 30006868: 11a01004 movne r1, r4 3000686c: 11a0e00f movne lr, pc 30006870: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
30006874: e59f3070 ldr r3, [pc, #112] ; 300068ec <malloc+0xec> 30006878: e5933000 ldr r3, [r3] 3000687c: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
30006880: 11a00005 movne r0, r5 30006884: 11a0e00f movne lr, pc 30006888: 1593f004 ldrne pc, [r3, #4]
return return_this;
}
3000688c: e1a00005 mov r0, r5
30006890: e8bd8030 pop {r4, r5, pc}
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
30006894: e59f3054 ldr r3, [pc, #84] ; 300068f0 <malloc+0xf0> 30006898: e5933000 ldr r3, [r3] 3000689c: e3530000 cmp r3, #0
300068a0: 0a000005 beq 300068bc <malloc+0xbc>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
300068a4: e1a00004 mov r0, r4 <== NOT EXECUTED 300068a8: e1a0e00f mov lr, pc <== NOT EXECUTED 300068ac: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( !return_this ) {
300068b0: e3500000 cmp r0, #0 <== NOT EXECUTED 300068b4: 11a05000 movne r5, r0 <== NOT EXECUTED 300068b8: 1affffe6 bne 30006858 <malloc+0x58> <== NOT EXECUTED
errno = ENOMEM;
300068bc: eb002a19 bl 30011128 <__errno> 300068c0: e3a0300c mov r3, #12 300068c4: e5803000 str r3, [r0]
return (void *) 0;
300068c8: eaffffef b 3000688c <malloc+0x8c>
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
300068cc: ebffff6f bl 30006690 <malloc_is_system_state_OK>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
300068d0: e2505000 subs r5, r0, #0
300068d4: 1affffd7 bne 30006838 <malloc+0x38>
300068d8: eaffffeb b 3000688c <malloc+0x8c> <== NOT EXECUTED
30006704 <malloc_deferred_free>:
void malloc_deferred_free(
void *pointer
)
{
30006704: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
30006708: e59f0000 ldr r0, [pc, #0] ; 30006710 <malloc_deferred_free+0xc><== NOT EXECUTED 3000670c: ea000f70 b 3000a4d4 <_Chain_Append> <== NOT EXECUTED
300066e0 <malloc_deferred_frees_process>:
void malloc_deferred_frees_process(void)
{
300066e0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
300066e4: ea000000 b 300066ec <malloc_deferred_frees_process+0xc>
free(to_be_freed);
300066e8: ebffff6a bl 30006498 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
300066ec: e59f000c ldr r0, [pc, #12] ; 30006700 <malloc_deferred_frees_process+0x20> 300066f0: eb000f8a bl 3000a520 <_Chain_Get>
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
300066f4: e3500000 cmp r0, #0
300066f8: 1afffffa bne 300066e8 <malloc_deferred_frees_process+0x8>
free(to_be_freed);
}
300066fc: e49df004 pop {pc} ; (ldr pc, [sp], #4)
300069bc <malloc_get_heap_pointer>:
#include <rtems.h>
#include <rtems/libcsupport.h>
#include "malloc_p.h"
Heap_Control *malloc_get_heap_pointer( void )
{
300069bc: e59f3004 ldr r3, [pc, #4] ; 300069c8 <malloc_get_heap_pointer+0xc><== NOT EXECUTED
return RTEMS_Malloc_Heap; }
300069c0: e5930000 ldr r0, [r3] <== NOT EXECUTED 300069c4: e12fff1e bx lr <== NOT EXECUTED
30006748 <malloc_get_statistics>:
#include "malloc_p.h"
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
30006748: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !stats )
3000674c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 30006750: 0a00000e beq 30006790 <malloc_get_statistics+0x48> <== NOT EXECUTED
return -1;
_RTEMS_Lock_allocator();
30006754: e59f503c ldr r5, [pc, #60] ; 30006798 <malloc_get_statistics+0x50><== NOT EXECUTED 30006758: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000675c: eb000f3f bl 3000a460 <_API_Mutex_Lock> <== NOT EXECUTED
*stats = rtems_malloc_statistics;
30006760: e59fe034 ldr lr, [pc, #52] ; 3000679c <malloc_get_statistics+0x54><== NOT EXECUTED
30006764: e1a0c004 mov ip, r4 <== NOT EXECUTED
30006768: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
3000676c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006770: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30006774: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30006778: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
3000677c: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
_RTEMS_Unlock_allocator();
30006780: e5950000 ldr r0, [r5] <== NOT EXECUTED 30006784: eb000f51 bl 3000a4d0 <_API_Mutex_Unlock> <== NOT EXECUTED
return 0;
30006788: e3a00000 mov r0, #0 <== NOT EXECUTED
3000678c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int malloc_get_statistics(
rtems_malloc_statistics_t *stats
)
{
if ( !stats )
return -1;
30006790: e3e00000 mvn r0, #0 <== NOT EXECUTED
_RTEMS_Lock_allocator(); *stats = rtems_malloc_statistics; _RTEMS_Unlock_allocator(); return 0; }
30006794: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000a730 <malloc_info>:
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
3000a730: e2501000 subs r1, r0, #0 <== NOT EXECUTED
*/
int malloc_info(
Heap_Information_block *the_info
)
{
3000a734: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !the_info )
3000a738: 0a000004 beq 3000a750 <malloc_info+0x20> <== NOT EXECUTED
return -1;
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
3000a73c: e59f3014 ldr r3, [pc, #20] ; 3000a758 <malloc_info+0x28> <== NOT EXECUTED 3000a740: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000a744: eb001955 bl 30010ca0 <_Protected_heap_Get_information> <== NOT EXECUTED
return 0;
3000a748: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a74c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int malloc_info(
Heap_Information_block *the_info
)
{
if ( !the_info )
return -1;
3000a750: e3e00000 mvn r0, #0 <== NOT EXECUTED
_Protected_heap_Get_information( RTEMS_Malloc_Heap, the_info );
return 0;
}
3000a754: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006690 <malloc_is_system_state_OK>:
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
{
if ( _Thread_Dispatch_disable_level > 0 )
30006690: e59f3024 ldr r3, [pc, #36] ; 300066bc <malloc_is_system_state_OK+0x2c> 30006694: e5933000 ldr r3, [r3] 30006698: e3530000 cmp r3, #0
3000669c: 1a000004 bne 300066b4 <malloc_is_system_state_OK+0x24>
return false;
if ( _ISR_Nest_level > 0 )
300066a0: e59f3018 ldr r3, [pc, #24] ; 300066c0 <malloc_is_system_state_OK+0x30>
#include "malloc_p.h"
rtems_chain_control RTEMS_Malloc_GC_list;
bool malloc_is_system_state_OK(void)
300066a4: e5930000 ldr r0, [r3] 300066a8: e2700001 rsbs r0, r0, #1 300066ac: 33a00000 movcc r0, #0 300066b0: e12fff1e bx lr
{
if ( _Thread_Dispatch_disable_level > 0 )
return false;
300066b4: e3a00000 mov r0, #0 <== NOT EXECUTED
if ( _ISR_Nest_level > 0 )
return false;
return true;
}
300066b8: e12fff1e bx lr <== NOT EXECUTED
3000a93c <malloc_report_statistics>:
#ifdef RTEMS_NEWLIB
#include "malloc_p.h"
void malloc_report_statistics(void)
{
malloc_report_statistics_with_plugin( NULL, printk_plugin );
3000a93c: e59f1004 ldr r1, [pc, #4] ; 3000a948 <malloc_report_statistics+0xc><== NOT EXECUTED 3000a940: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a944: ea000000 b 3000a94c <malloc_report_statistics_with_plugin> <== NOT EXECUTED
3000a94c <malloc_report_statistics_with_plugin>:
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a94c: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr} <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a950: e59f4100 ldr r4, [pc, #256] ; 3000aa58 <malloc_report_statistics_with_plugin+0x10c><== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a954: e3a03064 mov r3, #100 ; 0x64 <== NOT EXECUTED
rtems_malloc_statistics_t *s;
uintmax_t allocated;
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
3000a958: e2846024 add r6, r4, #36 ; 0x24 <== NOT EXECUTED
3000a95c: e8960060 ldm r6, {r5, r6} <== NOT EXECUTED
3000a960: e284c01c add ip, r4, #28 <== NOT EXECUTED
3000a964: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
3000a968: e05bb005 subs fp, fp, r5 <== NOT EXECUTED
3000a96c: e0ccc006 sbc ip, ip, r6 <== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a970: e086539b umull r5, r6, fp, r3 <== NOT EXECUTED 3000a974: e1a0200c mov r2, ip <== NOT EXECUTED 3000a978: e0226293 mla r2, r3, r2, r6 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a97c: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a980: e58d501c str r5, [sp, #28] <== NOT EXECUTED 3000a984: e58d6020 str r6, [sp, #32] <== NOT EXECUTED
context,
"Malloc statistics\n"
" avail:%"PRIu32"k allocated:%"PRIu32"k (%"PRId32"%%) "
"max:%"PRIu32"k (%"PRIu32"%%)"
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
3000a988: e5946000 ldr r6, [r4] <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
3000a98c: e58d2020 str r2, [sp, #32] <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a990: e1a08000 mov r8, r0 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a994: e1a02006 mov r2, r6 <== NOT EXECUTED
void malloc_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000a998: e1a0a001 mov sl, r1 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a99c: e3a03000 mov r3, #0 <== NOT EXECUTED
3000a9a0: e28d101c add r1, sp, #28 <== NOT EXECUTED
3000a9a4: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3000a9a8: e1a0552b lsr r5, fp, #10 <== NOT EXECUTED
3000a9ac: e1855b0c orr r5, r5, ip, lsl #22 <== NOT EXECUTED
3000a9b0: e1a0b52c lsr fp, ip, #10 <== NOT EXECUTED
3000a9b4: eb005945 bl 30020ed0 <__udivdi3> <== NOT EXECUTED
" lifetime:%"PRIu32"k freed:%"PRIu32"k\n",
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
3000a9b8: e5947018 ldr r7, [r4, #24] <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9bc: e98d0003 stmib sp, {r0, r1} <== NOT EXECUTED
s->space_available / 1024,
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
3000a9c0: e0873107 add r3, r7, r7, lsl #2 <== NOT EXECUTED 3000a9c4: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9c8: e1a01006 mov r1, r6 <== NOT EXECUTED 3000a9cc: e1a07527 lsr r7, r7, #10 <== NOT EXECUTED 3000a9d0: e1a00103 lsl r0, r3, #2 <== NOT EXECUTED 3000a9d4: e58d700c str r7, [sp, #12] <== NOT EXECUTED 3000a9d8: ebfff3fa bl 300079c8 <__aeabi_uidiv> <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a9dc: e594101c ldr r1, [r4, #28] <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9e0: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a9e4: e594e020 ldr lr, [r4, #32] <== NOT EXECUTED 3000a9e8: e1a0c521 lsr ip, r1, #10 <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9ec: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED 3000a9f0: e1a03522 lsr r3, r2, #10 <== NOT EXECUTED
allocated / 1024,
/* avoid float! */
(allocated * 100) / s->space_available,
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
3000a9f4: e18ccb0e orr ip, ip, lr, lsl #22 <== NOT EXECUTED
(uint32_t) (s->lifetime_freed / 1024)
3000a9f8: e1833b01 orr r3, r3, r1, lsl #22 <== NOT EXECUTED
s = &rtems_malloc_statistics;
allocated = s->lifetime_allocated - s->lifetime_freed;
(*print)(
3000a9fc: e1a02526 lsr r2, r6, #10 <== NOT EXECUTED 3000aa00: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 3000aa04: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3000aa08: e59f104c ldr r1, [pc, #76] ; 3000aa5c <malloc_report_statistics_with_plugin+0x110><== NOT EXECUTED 3000aa0c: e1a03005 mov r3, r5 <== NOT EXECUTED 3000aa10: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 3000aa14: e58db000 str fp, [sp] <== NOT EXECUTED 3000aa18: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aa1c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000aa20: e12fff1a bx sl <== NOT EXECUTED
s->max_depth / 1024,
(s->max_depth * 100) / s->space_available,
(uint32_t) (s->lifetime_allocated / 1024),
(uint32_t) (s->lifetime_freed / 1024)
);
(*print)(
3000aa24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3000aa28: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
3000aa2c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
3000aa30: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3000aa34: e58d1000 str r1, [sp] <== NOT EXECUTED
3000aa38: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
3000aa3c: e994000c ldmib r4, {r2, r3} <== NOT EXECUTED
3000aa40: e59f1018 ldr r1, [pc, #24] ; 3000aa60 <malloc_report_statistics_with_plugin+0x114><== NOT EXECUTED
3000aa44: e1a00008 mov r0, r8 <== NOT EXECUTED
3000aa48: e1a0e00f mov lr, pc <== NOT EXECUTED
3000aa4c: e12fff1a bx sl <== NOT EXECUTED
s->memalign_calls,
s->free_calls,
s->realloc_calls,
s->calloc_calls
);
}
3000aa50: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
3000aa54: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc} <== NOT EXECUTED
30006bac <malloc_sbrk_extend_and_allocate>:
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
30006bac: e59f309c ldr r3, [pc, #156] ; 30006c50 <malloc_sbrk_extend_and_allocate+0xa4><== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006bb0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
* Round to the "requested sbrk amount" so hopefully we won't have
* to grow again for a while. This effectively does sbrk() calls
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
30006bb4: e5934000 ldr r4, [r3] <== NOT EXECUTED
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
30006bb8: e1a05000 mov r5, r0 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
30006bbc: e3540000 cmp r4, #0 <== NOT EXECUTED
return (void *) 0;
30006bc0: 01a00004 moveq r0, r4 <== NOT EXECUTED
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
30006bc4: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
30006bc8: e1a01004 mov r1, r4 <== NOT EXECUTED 30006bcc: e0850004 add r0, r5, r4 <== NOT EXECUTED 30006bd0: eb00386a bl 30014d80 <__aeabi_uidiv> <== NOT EXECUTED 30006bd4: e0040490 mul r4, r0, r4 <== NOT EXECUTED
starting_address = (void *) sbrk(the_size);
30006bd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30006bdc: ebfff7df bl 30004b60 <sbrk> <== NOT EXECUTED
if ( starting_address == (void*) -1 )
30006be0: e3700001 cmn r0, #1 <== NOT EXECUTED 30006be4: 0a000010 beq 30006c2c <malloc_sbrk_extend_and_allocate+0x80><== NOT EXECUTED
return (void *) 0;
if ( !_Protected_heap_Extend(
30006be8: e59f6064 ldr r6, [pc, #100] ; 30006c54 <malloc_sbrk_extend_and_allocate+0xa8><== NOT EXECUTED 30006bec: e1a01000 mov r1, r0 <== NOT EXECUTED 30006bf0: e1a02004 mov r2, r4 <== NOT EXECUTED 30006bf4: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006bf8: eb001346 bl 3000b918 <_Protected_heap_Extend> <== NOT EXECUTED 30006bfc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 30006c00: 0a00000b beq 30006c34 <malloc_sbrk_extend_and_allocate+0x88><== NOT EXECUTED
sbrk(-the_size);
errno = ENOMEM;
return (void *) 0;
}
MSBUMP(space_available, the_size);
30006c04: e59fc04c ldr ip, [pc, #76] ; 30006c58 <malloc_sbrk_extend_and_allocate+0xac><== NOT EXECUTED 30006c08: e3a02000 mov r2, #0 <== NOT EXECUTED 30006c0c: e59c3000 ldr r3, [ip] <== NOT EXECUTED 30006c10: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006c14: e0844003 add r4, r4, r3 <== NOT EXECUTED 30006c18: e1a01005 mov r1, r5 <== NOT EXECUTED 30006c1c: e1a03002 mov r3, r2 <== NOT EXECUTED 30006c20: e58c4000 str r4, [ip] <== NOT EXECUTED
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006c24: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
30006c28: ea001327 b 3000b8cc <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
starting_address = (void *) sbrk(the_size);
if ( starting_address == (void*) -1 )
return (void *) 0;
30006c2c: e3a00000 mov r0, #0 <== NOT EXECUTED
MSBUMP(space_available, the_size);
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
30006c30: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
if ( starting_address == (void*) -1 )
return (void *) 0;
if ( !_Protected_heap_Extend(
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
30006c34: e2640000 rsb r0, r4, #0 <== NOT EXECUTED 30006c38: ebfff7c8 bl 30004b60 <sbrk> <== NOT EXECUTED
errno = ENOMEM;
30006c3c: eb002ab7 bl 30011720 <__errno> <== NOT EXECUTED 30006c40: e3a0300c mov r3, #12 <== NOT EXECUTED 30006c44: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30006c48: e1a00007 mov r0, r7 <== NOT EXECUTED
30006c4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30006c5c <malloc_sbrk_initialize>:
)
{
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006c5c: e59f3034 ldr r3, [pc, #52] ; 30006c98 <malloc_sbrk_initialize+0x3c><== NOT EXECUTED
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
30006c60: e3500000 cmp r0, #0 <== NOT EXECUTED
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
30006c64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
30006c68: e5831000 str r1, [r3] <== NOT EXECUTED
* If the starting address is 0 then we are to attempt to
* get length worth of memory using sbrk. Make sure we
* align the address that we get back.
*/
if (!starting_address) {
30006c6c: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
uaddress = (uintptr_t)sbrk(length);
30006c70: e1a00001 mov r0, r1 <== NOT EXECUTED 30006c74: ebfff7b9 bl 30004b60 <sbrk> <== NOT EXECUTED
if (uaddress == (uintptr_t) -1) {
30006c78: e3700001 cmn r0, #1 <== NOT EXECUTED 30006c7c: 0a000003 beq 30006c90 <malloc_sbrk_initialize+0x34> <== NOT EXECUTED
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
30006c80: e3100007 tst r0, #7 <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
30006c84: 12800008 addne r0, r0, #8 <== NOT EXECUTED 30006c88: 13c00007 bicne r0, r0, #7 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
30006c8c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if (!starting_address) {
uaddress = (uintptr_t)sbrk(length);
if (uaddress == (uintptr_t) -1) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
30006c90: e280001b add r0, r0, #27 <== NOT EXECUTED 30006c94: eb000e2c bl 3000a54c <rtems_fatal_error_occurred> <== NOT EXECUTED
30006c9c <malloc_set_heap_pointer>:
void malloc_set_heap_pointer(
Heap_Control *new_heap
)
{
RTEMS_Malloc_Heap = new_heap;
30006c9c: e59f3004 ldr r3, [pc, #4] ; 30006ca8 <malloc_set_heap_pointer+0xc><== NOT EXECUTED 30006ca0: e5830000 str r0, [r3] <== NOT EXECUTED
}
30006ca4: e12fff1e bx lr <== NOT EXECUTED
3000ab68 <malloc_walk>:
#include <stdlib.h>
void malloc_walk(size_t source, size_t printf_enabled)
{
_Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
3000ab68: e2512000 subs r2, r1, #0 <== NOT EXECUTED 3000ab6c: 13a02001 movne r2, #1 <== NOT EXECUTED 3000ab70: e59f100c ldr r1, [pc, #12] ; 3000ab84 <malloc_walk+0x1c> <== NOT EXECUTED
#include "malloc_p.h"
#include <stdlib.h>
void malloc_walk(size_t source, size_t printf_enabled)
{
3000ab74: e1a03000 mov r3, r0 <== NOT EXECUTED
_Protected_heap_Walk( RTEMS_Malloc_Heap, (int) source, printf_enabled );
3000ab78: e5910000 ldr r0, [r1] <== NOT EXECUTED 3000ab7c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000ab80: ea001873 b 30010d54 <_Protected_heap_Walk> <== NOT EXECUTED
3000ff7c <memfile_free_block>:
* Free a block from an in-memory file.
*/
void memfile_free_block(
void *memory
)
{
3000ff7c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free(memory);
3000ff80: ebffd944 bl 30006498 <free> <== NOT EXECUTED
memfile_blocks_allocated--;
3000ff84: e59f300c ldr r3, [pc, #12] ; 3000ff98 <memfile_free_block+0x1c><== NOT EXECUTED 3000ff88: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000ff8c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3000ff90: e5832000 str r2, [r3] <== NOT EXECUTED
}
3000ff94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ff9c <memfile_free_blocks_in_table>:
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000ff9c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000ffa0: e2517000 subs r7, r1, #0 <== NOT EXECUTED
*/
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
3000ffa4: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_assert( block_table );
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
3000ffa8: e5900000 ldr r0, [r0] <== NOT EXECUTED
for ( i=0 ; i<entries ; i++ ) {
3000ffac: da00000b ble 3000ffe0 <memfile_free_blocks_in_table+0x44> <== NOT EXECUTED 3000ffb0: e3a05000 mov r5, #0 <== NOT EXECUTED 3000ffb4: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
3000ffb8: e1a08005 mov r8, r5 <== NOT EXECUTED
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
if ( b[i] ) {
3000ffbc: e4960004 ldr r0, [r6], #4 <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000ffc0: e2855001 add r5, r5, #1 <== NOT EXECUTED
if ( b[i] ) {
3000ffc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000ffc8: 0a000001 beq 3000ffd4 <memfile_free_blocks_in_table+0x38> <== NOT EXECUTED
memfile_free_block( b[i] );
3000ffcc: ebffffea bl 3000ff7c <memfile_free_block> <== NOT EXECUTED
b[i] = 0;
3000ffd0: e5068004 str r8, [r6, #-4] <== NOT EXECUTED
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
3000ffd4: e1570005 cmp r7, r5 <== NOT EXECUTED 3000ffd8: cafffff7 bgt 3000ffbc <memfile_free_blocks_in_table+0x20> <== NOT EXECUTED 3000ffdc: e5940000 ldr r0, [r4] <== NOT EXECUTED
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
3000ffe0: ebffffe5 bl 3000ff7c <memfile_free_block> <== NOT EXECUTED
*block_table = 0;
3000ffe4: e3a03000 mov r3, #0 <== NOT EXECUTED 3000ffe8: e5843000 str r3, [r4] <== NOT EXECUTED
}
3000ffec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3001052c <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
3001052c: e92d4010 push {r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010530: e5904018 ldr r4, [r0, #24]
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
30010534: e1a03000 mov r3, r0
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
30010538: e5940054 ldr r0, [r4, #84] ; 0x54
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
3001053c: e24dd008 sub sp, sp, #8
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
30010540: e1500002 cmp r0, r2
30010544: ba00000e blt 30010584 <memfile_ftruncate+0x58> 30010548: 0a00000a beq 30010578 <memfile_ftruncate+0x4c> /* * The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length;
3001054c: e5841050 str r1, [r4, #80] ; 0x50 30010550: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
30010554: e1a0000d mov r0, sp
* The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length; iop->size = the_jnode->info.file.size;
30010558: e9830006 stmib r3, {r1, r2}
IMFS_update_atime( the_jnode );
3001055c: e3a01000 mov r1, #0 30010560: ebffd7f5 bl 3000653c <gettimeofday> 30010564: e59d3000 ldr r3, [sp]
return 0;
30010568: e3a00000 mov r0, #0
* future use and just set the length.
*/
the_jnode->info.file.size = length;
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
3001056c: e5843040 str r3, [r4, #64] ; 0x40
return 0;
}
30010570: e28dd008 add sp, sp, #8
30010574: e8bd8010 pop {r4, pc}
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
30010578: e5940050 ldr r0, [r4, #80] ; 0x50 3001057c: e1500001 cmp r0, r1
30010580: 2afffff1 bcs 3001054c <memfile_ftruncate+0x20>
return IMFS_memfile_extend( the_jnode, length );
30010584: e1a00004 mov r0, r4 <== NOT EXECUTED 30010588: ebfffef2 bl 30010158 <IMFS_memfile_extend> <== NOT EXECUTED 3001058c: eafffff7 b 30010570 <memfile_ftruncate+0x44> <== NOT EXECUTED
3000fabc <memfile_ioctl>:
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
return 0;
}
3000fabc: e3a00000 mov r0, #0 <== NOT EXECUTED 3000fac0: e12fff1e bx lr <== NOT EXECUTED
30010590 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30010590: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010594: e5905018 ldr r5, [r0, #24]
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
30010598: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
3001059c: e595304c ldr r3, [r5, #76] ; 0x4c 300105a0: e3530006 cmp r3, #6
300105a4: 0a00000d beq 300105e0 <memfile_lseek+0x50>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
300105a8: e1a00005 mov r0, r5
300105ac: e284200c add r2, r4, #12
300105b0: e8920006 ldm r2, {r1, r2}
300105b4: ebfffee7 bl 30010158 <IMFS_memfile_extend>
300105b8: e3500000 cmp r0, #0
300105bc: 1a000018 bne 30010624 <memfile_lseek+0x94>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
300105c0: e2853050 add r3, r5, #80 ; 0x50
300105c4: e893000c ldm r3, {r2, r3}
300105c8: e984000c stmib r4, {r2, r3}
300105cc: e284300c add r3, r4, #12
300105d0: e893000c ldm r3, {r2, r3}
} return iop->offset; }
300105d4: e1a00002 mov r0, r2
300105d8: e1a01003 mov r1, r3
300105dc: e8bd8030 pop {r4, r5, pc}
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
300105e0: e5951054 ldr r1, [r5, #84] ; 0x54
300105e4: e280300c add r3, r0, #12
300105e8: e893000c ldm r3, {r2, r3}
300105ec: e1530001 cmp r3, r1
300105f0: e5950050 ldr r0, [r5, #80] ; 0x50
300105f4: ca000002 bgt 30010604 <memfile_lseek+0x74> 300105f8: 1afffff5 bne 300105d4 <memfile_lseek+0x44>
300105fc: e1520000 cmp r2, r0
30010600: 9afffff3 bls 300105d4 <memfile_lseek+0x44>
iop->offset = the_jnode->info.linearfile.size;
30010604: e1a02000 mov r2, r0 <== NOT EXECUTED 30010608: e1a03001 mov r3, r1 <== NOT EXECUTED 3001060c: e1a05000 mov r5, r0 <== NOT EXECUTED 30010610: e584000c str r0, [r4, #12] <== NOT EXECUTED 30010614: e5841010 str r1, [r4, #16] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
30010618: e1a00002 mov r0, r2 <== NOT EXECUTED
3001061c: e1a01003 mov r1, r3 <== NOT EXECUTED
30010620: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
30010624: eb0002bf bl 30011128 <__errno> <== NOT EXECUTED 30010628: e3a0301c mov r3, #28 <== NOT EXECUTED 3001062c: e5803000 str r3, [r0] <== NOT EXECUTED 30010630: e3e02000 mvn r2, #0 <== NOT EXECUTED 30010634: e3e03000 mvn r3, #0 <== NOT EXECUTED 30010638: eaffffe5 b 300105d4 <memfile_lseek+0x44> <== NOT EXECUTED
3001047c <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3001047c: e92d4070 push {r4, r5, r6, lr}
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010480: e5903014 ldr r3, [r0, #20]
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
30010484: e24dd004 sub sp, sp, #4
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010488: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
3001048c: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
30010490: e5905018 ldr r5, [r0, #24]
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
30010494: 0a000002 beq 300104a4 <memfile_open+0x28>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
30010498: e595204c ldr r2, [r5, #76] ; 0x4c 3001049c: e3520006 cmp r2, #6
300104a0: 0a00000a beq 300104d0 <memfile_open+0x54>
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
300104a4: e5950050 ldr r0, [r5, #80] ; 0x50 300104a8: e5952054 ldr r2, [r5, #84] ; 0x54
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
300104ac: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
300104b0: 1584000c strne r0, [r4, #12] 300104b4: 15842010 strne r2, [r4, #16] 300104b8: 15950050 ldrne r0, [r5, #80] ; 0x50 300104bc: 15952054 ldrne r2, [r5, #84] ; 0x54
iop->size = the_jnode->info.file.size;
300104c0: e9840005 stmib r4, {r0, r2}
return 0;
300104c4: e3a00000 mov r0, #0
}
300104c8: e28dd004 add sp, sp, #4
300104cc: e8bd8070 pop {r4, r5, r6, pc}
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
300104d0: e595c050 ldr ip, [r5, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
300104d4: e3a00000 mov r0, #0 <== NOT EXECUTED
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
300104d8: e3a01000 mov r1, #0 <== NOT EXECUTED 300104dc: e3a02000 mov r2, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
300104e0: e3a06005 mov r6, #5 <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
300104e4: e15c0000 cmp ip, r0 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
300104e8: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
300104ec: e585604c str r6, [r5, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
300104f0: e5851050 str r1, [r5, #80] ; 0x50 <== NOT EXECUTED 300104f4: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
300104f8: e5850058 str r0, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
300104fc: e585005c str r0, [r5, #92] ; 0x5c <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
30010500: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED
if ((count != 0)
30010504: 05943014 ldreq r3, [r4, #20] <== NOT EXECUTED 30010508: 01a00001 moveq r0, r1 <== NOT EXECUTED 3001050c: 0affffe6 beq 300104ac <memfile_open+0x30> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
30010510: e1a00005 mov r0, r5 <== NOT EXECUTED 30010514: e58dc000 str ip, [sp] <== NOT EXECUTED 30010518: ebffff5b bl 3001028c <IMFS_memfile_write> <== NOT EXECUTED 3001051c: e3700001 cmn r0, #1 <== NOT EXECUTED 30010520: 0affffe8 beq 300104c8 <memfile_open+0x4c> <== NOT EXECUTED 30010524: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 30010528: eaffffdd b 300104a4 <memfile_open+0x28> <== NOT EXECUTED
30006904 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
30006904: e92d41f0 push {r4, r5, r6, r7, r8, lr}
30006908: e1a04001 mov r4, r1
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
3000690c: e2011a0f and r1, r1, #61440 ; 0xf000 30006910: e3510901 cmp r1, #16384 ; 0x4000
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
30006914: e24dd020 sub sp, sp, #32 30006918: e1a05000 mov r5, r0 3000691c: e1a07002 mov r7, r2 30006920: e1a08003 mov r8, r3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
30006924: 0a00000f beq 30006968 <mknod+0x64>
30006928: 9a00000a bls 30006958 <mknod+0x54>
3000692c: e3510a06 cmp r1, #24576 ; 0x6000
30006930: 0a00000c beq 30006968 <mknod+0x64>
30006934: e3510902 cmp r1, #32768 ; 0x8000
30006938: 0a00000a beq 30006968 <mknod+0x64>
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
3000693c: eb0029f9 bl 30011128 <__errno> <== NOT EXECUTED 30006940: e3a03016 mov r3, #22 <== NOT EXECUTED 30006944: e5803000 str r3, [r0] <== NOT EXECUTED 30006948: e3e04000 mvn r4, #0 <== NOT EXECUTED
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
rtems_filesystem_freenode( &temp_loc );
return result;
}
3000694c: e1a00004 mov r0, r4
30006950: e28dd020 add sp, sp, #32
30006954: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
30006958: e3510a01 cmp r1, #4096 ; 0x1000
3000695c: 0a000001 beq 30006968 <mknod+0x64>
30006960: e3510a02 cmp r1, #8192 ; 0x2000
30006964: 1afffff4 bne 3000693c <mknod+0x38>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
30006968: e28d6004 add r6, sp, #4 3000696c: e1a00005 mov r0, r5 30006970: e1a02006 mov r2, r6 30006974: e28d101c add r1, sp, #28 30006978: eb00026c bl 30007330 <rtems_filesystem_get_start_loc>
result = (*temp_loc.ops->evalformake_h)(
3000697c: e59d001c ldr r0, [sp, #28] 30006980: e1a01006 mov r1, r6 30006984: e0850000 add r0, r5, r0 30006988: e28d2018 add r2, sp, #24 3000698c: e59d3010 ldr r3, [sp, #16] 30006990: e1a0e00f mov lr, pc 30006994: e593f004 ldr pc, [r3, #4]
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
30006998: e3500000 cmp r0, #0
return -1;
3000699c: 13e04000 mvnne r4, #0
result = (*temp_loc.ops->evalformake_h)(
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
300069a0: 1affffe9 bne 3000694c <mknod+0x48>
return -1;
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
300069a4: e1a01004 mov r1, r4 300069a8: e1a02007 mov r2, r7 300069ac: e1a03008 mov r3, r8 300069b0: e58d6000 str r6, [sp] 300069b4: e59d0018 ldr r0, [sp, #24] 300069b8: e59dc010 ldr ip, [sp, #16] 300069bc: e1a0e00f mov lr, pc 300069c0: e59cf014 ldr pc, [ip, #20] 300069c4: e1a04000 mov r4, r0
rtems_filesystem_freenode( &temp_loc );
300069c8: e1a00006 mov r0, r6 300069cc: ebfffeac bl 30006484 <rtems_filesystem_freenode>
return result;
300069d0: eaffffdd b 3000694c <mknod+0x48>
30006a60 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
30006a60: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006a64: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
30006a68: e24dd030 sub sp, sp, #48 ; 0x30 30006a6c: e58d3008 str r3, [sp, #8] 30006a70: e1a07000 mov r7, r0 30006a74: e1a06001 mov r6, r1 30006a78: e1a09002 mov r9, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
30006a7c: 8a00009a bhi 30006cec <mount+0x28c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
30006a80: e1a00002 mov r0, r2 30006a84: eb001fcd bl 3000e9c0 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
30006a88: e3500000 cmp r0, #0 30006a8c: e58d0014 str r0, [sp, #20]
30006a90: 0a000095 beq 30006cec <mount+0x28c>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
30006a94: e2565000 subs r5, r6, #0 30006a98: 13a05001 movne r5, #1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
30006a9c: e3550000 cmp r5, #0
30006aa0: 0a00008a beq 30006cd0 <mount+0x270>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
30006aa4: e1a00006 mov r0, r6 30006aa8: eb002d88 bl 300120d0 <strlen> 30006aac: e2803001 add r3, r0, #1 30006ab0: e58d0010 str r0, [sp, #16] 30006ab4: e58d300c str r3, [sp, #12] 30006ab8: e58d6018 str r6, [sp, #24]
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
30006abc: e1a00009 mov r0, r9 30006ac0: eb002d82 bl 300120d0 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30006ac4: e3570000 cmp r7, #0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
30006ac8: e280b001 add fp, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
30006acc: 01a08007 moveq r8, r7
30006ad0: 0a000002 beq 30006ae0 <mount+0x80>
30006ad4: e1a00007 mov r0, r7 30006ad8: eb002d7c bl 300120d0 <strlen> 30006adc: e2808001 add r8, r0, #1
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
30006ae0: e59d300c ldr r3, [sp, #12]
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30006ae4: e3a00001 mov r0, #1
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
30006ae8: e2831074 add r1, r3, #116 ; 0x74 30006aec: e081100b add r1, r1, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
30006af0: e0811008 add r1, r1, r8 30006af4: ebfffdfa bl 300062e4 <calloc>
if ( mt_entry != NULL ) {
30006af8: e2504000 subs r4, r0, #0
30006afc: 0a00006e beq 30006cbc <mount+0x25c>
char *str = (char *) mt_entry + sizeof( *mt_entry );
30006b00: e284a074 add sl, r4, #116 ; 0x74
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
30006b04: e08a300b add r3, sl, fp
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
30006b08: e1a01009 mov r1, r9 30006b0c: e1a0200b mov r2, fp 30006b10: e1a0000a mov r0, sl 30006b14: e58d3004 str r3, [sp, #4] 30006b18: eb002bb0 bl 300119e0 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30006b1c: e59d3004 ldr r3, [sp, #4]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30006b20: e1a01007 mov r1, r7 30006b24: e1a02008 mov r2, r8 30006b28: e1a00003 mov r0, r3
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
30006b2c: e584a06c str sl, [r4, #108] ; 0x6c
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
30006b30: e0839008 add r9, r3, r8
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
30006b34: eb002ba9 bl 300119e0 <memcpy>
mt_entry->dev = str;
30006b38: e59d3004 ldr r3, [sp, #4]
str += source_size;
memcpy( str, target, target_size );
30006b3c: e59d1018 ldr r1, [sp, #24] 30006b40: e59d200c ldr r2, [sp, #12]
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
30006b44: e5843070 str r3, [r4, #112] ; 0x70
str += source_size;
memcpy( str, target, target_size );
30006b48: e1a00009 mov r0, r9 30006b4c: eb002ba3 bl 300119e0 <memcpy>
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006b50: e59fe20c ldr lr, [pc, #524] ; 30006d64 <mount+0x304>
30006b54: e284c038 add ip, r4, #56 ; 0x38
30006b58: e8be000f ldm lr!, {r0, r1, r2, r3}
30006b5c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006b60: e8be000f ldm lr!, {r0, r1, r2, r3}
30006b64: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006b68: e89e000f ldm lr, {r0, r1, r2, r3}
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
30006b6c: e59de008 ldr lr, [sp, #8]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
30006b70: e3550000 cmp r5, #0
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
30006b74: e5849068 str r9, [r4, #104] ; 0x68
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
30006b78: e584402c str r4, [r4, #44] ; 0x2c
mt_entry->options = options;
30006b7c: e584e030 str lr, [r4, #48] ; 0x30
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
30006b80: e88c000f stm ip, {r0, r1, r2, r3}
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
30006b84: 1a000024 bne 30006c1c <mount+0x1bc>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006b88: e59f31d8 ldr r3, [pc, #472] ; 30006d68 <mount+0x308>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006b8c: e5932000 ldr r2, [r3]
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
30006b90: e2833004 add r3, r3, #4 30006b94: e1520003 cmp r2, r3
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
30006b98: 01a07005 moveq r7, r5
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
30006b9c: 1a000057 bne 30006d00 <mount+0x2a0>
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
30006ba0: e1a00004 mov r0, r4 30006ba4: e59d1054 ldr r1, [sp, #84] ; 0x54 30006ba8: e59d3014 ldr r3, [sp, #20] 30006bac: e1a0e00f mov lr, pc 30006bb0: e12fff13 bx r3 30006bb4: e2506000 subs r6, r0, #0
30006bb8: 1a000057 bne 30006d1c <mount+0x2bc>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
30006bbc: e59f71a8 ldr r7, [pc, #424] ; 30006d6c <mount+0x30c> 30006bc0: e1a02006 mov r2, r6 30006bc4: e1a01006 mov r1, r6 30006bc8: e5970000 ldr r0, [r7] 30006bcc: eb000be0 bl 30009b54 <rtems_semaphore_obtain> 30006bd0: e59f0190 ldr r0, [pc, #400] ; 30006d68 <mount+0x308> 30006bd4: e1a01004 mov r1, r4 30006bd8: eb000e3d bl 3000a4d4 <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30006bdc: e5970000 ldr r0, [r7] 30006be0: eb000c24 bl 30009c78 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30006be4: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
30006be8: 11a00006 movne r0, r6
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
30006bec: 1a000008 bne 30006c14 <mount+0x1b4>
rtems_filesystem_root = mt_entry->mt_fs_root;
30006bf0: e59f3178 ldr r3, [pc, #376] ; 30006d70 <mount+0x310>
30006bf4: e284401c add r4, r4, #28
30006bf8: e593c000 ldr ip, [r3]
30006bfc: e8b4000f ldm r4!, {r0, r1, r2, r3}
30006c00: e28cc018 add ip, ip, #24
30006c04: e8ac000f stmia ip!, {r0, r1, r2, r3}
30006c08: e5943000 ldr r3, [r4]
return 0;
30006c0c: e1a00005 mov r0, r5
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
30006c10: e58c3000 str r3, [ip]
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
30006c14: e28dd030 add sp, sp, #48 ; 0x30
30006c18: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
30006c1c: e28d701c add r7, sp, #28 30006c20: e3a0c001 mov ip, #1 30006c24: e1a00006 mov r0, r6 30006c28: e59d1010 ldr r1, [sp, #16] 30006c2c: e3a02007 mov r2, #7 30006c30: e1a03007 mov r3, r7 30006c34: e58dc000 str ip, [sp] 30006c38: ebfffdd7 bl 3000639c <rtems_filesystem_evaluate_path> 30006c3c: e3700001 cmn r0, #1
30006c40: 0a000031 beq 30006d0c <mount+0x2ac>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
30006c44: e1a00007 mov r0, r7 30006c48: e59d3028 ldr r3, [sp, #40] ; 0x28 30006c4c: e1a0e00f mov lr, pc 30006c50: e593f010 ldr pc, [r3, #16] 30006c54: e3500001 cmp r0, #1
30006c58: 1a000039 bne 30006d44 <mount+0x2e4>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
30006c5c: e59f0110 ldr r0, [pc, #272] ; 30006d74 <mount+0x314> 30006c60: e59d101c ldr r1, [sp, #28] 30006c64: ebffff5f bl 300069e8 <rtems_filesystem_mount_iterate> 30006c68: e3500000 cmp r0, #0
30006c6c: 1a000038 bne 30006d54 <mount+0x2f4>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
30006c70: e59d201c ldr r2, [sp, #28]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
30006c74: e59d3028 ldr r3, [sp, #40] ; 0x28
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
30006c78: e5842008 str r2, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
30006c7c: e59d2024 ldr r2, [sp, #36] ; 0x24
mt_entry->mt_point_node.ops = loc.ops;
30006c80: e5843014 str r3, [r4, #20]
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
30006c84: e5842010 str r2, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
30006c88: e59d202c ldr r2, [sp, #44] ; 0x2c
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
30006c8c: e1a00004 mov r0, r4
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
30006c90: e5842018 str r2, [r4, #24]
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( loc.ops->mount_h( mt_entry ) ) {
30006c94: e1a0e00f mov lr, pc 30006c98: e593f020 ldr pc, [r3, #32] 30006c9c: e3500000 cmp r0, #0
30006ca0: 0affffbe beq 30006ba0 <mount+0x140>
return 0;
cleanup_and_bail:
free( mt_entry );
30006ca4: e1a00004 mov r0, r4 30006ca8: ebfffdfa bl 30006498 <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
30006cac: e1a00007 mov r0, r7 30006cb0: ebfffdf3 bl 30006484 <rtems_filesystem_freenode>
return -1;
30006cb4: e3e00000 mvn r0, #0 30006cb8: eaffffd5 b 30006c14 <mount+0x1b4>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
30006cbc: eb002919 bl 30011128 <__errno> <== NOT EXECUTED 30006cc0: e3a0300c mov r3, #12 <== NOT EXECUTED 30006cc4: e5803000 str r3, [r0] <== NOT EXECUTED 30006cc8: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006ccc: eaffffd0 b 30006c14 <mount+0x1b4> <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
30006cd0: e59fe0a0 ldr lr, [pc, #160] ; 30006d78 <mount+0x318> 30006cd4: e3a03002 mov r3, #2 30006cd8: e58de018 str lr, [sp, #24] 30006cdc: e3a0e001 mov lr, #1 30006ce0: e58d300c str r3, [sp, #12] 30006ce4: e58de010 str lr, [sp, #16] 30006ce8: eaffff73 b 30006abc <mount+0x5c>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
30006cec: eb00290d bl 30011128 <__errno> 30006cf0: e3a03016 mov r3, #22 30006cf4: e5803000 str r3, [r0] 30006cf8: e3e00000 mvn r0, #0 30006cfc: eaffffc4 b 30006c14 <mount+0x1b4>
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
30006d00: eb002908 bl 30011128 <__errno> <== NOT EXECUTED 30006d04: e3a03016 mov r3, #22 <== NOT EXECUTED 30006d08: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30006d0c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d10: ebfffde0 bl 30006498 <free> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
30006d14: e3e00000 mvn r0, #0 <== NOT EXECUTED 30006d18: eaffffbd b 30006c14 <mount+0x1b4> <== NOT EXECUTED
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
30006d1c: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 30006d20: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d24: e1a0e00f mov lr, pc <== NOT EXECUTED 30006d28: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
30006d2c: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d30: ebfffdd8 bl 30006498 <free> <== NOT EXECUTED
if ( loc_to_free )
30006d34: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
return -1;
30006d38: 03e00000 mvneq r0, #0 <== NOT EXECUTED
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
30006d3c: 0affffb4 beq 30006c14 <mount+0x1b4> <== NOT EXECUTED 30006d40: eaffffd9 b 30006cac <mount+0x24c> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
30006d44: eb0028f7 bl 30011128 <__errno> 30006d48: e3a03014 mov r3, #20 30006d4c: e5803000 str r3, [r0]
goto cleanup_and_bail;
30006d50: eaffffd3 b 30006ca4 <mount+0x244>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
30006d54: eb0028f3 bl 30011128 <__errno> 30006d58: e3a03010 mov r3, #16 30006d5c: e5803000 str r3, [r0]
goto cleanup_and_bail;
30006d60: eaffffcf b 30006ca4 <mount+0x244>
30006d80 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
30006d80: e92d4010 push {r4, lr}
30006d84: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
30006d88: eb0029e9 bl 30011534 <fileno> 30006d8c: e3500002 cmp r0, #2
30006d90: 9a000003 bls 30006da4 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
30006d94: e1a00004 mov r0, r4 <== NOT EXECUTED 30006d98: eb002930 bl 30011260 <fclose> <== NOT EXECUTED
} return 0; }
30006d9c: e3a00000 mov r0, #0
30006da0: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
30006da4: e1d430bc ldrh r3, [r4, #12] 30006da8: e3130080 tst r3, #128 ; 0x80
30006dac: 0afffffa beq 30006d9c <newlib_free_buffers+0x1c>
free( fp->_bf._base );
30006db0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30006db4: ebfffdb7 bl 30006498 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
30006db8: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30006dbc: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
30006dc0: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED 30006dc4: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
30006dc8: e5843000 str r3, [r4] <== NOT EXECUTED 30006dcc: e5843010 str r3, [r4, #16] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
30006dd0: e3a00000 mov r0, #0 <== NOT EXECUTED
30006dd4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30006178 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
30006178: e92d4010 push {r4, lr}
rtems_device_driver status;
if ( !initialized ) {
3000617c: e59f3044 ldr r3, [pc, #68] ; 300061c8 <null_initialize+0x50>
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
30006180: e1a04000 mov r4, r0
rtems_device_driver status;
if ( !initialized ) {
30006184: e5d32000 ldrb r2, [r3] 30006188: e3520000 cmp r2, #0
3000618c: 0a000001 beq 30006198 <null_initialize+0x20>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
30006190: e3a00000 mov r0, #0
30006194: e8bd8010 pop {r4, pc}
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
30006198: e3a0c001 mov ip, #1
status = rtems_io_register_name(
3000619c: e59f0028 ldr r0, [pc, #40] ; 300061cc <null_initialize+0x54> 300061a0: e1a01004 mov r1, r4
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
300061a4: e5c3c000 strb ip, [r3]
status = rtems_io_register_name(
300061a8: eb00005e bl 30006328 <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
300061ac: e3500000 cmp r0, #0
300061b0: 1a000003 bne 300061c4 <null_initialize+0x4c>
rtems_fatal_error_occurred(status);
NULL_major = major;
300061b4: e59f3014 ldr r3, [pc, #20] ; 300061d0 <null_initialize+0x58>
}
return RTEMS_SUCCESSFUL;
}
300061b8: e3a00000 mov r0, #0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
NULL_major = major;
300061bc: e5834000 str r4, [r3]
}
return RTEMS_SUCCESSFUL;
}
300061c0: e8bd8010 pop {r4, pc}
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
300061c4: eb0010cb bl 3000a4f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
30007084 <open>:
int open(
const char *pathname,
int flags,
...
)
{
30007084: e92d000e push {r1, r2, r3}
30007088: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
3000708c: e24dd01c sub sp, sp, #28
30007090: e59d503c ldr r5, [sp, #60] ; 0x3c
30007094: e1a06000 mov r6, r0
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
30007098: e2853001 add r3, r5, #1
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
3000709c: e2139001 ands r9, r3, #1 300070a0: 13a09004 movne r9, #4
if ( ( status & _FWRITE ) == _FWRITE )
300070a4: e3130002 tst r3, #2
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
300070a8: e28d3044 add r3, sp, #68 ; 0x44
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
300070ac: 13899002 orrne r9, r9, #2
va_start(ap, flags);
mode = va_arg( ap, int );
300070b0: e58d3018 str r3, [sp, #24] 300070b4: e59da040 ldr sl, [sp, #64] ; 0x40
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
300070b8: eb001d5e bl 3000e638 <rtems_libio_allocate>
if ( iop == 0 ) {
300070bc: e2504000 subs r4, r0, #0
300070c0: 0a000033 beq 30007194 <open+0x110>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
300070c4: e1a00006 mov r0, r6 300070c8: eb002c00 bl 300120d0 <strlen> 300070cc: e28d7004 add r7, sp, #4 300070d0: e1a01000 mov r1, r0 300070d4: e3a08001 mov r8, #1 300070d8: e1a00006 mov r0, r6 300070dc: e1a02009 mov r2, r9 300070e0: e1a03007 mov r3, r7 300070e4: e58d8000 str r8, [sp] 300070e8: ebfffcab bl 3000639c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
300070ec: e3700001 cmn r0, #1
300070f0: 0a00005a beq 30007260 <open+0x1dc>
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
300070f4: e2053c0a and r3, r5, #2560 ; 0xa00 300070f8: e3530c0a cmp r3, #2560 ; 0xa00
300070fc: 0a000029 beq 300071a8 <open+0x124>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30007100: e1a00005 mov r0, r5 30007104: e5948014 ldr r8, [r4, #20] 30007108: eb001d2a bl 3000e5b8 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
3000710c: e284c018 add ip, r4, #24 30007110: e1a0e007 mov lr, r7
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
30007114: e1808008 orr r8, r0, r8
iop->pathinfo = loc;
30007118: e8be000f ldm lr!, {r0, r1, r2, r3}
3000711c: e8ac000f stmia ip!, {r0, r1, r2, r3}
30007120: e59e3000 ldr r3, [lr]
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30007124: e1a00004 mov r0, r4
/* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); iop->pathinfo = loc;
30007128: e58c3000 str r3, [ip]
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
3000712c: e5848014 str r8, [r4, #20]
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
30007130: e594c020 ldr ip, [r4, #32] 30007134: e1a01006 mov r1, r6 30007138: e1a02005 mov r2, r5 3000713c: e1a0300a mov r3, sl 30007140: e1a0e00f mov lr, pc 30007144: e59cf000 ldr pc, [ip]
if ( rc ) {
30007148: e3500000 cmp r0, #0
3000714c: 1a00003e bne 3000724c <open+0x1c8>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
30007150: e3150b01 tst r5, #1024 ; 0x400
30007154: 1a00001c bne 300071cc <open+0x148>
30007158: e59f518c ldr r5, [pc, #396] ; 300072ec <open+0x268>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
3000715c: e5953000 ldr r3, [r5] 30007160: e0634004 rsb r4, r3, r4 30007164: e1a041c4 asr r4, r4, #3 30007168: e0843184 add r3, r4, r4, lsl #3 3000716c: e0833303 add r3, r3, r3, lsl #6 30007170: e0843183 add r3, r4, r3, lsl #3 30007174: e0833783 add r3, r3, r3, lsl #15 30007178: e0844183 add r4, r4, r3, lsl #3 3000717c: e2644000 rsb r4, r4, #0
}
30007180: e1a00004 mov r0, r4
30007184: e28dd01c add sp, sp, #28
30007188: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
3000718c: e28dd00c add sp, sp, #12
30007190: e12fff1e bx lr
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
30007194: e3a06017 mov r6, #23
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
30007198: eb0027e2 bl 30011128 <__errno> 3000719c: e3e04000 mvn r4, #0 300071a0: e5806000 str r6, [r0] 300071a4: eafffff5 b 30007180 <open+0xfc>
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
/* We were trying to create a file that already exists */
rc = EEXIST;
300071a8: e3a06011 mov r6, #17 <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
if ( iop )
300071ac: e3540000 cmp r4, #0
rtems_libio_free( iop );
300071b0: 11a00004 movne r0, r4 300071b4: 1b001d60 blne 3000e73c <rtems_libio_free>
if ( loc_to_free )
300071b8: e3570000 cmp r7, #0
300071bc: 0afffff5 beq 30007198 <open+0x114>
rtems_filesystem_freenode( loc_to_free );
300071c0: e1a00007 mov r0, r7 <== NOT EXECUTED 300071c4: ebfffcae bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED 300071c8: eafffff2 b 30007198 <open+0x114> <== NOT EXECUTED
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
300071cc: e59f5118 ldr r5, [pc, #280] ; 300072ec <open+0x268> 300071d0: e3a01000 mov r1, #0 300071d4: e5953000 ldr r3, [r5] 300071d8: e3a02000 mov r2, #0 300071dc: e0633004 rsb r3, r3, r4 300071e0: e1a031c3 asr r3, r3, #3 300071e4: e0830183 add r0, r3, r3, lsl #3 300071e8: e0800300 add r0, r0, r0, lsl #6 300071ec: e0830180 add r0, r3, r0, lsl #3 300071f0: e0800780 add r0, r0, r0, lsl #15 300071f4: e0830180 add r0, r3, r0, lsl #3 300071f8: e2600000 rsb r0, r0, #0 300071fc: eb001cb6 bl 3000e4dc <ftruncate>
if ( rc ) {
30007200: e2506000 subs r6, r0, #0
30007204: 0affffd4 beq 3000715c <open+0xd8>
if(errno) rc = errno;
30007208: eb0027c6 bl 30011128 <__errno> <== NOT EXECUTED 3000720c: e5903000 ldr r3, [r0] <== NOT EXECUTED 30007210: e3530000 cmp r3, #0 <== NOT EXECUTED 30007214: 1a000031 bne 300072e0 <open+0x25c> <== NOT EXECUTED
close( iop - rtems_libio_iops );
30007218: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000721c: e0634004 rsb r4, r3, r4 <== NOT EXECUTED 30007220: e1a041c4 asr r4, r4, #3 <== NOT EXECUTED 30007224: e0843184 add r3, r4, r4, lsl #3 <== NOT EXECUTED 30007228: e0833303 add r3, r3, r3, lsl #6 <== NOT EXECUTED 3000722c: e0843183 add r3, r4, r3, lsl #3 <== NOT EXECUTED 30007230: e0833783 add r3, r3, r3, lsl #15 <== NOT EXECUTED 30007234: e0840183 add r0, r4, r3, lsl #3 <== NOT EXECUTED 30007238: e2600000 rsb r0, r0, #0 <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
3000723c: e3a04000 mov r4, #0 <== NOT EXECUTED
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
close( iop - rtems_libio_iops );
30007240: eb001c85 bl 3000e45c <close> <== NOT EXECUTED
/* those are released by close(): */
iop = 0;
30007244: e1a07004 mov r7, r4 <== NOT EXECUTED 30007248: ea000001 b 30007254 <open+0x1d0> <== NOT EXECUTED
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
3000724c: eb0027b5 bl 30011128 <__errno> <== NOT EXECUTED 30007250: e5906000 ldr r6, [r0] <== NOT EXECUTED
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
30007254: e3560000 cmp r6, #0 <== NOT EXECUTED 30007258: 0affffbe beq 30007158 <open+0xd4> <== NOT EXECUTED 3000725c: eaffffd2 b 300071ac <open+0x128> <== NOT EXECUTED
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
30007260: eb0027b0 bl 30011128 <__errno> 30007264: e5903000 ldr r3, [r0] 30007268: e3530002 cmp r3, #2
3000726c: 0a000003 beq 30007280 <open+0x1fc>
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
30007270: eb0027ac bl 30011128 <__errno> <== NOT EXECUTED
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
30007274: e3a07000 mov r7, #0 <== NOT EXECUTED
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
30007278: e5906000 ldr r6, [r0] <== NOT EXECUTED
goto done;
3000727c: eafffff4 b 30007254 <open+0x1d0> <== NOT EXECUTED
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
30007280: e2159c02 ands r9, r5, #512 ; 0x200
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
30007284: 01a07009 moveq r7, r9
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
30007288: 01a06003 moveq r6, r3
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
3000728c: 0affffc6 beq 300071ac <open+0x128>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
30007290: e1a00006 mov r0, r6 30007294: e38a1902 orr r1, sl, #32768 ; 0x8000 30007298: e3a02000 mov r2, #0 3000729c: e3a03000 mov r3, #0 300072a0: ebfffd97 bl 30006904 <mknod>
if ( rc ) {
300072a4: e2509000 subs r9, r0, #0
300072a8: 1afffff0 bne 30007270 <open+0x1ec>
/*
* After we do the mknod(), we have to evaluate the path to get the
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
300072ac: e1a00006 mov r0, r6 300072b0: eb002b86 bl 300120d0 <strlen> 300072b4: e1a03007 mov r3, r7 300072b8: e1a01000 mov r1, r0 300072bc: e1a02009 mov r2, r9 300072c0: e1a00006 mov r0, r6 300072c4: e58d8000 str r8, [sp] 300072c8: ebfffc33 bl 3000639c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
300072cc: e3500000 cmp r0, #0
int mode; int rc; rtems_libio_t *iop = 0; int status; rtems_filesystem_location_info_t loc; rtems_filesystem_location_info_t *loc_to_free = NULL;
300072d0: 11a07009 movne r7, r9
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
300072d4: 13a0600d movne r6, #13
* "loc" structure needed to actually have the file itself open.
* So we created it, and then we need to have "look it up."
*/
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
300072d8: 1affffb3 bne 300071ac <open+0x128>
300072dc: eaffff87 b 30007100 <open+0x7c>
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
300072e0: eb002790 bl 30011128 <__errno> <== NOT EXECUTED 300072e4: e5906000 ldr r6, [r0] <== NOT EXECUTED 300072e8: eaffffca b 30007218 <open+0x194> <== NOT EXECUTED
30008000 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008000: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
30008004: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008008: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
3000800c: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008010: e1a04001 mov r4, r1 30008014: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
30008018: 0a000014 beq 30008070 <oproc+0x70>
switch (c) {
3000801c: e5dd1000 ldrb r1, [sp] 30008020: e2412008 sub r2, r1, #8 30008024: e3520005 cmp r2, #5 30008028: 979ff102 ldrls pc, [pc, r2, lsl #2] 3000802c: ea000005 b 30008048 <oproc+0x48> 30008030: 300080f8 .word 0x300080f8 30008034: 300080c0 .word 0x300080c0 30008038: 3000810c .word 0x3000810c 3000803c: 30008048 .word 0x30008048 30008040: 30008048 .word 0x30008048 30008044: 30008088 .word 0x30008088
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
30008048: e3130002 tst r3, #2
3000804c: 1a00003a bne 3000813c <oproc+0x13c>
30008050: e59f310c ldr r3, [pc, #268] ; 30008164 <oproc+0x164> 30008054: e5933000 ldr r3, [r3]
c = toupper(c);
if (!iscntrl(c))
30008058: e0831001 add r1, r3, r1 3000805c: e5d13001 ldrb r3, [r1, #1] 30008060: e3130020 tst r3, #32
tty->column++;
30008064: 05943028 ldreq r3, [r4, #40] ; 0x28 30008068: 02833001 addeq r3, r3, #1 3000806c: 05843028 streq r3, [r4, #40] ; 0x28
break;
}
}
rtems_termios_puts (&c, 1, tty);
30008070: e1a0000d mov r0, sp 30008074: e3a01001 mov r1, #1 30008078: e1a02004 mov r2, r4 3000807c: ebffff98 bl 30007ee4 <rtems_termios_puts>
}
30008080: e28dd004 add sp, sp, #4
30008084: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
30008088: e3130010 tst r3, #16 <== NOT EXECUTED 3000808c: 0a000002 beq 3000809c <oproc+0x9c> <== NOT EXECUTED 30008090: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED 30008094: e3520000 cmp r2, #0 <== NOT EXECUTED 30008098: 0afffff8 beq 30008080 <oproc+0x80> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
3000809c: e2132008 ands r2, r3, #8 <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
300080a0: 05842028 streq r2, [r4, #40] ; 0x28 <== NOT EXECUTED
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
300080a4: 0afffff1 beq 30008070 <oproc+0x70> <== NOT EXECUTED
c = '\n';
if (tty->termios.c_oflag & ONLRET)
300080a8: e3130020 tst r3, #32 <== NOT EXECUTED
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
c = '\n';
300080ac: e3a0300a mov r3, #10 <== NOT EXECUTED 300080b0: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
300080b4: 13a03000 movne r3, #0 <== NOT EXECUTED 300080b8: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300080bc: eaffffeb b 30008070 <oproc+0x70> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080c0: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080c4: e2033b06 and r3, r3, #6144 ; 0x1800 <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080c8: e2021007 and r1, r2, #7 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080cc: e3530b06 cmp r3, #6144 ; 0x1800 <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
300080d0: e2611008 rsb r1, r1, #8 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
300080d4: 10811002 addne r1, r1, r2 <== NOT EXECUTED 300080d8: 15841028 strne r1, [r4, #40] ; 0x28 <== NOT EXECUTED
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
300080dc: 1affffe3 bne 30008070 <oproc+0x70> <== NOT EXECUTED
tty->column += i;
300080e0: e0812002 add r2, r1, r2 <== NOT EXECUTED 300080e4: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_termios_puts ( " ", i, tty);
300080e8: e59f0078 ldr r0, [pc, #120] ; 30008168 <oproc+0x168> <== NOT EXECUTED 300080ec: e1a02004 mov r2, r4 <== NOT EXECUTED 300080f0: ebffff7b bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED
return;
300080f4: eaffffe1 b 30008080 <oproc+0x80> <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
300080f8: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 300080fc: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
30008100: c2433001 subgt r3, r3, #1 <== NOT EXECUTED 30008104: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED 30008108: eaffffd8 b 30008070 <oproc+0x70> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
3000810c: e3130020 tst r3, #32
tty->column = 0;
30008110: 13a02000 movne r2, #0 30008114: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
30008118: e3130004 tst r3, #4
3000811c: 0affffd3 beq 30008070 <oproc+0x70>
rtems_termios_puts ("\r", 1, tty);
30008120: e59f0044 ldr r0, [pc, #68] ; 3000816c <oproc+0x16c> 30008124: e3a01001 mov r1, #1 30008128: e1a02004 mov r2, r4 3000812c: ebffff6c bl 30007ee4 <rtems_termios_puts>
tty->column = 0;
30008130: e3a03000 mov r3, #0 30008134: e5843028 str r3, [r4, #40] ; 0x28 30008138: eaffffcc b 30008070 <oproc+0x70>
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
3000813c: e59f3020 ldr r3, [pc, #32] ; 30008164 <oproc+0x164> <== NOT EXECUTED 30008140: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008144: e0832001 add r2, r3, r1 <== NOT EXECUTED 30008148: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 3000814c: e2022003 and r2, r2, #3 <== NOT EXECUTED 30008150: e3520002 cmp r2, #2 <== NOT EXECUTED 30008154: 02411020 subeq r1, r1, #32 <== NOT EXECUTED 30008158: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED 3000815c: e5cd1000 strb r1, [sp] <== NOT EXECUTED 30008160: eaffffbc b 30008058 <oproc+0x58> <== NOT EXECUTED
30008578 <pathconf>:
long pathconf(
const char *path,
int name
)
{
30008578: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000857c: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_RDONLY );
30008580: e3a01000 mov r1, #0 <== NOT EXECUTED 30008584: ebffff5c bl 300082fc <open> <== NOT EXECUTED
if ( fd == -1 )
30008588: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_RDONLY );
3000858c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
30008590: 0a000006 beq 300085b0 <pathconf+0x38> <== NOT EXECUTED
return -1;
status = fpathconf( fd, name );
30008594: e1a01005 mov r1, r5 <== NOT EXECUTED 30008598: ebfffabe bl 30007098 <fpathconf> <== NOT EXECUTED 3000859c: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
300085a0: e1a00004 mov r0, r4 <== NOT EXECUTED 300085a4: ebfff991 bl 30006bf0 <close> <== NOT EXECUTED
return status;
300085a8: e1a00005 mov r0, r5 <== NOT EXECUTED
300085ac: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
300085b0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30008894 <pipe>:
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
30008894: e3500000 cmp r0, #0 <== NOT EXECUTED
extern int pipe_create(int filsdes[2]);
int pipe(
int filsdes[2]
)
{
30008898: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (filsdes == NULL)
3000889c: 0a000001 beq 300088a8 <pipe+0x14> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
}
300088a0: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
return pipe_create(filsdes);
300088a4: ea001bee b 3000f864 <pipe_create> <== NOT EXECUTED
int pipe(
int filsdes[2]
)
{
if (filsdes == NULL)
rtems_set_errno_and_return_minus_one( EFAULT );
300088a8: eb002805 bl 300128c4 <__errno> <== NOT EXECUTED 300088ac: e3a0300e mov r3, #14 <== NOT EXECUTED 300088b0: e5803000 str r3, [r0] <== NOT EXECUTED
return pipe_create(filsdes);
}
300088b4: e3e00000 mvn r0, #0 <== NOT EXECUTED
300088b8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000f864 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000f864: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000f868: e59f1128 ldr r1, [pc, #296] ; 3000f998 <pipe_create+0x134> <== NOT EXECUTED
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
3000f86c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 3000f870: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000f874: e59f0120 ldr r0, [pc, #288] ; 3000f99c <pipe_create+0x138> <== NOT EXECUTED 3000f878: eb0005c0 bl 30010f80 <rtems_mkdir> <== NOT EXECUTED 3000f87c: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
3000f880: 13e03000 mvnne r3, #0 <== NOT EXECUTED
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
3000f884: 0a000002 beq 3000f894 <pipe_create+0x30> <== NOT EXECUTED
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
3000f888: e1a00003 mov r0, r3 <== NOT EXECUTED
3000f88c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3000f890: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000f894: e59f2104 ldr r2, [pc, #260] ; 3000f9a0 <pipe_create+0x13c> <== NOT EXECUTED
3000f898: e1a0c00d mov ip, sp <== NOT EXECUTED
3000f89c: e8920007 ldm r2, {r0, r1, r2} <== NOT EXECUTED
3000f8a0: e8ac0003 stmia ip!, {r0, r1} <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000f8a4: e59f30f8 ldr r3, [pc, #248] ; 3000f9a4 <pipe_create+0x140> <== NOT EXECUTED
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000f8a8: e1a0100c mov r1, ip <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000f8ac: e1d3c0b0 ldrh ip, [r3] <== NOT EXECUTED
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000f8b0: e1c120b0 strh r2, [r1] <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
3000f8b4: e28ce001 add lr, ip, #1 <== NOT EXECUTED 3000f8b8: e59f10e8 ldr r1, [pc, #232] ; 3000f9a8 <pipe_create+0x144> <== NOT EXECUTED 3000f8bc: e1a0200c mov r2, ip <== NOT EXECUTED 3000f8c0: e1c3e0b0 strh lr, [r3] <== NOT EXECUTED 3000f8c4: e28d000a add r0, sp, #10 <== NOT EXECUTED 3000f8c8: eb000ebc bl 300133c0 <sprintf> <== NOT EXECUTED
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000f8cc: e1a0000d mov r0, sp <== NOT EXECUTED 3000f8d0: e3a01d06 mov r1, #384 ; 0x180 <== NOT EXECUTED 3000f8d4: eb0004ff bl 30010cd8 <mkfifo> <== NOT EXECUTED 3000f8d8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
3000f8dc: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
3000f8e0: 1a000029 bne 3000f98c <pipe_create+0x128> <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
3000f8e4: e1a0000d mov r0, sp <== NOT EXECUTED 3000f8e8: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000f8ec: ebffe349 bl 30008618 <open> <== NOT EXECUTED
if (filsdes[0] < 0) {
3000f8f0: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
3000f8f4: e5850000 str r0, [r5] <== NOT EXECUTED
if (filsdes[0] < 0) {
3000f8f8: ba000019 blt 3000f964 <pipe_create+0x100> <== NOT EXECUTED
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
3000f8fc: e59f30a8 ldr r3, [pc, #168] ; 3000f9ac <pipe_create+0x148> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000f900: e3a01001 mov r1, #1 <== NOT EXECUTED
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
3000f904: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000f908: e1500003 cmp r0, r3 <== NOT EXECUTED 3000f90c: 359f309c ldrcc r3, [pc, #156] ; 3000f9b0 <pipe_create+0x14c><== NOT EXECUTED 3000f910: 30600180 rsbcc r0, r0, r0, lsl #3 <== NOT EXECUTED 3000f914: 35933000 ldrcc r3, [r3] <== NOT EXECUTED 3000f918: 30836180 addcc r6, r3, r0, lsl #3 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000f91c: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000f920: e1a0000d mov r0, sp <== NOT EXECUTED
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
3000f924: e3c33001 bic r3, r3, #1 <== NOT EXECUTED 3000f928: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
3000f92c: ebffe339 bl 30008618 <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
3000f930: e3500000 cmp r0, #0 <== NOT EXECUTED
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
3000f934: e5850004 str r0, [r5, #4] <== NOT EXECUTED
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
3000f938: a3a06000 movge r6, #0 <== NOT EXECUTED
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
3000f93c: ba00000d blt 3000f978 <pipe_create+0x114> <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
3000f940: e1a0000d mov r0, sp <== NOT EXECUTED 3000f944: ebffeb80 bl 3000a74c <unlink> <== NOT EXECUTED
} if(err != 0)
3000f948: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
return 0;
3000f94c: 01a03006 moveq r3, r6 <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
3000f950: 0affffcc beq 3000f888 <pipe_create+0x24> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(err);
3000f954: eb000bda bl 300128c4 <__errno> <== NOT EXECUTED 3000f958: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f95c: e5806000 str r6, [r0] <== NOT EXECUTED 3000f960: eaffffc8 b 3000f888 <pipe_create+0x24> <== NOT EXECUTED
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
3000f964: eb000bd6 bl 300128c4 <__errno> <== NOT EXECUTED 3000f968: e5906000 ldr r6, [r0] <== NOT EXECUTED
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
3000f96c: e1a0000d mov r0, sp <== NOT EXECUTED 3000f970: ebffeb75 bl 3000a74c <unlink> <== NOT EXECUTED 3000f974: eafffff3 b 3000f948 <pipe_create+0xe4> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
3000f978: eb000bd1 bl 300128c4 <__errno> <== NOT EXECUTED 3000f97c: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
3000f980: e5950000 ldr r0, [r5] <== NOT EXECUTED 3000f984: ebffdede bl 30007504 <close> <== NOT EXECUTED 3000f988: eaffffec b 3000f940 <pipe_create+0xdc> <== NOT EXECUTED
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
3000f98c: eb000bcc bl 300128c4 <__errno> <== NOT EXECUTED
return -1;
3000f990: e3e03000 mvn r3, #0 <== NOT EXECUTED 3000f994: eaffffbb b 3000f888 <pipe_create+0x24> <== NOT EXECUTED
30010e6c <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
30010e6c: e59f3058 ldr r3, [pc, #88] ; 30010ecc <pipe_ioctl+0x60> <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
30010e70: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (cmd == FIONREAD) {
30010e74: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
30010e78: e1a05000 mov r5, r0 <== NOT EXECUTED 30010e7c: e1a04002 mov r4, r2 <== NOT EXECUTED
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
30010e80: 13e00015 mvnne r0, #21 <== NOT EXECUTED
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
30010e84: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
30010e88: e3520000 cmp r2, #0 <== NOT EXECUTED
return -EFAULT;
30010e8c: 03e0000d mvneq r0, #13 <== NOT EXECUTED
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
30010e90: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
30010e94: e3a01000 mov r1, #0 <== NOT EXECUTED 30010e98: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010e9c: e1a02001 mov r2, r1 <== NOT EXECUTED 30010ea0: ebffeb9d bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010ea4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30010ea8: 0a000001 beq 30010eb4 <pipe_ioctl+0x48> <== NOT EXECUTED
return -EINTR;
30010eac: e3e00003 mvn r0, #3 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
30010eb0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
30010eb4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010eb8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
30010ebc: e5843000 str r3, [r4] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010ec0: ebffebde bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
return 0;
30010ec4: e1a00006 mov r0, r6 <== NOT EXECUTED
30010ec8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010ed0 <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
30010ed0: e3e0001c mvn r0, #28 <== NOT EXECUTED 30010ed4: e12fff1e bx lr <== NOT EXECUTED
30010ab8 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010ab8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
30010abc: e1a09001 mov r9, r1 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010ac0: e3a01000 mov r1, #0 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010ac4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30010ac8: e1a04000 mov r4, r0 <== NOT EXECUTED 30010acc: e1a05002 mov r5, r2 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010ad0: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED 30010ad4: e1a02001 mov r2, r1 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010ad8: e1a07003 mov r7, r3 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010adc: ebffec8e bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010ae0: e250a000 subs sl, r0, #0 <== NOT EXECUTED
return -EINTR;
30010ae4: 13e00003 mvnne r0, #3 <== NOT EXECUTED
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
30010ae8: 1a000028 bne 30010b90 <pipe_read+0xd8> <== NOT EXECUTED
return -EINTR;
while (read < count) {
30010aec: e3550000 cmp r5, #0 <== NOT EXECUTED 30010af0: 01a08005 moveq r8, r5 <== NOT EXECUTED 30010af4: 01a06008 moveq r6, r8 <== NOT EXECUTED 30010af8: 0a00001f beq 30010b7c <pipe_read+0xc4> <== NOT EXECUTED 30010afc: e1a0800a mov r8, sl <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
30010b00: e28db004 add fp, sp, #4 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
30010b04: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 30010b08: e3520000 cmp r2, #0 <== NOT EXECUTED 30010b0c: 1a000021 bne 30010b98 <pipe_read+0xe0> <== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
30010b10: e5946014 ldr r6, [r4, #20] <== NOT EXECUTED 30010b14: e3560000 cmp r6, #0 <== NOT EXECUTED 30010b18: 0a000017 beq 30010b7c <pipe_read+0xc4> <== NOT EXECUTED
goto out_locked;
if (LIBIO_NODELAY(iop)) {
30010b1c: e5976014 ldr r6, [r7, #20] <== NOT EXECUTED 30010b20: e2166001 ands r6, r6, #1 <== NOT EXECUTED 30010b24: 1a00003b bne 30010c18 <pipe_read+0x160> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
30010b28: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010b2c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
30010b30: e2833001 add r3, r3, #1 <== NOT EXECUTED 30010b34: e5843018 str r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010b38: ebffecc0 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
30010b3c: e1a01006 mov r1, r6 <== NOT EXECUTED 30010b40: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 30010b44: eb0003e3 bl 30011ad8 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010b48: e1a01006 mov r1, r6 <== NOT EXECUTED 30010b4c: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010b50: e2506000 subs r6, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010b54: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
30010b58: 13e06003 mvnne r6, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010b5c: ebffec6e bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010b60: e3500000 cmp r0, #0 <== NOT EXECUTED 30010b64: 1a00002d bne 30010c20 <pipe_read+0x168> <== NOT EXECUTED
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
30010b68: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
30010b6c: e3560000 cmp r6, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
30010b70: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30010b74: e5843018 str r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
30010b78: 0affffe1 beq 30010b04 <pipe_read+0x4c> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
30010b7c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 30010b80: ebffecae bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
out_nolock:
if (read > 0)
30010b84: e3580000 cmp r8, #0 <== NOT EXECUTED 30010b88: c1a00008 movgt r0, r8 <== NOT EXECUTED 30010b8c: d1a00006 movle r0, r6 <== NOT EXECUTED
return read;
return ret;
}
30010b90: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010b94: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
30010b98: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 30010b9c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
30010ba0: e06a6005 rsb r6, sl, r5 <== NOT EXECUTED 30010ba4: e1520006 cmp r2, r6 <== NOT EXECUTED 30010ba8: 31a06002 movcc r6, r2 <== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
30010bac: e0613003 rsb r3, r1, r3 <== NOT EXECUTED
if (chunk > chunk1) {
30010bb0: e1560003 cmp r6, r3 <== NOT EXECUTED 30010bb4: ca00001b bgt 30010c28 <pipe_read+0x170> <== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
30010bb8: e5943000 ldr r3, [r4] <== NOT EXECUTED 30010bbc: e089000a add r0, r9, sl <== NOT EXECUTED 30010bc0: e0831001 add r1, r3, r1 <== NOT EXECUTED 30010bc4: e1a02006 mov r2, r6 <== NOT EXECUTED 30010bc8: eb000d3d bl 300140c4 <memcpy> <== NOT EXECUTED
pipe->Start += chunk;
30010bcc: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
pipe->Start %= pipe->Size;
30010bd0: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 30010bd4: e0860000 add r0, r6, r0 <== NOT EXECUTED 30010bd8: eb003c48 bl 3001fd00 <__umodsi3> <== NOT EXECUTED
pipe->Length -= chunk;
30010bdc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
30010be0: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Length -= chunk;
30010be4: e0663003 rsb r3, r6, r3 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
30010be8: e3530000 cmp r3, #0 <== NOT EXECUTED
pipe->Start = 0;
30010bec: 05843008 streq r3, [r4, #8] <== NOT EXECUTED
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
pipe->Length -= chunk;
30010bf0: e584300c str r3, [r4, #12] <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
30010bf4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 30010bf8: e3530000 cmp r3, #0 <== NOT EXECUTED 30010bfc: 1a000016 bne 30010c5c <pipe_read+0x1a4> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
30010c00: e0888006 add r8, r8, r6 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
30010c04: e1580005 cmp r8, r5 <== NOT EXECUTED 30010c08: e1a0a008 mov sl, r8 <== NOT EXECUTED 30010c0c: 3affffbc bcc 30010b04 <pipe_read+0x4c> <== NOT EXECUTED 30010c10: e3a06000 mov r6, #0 <== NOT EXECUTED 30010c14: eaffffd8 b 30010b7c <pipe_read+0xc4> <== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
30010c18: e3e0600a mvn r6, #10 <== NOT EXECUTED 30010c1c: eaffffd6 b 30010b7c <pipe_read+0xc4> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
30010c20: e3e06003 mvn r6, #3 <== NOT EXECUTED 30010c24: eaffffd6 b 30010b84 <pipe_read+0xcc> <== NOT EXECUTED
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
30010c28: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010c2c: e1a02003 mov r2, r3 <== NOT EXECUTED 30010c30: e0801001 add r1, r0, r1 <== NOT EXECUTED 30010c34: e089000a add r0, r9, sl <== NOT EXECUTED 30010c38: e58d3000 str r3, [sp] <== NOT EXECUTED 30010c3c: eb000d20 bl 300140c4 <memcpy> <== NOT EXECUTED
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
30010c40: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010c44: e5941000 ldr r1, [r4] <== NOT EXECUTED 30010c48: e08a0003 add r0, sl, r3 <== NOT EXECUTED 30010c4c: e0890000 add r0, r9, r0 <== NOT EXECUTED 30010c50: e0632006 rsb r2, r3, r6 <== NOT EXECUTED 30010c54: eb000d1a bl 300140c4 <memcpy> <== NOT EXECUTED 30010c58: eaffffdb b 30010bcc <pipe_read+0x114> <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
30010c5c: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30010c60: e1a0100b mov r1, fp <== NOT EXECUTED 30010c64: eb000383 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010c68: eaffffe4 b 30010c00 <pipe_read+0x148> <== NOT EXECUTED
3001059c <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
3001059c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
300105a0: e5915014 ldr r5, [r1, #20] <== NOT EXECUTED
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
300105a4: e5904000 ldr r4, [r0] <== NOT EXECUTED
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
300105a8: e3150002 tst r5, #2 <== NOT EXECUTED
pipe->Readers --;
300105ac: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
300105b0: e2055006 and r5, r5, #6 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
300105b4: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300105b8: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_WRITE)
300105bc: e3150004 tst r5, #4 <== NOT EXECUTED
pipe->Writers --;
300105c0: 15943014 ldrne r3, [r4, #20] <== NOT EXECUTED
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
300105c4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
300105c8: 12433001 subne r3, r3, #1 <== NOT EXECUTED 300105cc: 15843014 strne r3, [r4, #20] <== NOT EXECUTED
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
300105d0: e1a06000 mov r6, r0 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
PIPE_UNLOCK(pipe);
300105d4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 300105d8: ebffee18 bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
if (pipe->Readers == 0 && pipe->Writers == 0) {
300105dc: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 300105e0: e3530000 cmp r3, #0 <== NOT EXECUTED 300105e4: 1a000007 bne 30010608 <pipe_release+0x6c> <== NOT EXECUTED 300105e8: e5947014 ldr r7, [r4, #20] <== NOT EXECUTED 300105ec: e3570000 cmp r7, #0 <== NOT EXECUTED 300105f0: 0a000013 beq 30010644 <pipe_release+0xa8> <== NOT EXECUTED
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
300105f4: e3550004 cmp r5, #4 <== NOT EXECUTED 300105f8: 1a00000d bne 30010634 <pipe_release+0x98> <== NOT EXECUTED
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
PIPE_WAKEUPREADERS(pipe);
pipe_unlock();
300105fc: ebffffe2 bl 3001058c <pipe_unlock> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
30010600: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010604: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
30010608: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3001060c: e2733001 rsbs r3, r3, #1 <== NOT EXECUTED 30010610: 33a03000 movcc r3, #0 <== NOT EXECUTED 30010614: e3550002 cmp r5, #2 <== NOT EXECUTED 30010618: 03a03000 moveq r3, #0 <== NOT EXECUTED 3001061c: e3530000 cmp r3, #0 <== NOT EXECUTED 30010620: 0afffff5 beq 300105fc <pipe_release+0x60> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
30010624: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 30010628: e1a0100d mov r1, sp <== NOT EXECUTED 3001062c: eb000511 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010630: eafffff1 b 300105fc <pipe_release+0x60> <== NOT EXECUTED
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
30010634: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30010638: e1a0100d mov r1, sp <== NOT EXECUTED 3001063c: eb00050d bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010640: eaffffed b 300105fc <pipe_release+0x60> <== NOT EXECUTED
/* Called with pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
30010644: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED 30010648: eb0004de bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
3001064c: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 30010650: eb0004dc bl 300119c8 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
30010654: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 30010658: ebffed86 bl 3000bc78 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
3001065c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30010660: ebffde8c bl 30008098 <free> <== NOT EXECUTED
free(pipe);
30010664: e1a00004 mov r0, r4 <== NOT EXECUTED 30010668: ebffde8a bl 30008098 <free> <== NOT EXECUTED
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
3001066c: e5867000 str r7, [r6] <== NOT EXECUTED 30010670: eaffffe1 b 300105fc <pipe_release+0x60> <== NOT EXECUTED
3001058c <pipe_unlock>:
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
3001058c: e59f3004 ldr r3, [pc, #4] ; 30010598 <pipe_unlock+0xc> <== NOT EXECUTED 30010590: e5930000 ldr r0, [r3] <== NOT EXECUTED 30010594: eaffee29 b 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
30010c6c <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010c6c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
30010c70: e2524000 subs r4, r2, #0 <== NOT EXECUTED
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
30010c74: e1a05000 mov r5, r0 <== NOT EXECUTED 30010c78: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30010c7c: e1a06001 mov r6, r1 <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
30010c80: 01a00004 moveq r0, r4 <== NOT EXECUTED
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
30010c84: 1a000001 bne 30010c90 <pipe_write+0x24> <== NOT EXECUTED
#endif
if (written > 0)
return written;
return ret;
}
30010c88: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30010c8c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
30010c90: e3a01000 mov r1, #0 <== NOT EXECUTED 30010c94: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010c98: e1a02001 mov r2, r1 <== NOT EXECUTED 30010c9c: e58d3000 str r3, [sp] <== NOT EXECUTED 30010ca0: ebffec1d bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010ca4: e2509000 subs r9, r0, #0 <== NOT EXECUTED 30010ca8: e59d3000 ldr r3, [sp] <== NOT EXECUTED
return -EINTR;
30010cac: 13e00003 mvnne r0, #3 <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
30010cb0: 1afffff4 bne 30010c88 <pipe_write+0x1c> <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
30010cb4: e595a010 ldr sl, [r5, #16] <== NOT EXECUTED 30010cb8: e35a0000 cmp sl, #0 <== NOT EXECUTED 30010cbc: 0a000056 beq 30010e1c <pipe_write+0x1b0> <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
30010cc0: e5957004 ldr r7, [r5, #4] <== NOT EXECUTED 30010cc4: e1a0a009 mov sl, r9 <== NOT EXECUTED 30010cc8: e1540007 cmp r4, r7 <== NOT EXECUTED 30010ccc: 91a08004 movls r8, r4 <== NOT EXECUTED 30010cd0: 83a08001 movhi r8, #1 <== NOT EXECUTED
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
30010cd4: e28db004 add fp, sp, #4 <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
30010cd8: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 30010cdc: e0612007 rsb r2, r1, r7 <== NOT EXECUTED 30010ce0: e1520008 cmp r2, r8 <== NOT EXECUTED 30010ce4: 2a000021 bcs 30010d70 <pipe_write+0x104> <== NOT EXECUTED
if (LIBIO_NODELAY(iop)) {
30010ce8: e5937014 ldr r7, [r3, #20] <== NOT EXECUTED 30010cec: e2177001 ands r7, r7, #1 <== NOT EXECUTED 30010cf0: 1a00004d bne 30010e2c <pipe_write+0x1c0> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
30010cf4: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010cf8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
30010cfc: e2822001 add r2, r2, #1 <== NOT EXECUTED 30010d00: e585201c str r2, [r5, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
30010d04: e58d3000 str r3, [sp] <== NOT EXECUTED 30010d08: ebffec4c bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
30010d0c: e1a01007 mov r1, r7 <== NOT EXECUTED 30010d10: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED 30010d14: eb00036f bl 30011ad8 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010d18: e1a01007 mov r1, r7 <== NOT EXECUTED 30010d1c: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
30010d20: e2507000 subs r7, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010d24: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
30010d28: 13e07003 mvnne r7, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
30010d2c: ebffebfa bl 3000bd1c <rtems_semaphore_obtain> <== NOT EXECUTED 30010d30: e3500000 cmp r0, #0 <== NOT EXECUTED 30010d34: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010d38: 1a000039 bne 30010e24 <pipe_write+0x1b8> <== NOT EXECUTED
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
30010d3c: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
30010d40: e3570000 cmp r7, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
30010d44: e2422001 sub r2, r2, #1 <== NOT EXECUTED 30010d48: e585201c str r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
30010d4c: 1a00002c bne 30010e04 <pipe_write+0x198> <== NOT EXECUTED
goto out_locked;
if (pipe->Readers == 0) {
30010d50: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED 30010d54: e3520000 cmp r2, #0 <== NOT EXECUTED 30010d58: 0a00002f beq 30010e1c <pipe_write+0x1b0> <== NOT EXECUTED 30010d5c: e5957004 ldr r7, [r5, #4] <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
30010d60: e595100c ldr r1, [r5, #12] <== NOT EXECUTED 30010d64: e0612007 rsb r2, r1, r7 <== NOT EXECUTED 30010d68: e1520008 cmp r2, r8 <== NOT EXECUTED 30010d6c: 3affffdd bcc 30010ce8 <pipe_write+0x7c> <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30010d70: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
30010d74: e0698004 rsb r8, r9, r4 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30010d78: e0810000 add r0, r1, r0 <== NOT EXECUTED 30010d7c: e1a01007 mov r1, r7 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
30010d80: e1520008 cmp r2, r8 <== NOT EXECUTED 30010d84: 31a08002 movcc r8, r2 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30010d88: e58d3000 str r3, [sp] <== NOT EXECUTED 30010d8c: eb003bdb bl 3001fd00 <__umodsi3> <== NOT EXECUTED 30010d90: e0607007 rsb r7, r0, r7 <== NOT EXECUTED
if (chunk > chunk1) {
30010d94: e1580007 cmp r8, r7 <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
30010d98: e1a0c000 mov ip, r0 <== NOT EXECUTED
if (chunk > chunk1) {
30010d9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010da0: da000023 ble 30010e34 <pipe_write+0x1c8> <== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
30010da4: e5950000 ldr r0, [r5] <== NOT EXECUTED 30010da8: e0861009 add r1, r6, r9 <== NOT EXECUTED 30010dac: e1a02007 mov r2, r7 <== NOT EXECUTED 30010db0: e080000c add r0, r0, ip <== NOT EXECUTED 30010db4: eb000cc2 bl 300140c4 <memcpy> <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
30010db8: e0871009 add r1, r7, r9 <== NOT EXECUTED 30010dbc: e5950000 ldr r0, [r5] <== NOT EXECUTED 30010dc0: e0861001 add r1, r6, r1 <== NOT EXECUTED 30010dc4: e0672008 rsb r2, r7, r8 <== NOT EXECUTED 30010dc8: eb000cbd bl 300140c4 <memcpy> <== NOT EXECUTED 30010dcc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
30010dd0: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
30010dd4: e5951018 ldr r1, [r5, #24] <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
30010dd8: e0822008 add r2, r2, r8 <== NOT EXECUTED
if (pipe->waitingReaders > 0)
30010ddc: e3510000 cmp r1, #0 <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
30010de0: e585200c str r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
30010de4: 1a00001a bne 30010e54 <pipe_write+0x1e8> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
written += chunk;
30010de8: e08aa008 add sl, sl, r8 <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
30010dec: e154000a cmp r4, sl <== NOT EXECUTED 30010df0: e1a0900a mov r9, sl <== NOT EXECUTED 30010df4: 85957004 ldrhi r7, [r5, #4] <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
written += chunk;
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
30010df8: 83a08001 movhi r8, #1 <== NOT EXECUTED 30010dfc: 8affffb5 bhi 30010cd8 <pipe_write+0x6c> <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
30010e00: e3a07000 mov r7, #0 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
30010e04: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED 30010e08: ebffec0c bl 3000be40 <rtems_semaphore_release> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
30010e0c: e35a0000 cmp sl, #0 <== NOT EXECUTED 30010e10: c1a0000a movgt r0, sl <== NOT EXECUTED 30010e14: d1a00007 movle r0, r7 <== NOT EXECUTED 30010e18: eaffff9a b 30010c88 <pipe_write+0x1c> <== NOT EXECUTED
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
30010e1c: e3e0701f mvn r7, #31 <== NOT EXECUTED 30010e20: eafffff7 b 30010e04 <pipe_write+0x198> <== NOT EXECUTED
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
30010e24: e3e07003 mvn r7, #3 <== NOT EXECUTED 30010e28: eafffff7 b 30010e0c <pipe_write+0x1a0> <== NOT EXECUTED
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
30010e2c: e3e0700a mvn r7, #10 <== NOT EXECUTED 30010e30: eafffff3 b 30010e04 <pipe_write+0x198> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
30010e34: e5950000 ldr r0, [r5] <== NOT EXECUTED 30010e38: e0861009 add r1, r6, r9 <== NOT EXECUTED 30010e3c: e080000c add r0, r0, ip <== NOT EXECUTED 30010e40: e1a02008 mov r2, r8 <== NOT EXECUTED 30010e44: e58d3000 str r3, [sp] <== NOT EXECUTED 30010e48: eb000c9d bl 300140c4 <memcpy> <== NOT EXECUTED 30010e4c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010e50: eaffffde b 30010dd0 <pipe_write+0x164> <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
30010e54: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED 30010e58: e1a0100b mov r1, fp <== NOT EXECUTED 30010e5c: e58d3000 str r3, [sp] <== NOT EXECUTED 30010e60: eb000304 bl 30011a78 <rtems_barrier_release> <== NOT EXECUTED 30010e64: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30010e68: eaffffde b 30010de8 <pipe_write+0x17c> <== NOT EXECUTED
3000b618 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
3000b618: e92d0030 push {r4, r5} <== NOT EXECUTED
/* * Update call statistics */ MSBUMP(memalign_calls, 1);
3000b61c: e59fc040 ldr ip, [pc, #64] ; 3000b664 <posix_memalign+0x4c><== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b620: e2414001 sub r4, r1, #1 <== NOT EXECUTED 3000b624: e1140001 tst r4, r1 <== NOT EXECUTED 3000b628: 03a05000 moveq r5, #0 <== NOT EXECUTED 3000b62c: 13a05001 movne r5, #1 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b630: e59c4008 ldr r4, [ip, #8] <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b634: e3510003 cmp r1, #3 <== NOT EXECUTED 3000b638: 81a03005 movhi r3, r5 <== NOT EXECUTED 3000b63c: 93853001 orrls r3, r5, #1 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b640: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b644: e3530000 cmp r3, #0 <== NOT EXECUTED
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
3000b648: e58c4008 str r4, [ip, #8] <== NOT EXECUTED
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
3000b64c: 0a000002 beq 3000b65c <posix_memalign+0x44> <== NOT EXECUTED
/* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); }
3000b650: e3a00016 mov r0, #22 <== NOT EXECUTED
3000b654: e8bd0030 pop {r4, r5} <== NOT EXECUTED
3000b658: e12fff1e bx lr <== NOT EXECUTED
3000b65c: e8bd0030 pop {r4, r5} <== NOT EXECUTED
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
3000b660: ea000080 b 3000b868 <rtems_memalign> <== NOT EXECUTED
3000874c <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
3000874c: e92d000e push {r1, r2, r3} <== NOT EXECUTED
30008750: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30008754: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
30008758: e28d300c add r3, sp, #12 <== NOT EXECUTED
vprintk( format, arg_pointer );
3000875c: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 30008760: e1a01003 mov r1, r3 <== NOT EXECUTED
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
30008764: e58d3000 str r3, [sp] <== NOT EXECUTED
vprintk( format, arg_pointer );
30008768: eb000789 bl 3000a594 <vprintk> <== NOT EXECUTED
va_end(arg_pointer); /* clean up when done */
return 0;
}
3000876c: e3a00000 mov r0, #0 <== NOT EXECUTED
30008770: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30008774: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
30008778: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000877c: e12fff1e bx lr <== NOT EXECUTED
300169a4 <read>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300169a4: e59f30a4 ldr r3, [pc, #164] ; 30016a50 <read+0xac>
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
300169a8: e92d4010 push {r4, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
300169ac: e5933000 ldr r3, [r3] 300169b0: e1500003 cmp r0, r3
300169b4: 2a00001b bcs 30016a28 <read+0x84> iop = rtems_libio_iop( fd );
300169b8: e59f4094 ldr r4, [pc, #148] ; 30016a54 <read+0xb0> 300169bc: e0600180 rsb r0, r0, r0, lsl #3 300169c0: e5944000 ldr r4, [r4] 300169c4: e0844180 add r4, r4, r0, lsl #3
rtems_libio_check_is_open( iop );
300169c8: e5940014 ldr r0, [r4, #20] 300169cc: e3100c01 tst r0, #256 ; 0x100
300169d0: 0a000014 beq 30016a28 <read+0x84> rtems_libio_check_buffer( buffer );
300169d4: e3510000 cmp r1, #0
300169d8: 0a000017 beq 30016a3c <read+0x98> rtems_libio_check_count( count );
300169dc: e3520000 cmp r2, #0
300169e0: 0a00000e beq 30016a20 <read+0x7c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
300169e4: e3100002 tst r0, #2
300169e8: 0a000013 beq 30016a3c <read+0x98>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
300169ec: e5943020 ldr r3, [r4, #32] 300169f0: e1a00004 mov r0, r4 300169f4: e1a0e00f mov lr, pc 300169f8: e593f008 ldr pc, [r3, #8]
if ( rc > 0 )
300169fc: e3500000 cmp r0, #0
30016a00: d8bd8010 pople {r4, pc}
iop->offset += rc;
30016a04: e284300c add r3, r4, #12
30016a08: e893000c ldm r3, {r2, r3}
30016a0c: e0922000 adds r2, r2, r0
30016a10: e0a33fc0 adc r3, r3, r0, asr #31
30016a14: e584200c str r2, [r4, #12]
30016a18: e5843010 str r3, [r4, #16]
30016a1c: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
30016a20: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30016a24: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
30016a28: ebffe9be bl 30011128 <__errno> <== NOT EXECUTED
30016a2c: e3a03009 mov r3, #9 <== NOT EXECUTED
30016a30: e5803000 str r3, [r0] <== NOT EXECUTED
30016a34: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016a38: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
30016a3c: ebffe9b9 bl 30011128 <__errno> <== NOT EXECUTED
30016a40: e3a03016 mov r3, #22 <== NOT EXECUTED
30016a44: e5803000 str r3, [r0] <== NOT EXECUTED
30016a48: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016a4c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30009ca8 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
30009ca8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
30009cac: e2516000 subs r6, r1, #0 <== NOT EXECUTED
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
30009cb0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 30009cb4: e1a07000 mov r7, r0 <== NOT EXECUTED 30009cb8: e1a05002 mov r5, r2 <== NOT EXECUTED
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
30009cbc: 0a00001d beq 30009d38 <readlink+0x90> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
30009cc0: eb00313e bl 300161c0 <strlen> <== NOT EXECUTED 30009cc4: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009cc8: e1a01000 mov r1, r0 <== NOT EXECUTED 30009ccc: e3a02000 mov r2, #0 <== NOT EXECUTED 30009cd0: e1a00007 mov r0, r7 <== NOT EXECUTED 30009cd4: e1a03004 mov r3, r4 <== NOT EXECUTED 30009cd8: e58d2000 str r2, [sp] <== NOT EXECUTED 30009cdc: ebfffb6e bl 30008a9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, false );
if ( result != 0 )
30009ce0: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30009ce4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
30009ce8: 0a000001 beq 30009cf4 <readlink+0x4c> <== NOT EXECUTED
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
rtems_filesystem_freenode( &loc );
return result;
}
30009cec: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30009cf0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
30009cf4: e1a00004 mov r0, r4 <== NOT EXECUTED 30009cf8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009cfc: e1a0e00f mov lr, pc <== NOT EXECUTED 30009d00: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED 30009d04: e3500004 cmp r0, #4 <== NOT EXECUTED 30009d08: 1a00000f bne 30009d4c <readlink+0xa4> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
30009d0c: e1a02005 mov r2, r5 <== NOT EXECUTED 30009d10: e1a01006 mov r1, r6 <== NOT EXECUTED 30009d14: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 30009d18: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d1c: e1a0e00f mov lr, pc <== NOT EXECUTED 30009d20: e593f03c ldr pc, [r3, #60] ; 0x3c <== NOT EXECUTED 30009d24: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30009d28: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d2c: ebfffb94 bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
30009d30: e1a00005 mov r0, r5 <== NOT EXECUTED 30009d34: eaffffec b 30009cec <readlink+0x44> <== NOT EXECUTED
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
30009d38: eb0029d5 bl 30014494 <__errno> <== NOT EXECUTED 30009d3c: e3a0300e mov r3, #14 <== NOT EXECUTED 30009d40: e5803000 str r3, [r0] <== NOT EXECUTED 30009d44: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d48: eaffffe7 b 30009cec <readlink+0x44> <== NOT EXECUTED
0, &loc, false );
if ( result != 0 )
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
rtems_filesystem_freenode( &loc );
30009d4c: e1a00004 mov r0, r4 <== NOT EXECUTED 30009d50: ebfffb8b bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30009d54: eb0029ce bl 30014494 <__errno> <== NOT EXECUTED 30009d58: e3a03016 mov r3, #22 <== NOT EXECUTED 30009d5c: e5803000 str r3, [r0] <== NOT EXECUTED 30009d60: e3e00000 mvn r0, #0 <== NOT EXECUTED 30009d64: eaffffe0 b 30009cec <readlink+0x44> <== NOT EXECUTED
300085c0 <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
300085c0: e59f313c ldr r3, [pc, #316] ; 30008704 <readv+0x144> <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
300085c4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
300085c8: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
300085cc: e1a04002 mov r4, r2 <== NOT EXECUTED
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
300085d0: e1500003 cmp r0, r3 <== NOT EXECUTED 300085d4: 2a000045 bcs 300086f0 <readv+0x130> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
300085d8: e59f3128 ldr r3, [pc, #296] ; 30008708 <readv+0x148> <== NOT EXECUTED 300085dc: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 300085e0: e5933000 ldr r3, [r3] <== NOT EXECUTED 300085e4: e0836180 add r6, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
300085e8: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 300085ec: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 300085f0: 0a00003e beq 300086f0 <readv+0x130> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
300085f4: e3130002 tst r3, #2 <== NOT EXECUTED 300085f8: 0a000036 beq 300086d8 <readv+0x118> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
300085fc: e3510000 cmp r1, #0 <== NOT EXECUTED 30008600: 0a000034 beq 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
30008604: e3520000 cmp r2, #0 <== NOT EXECUTED 30008608: da000032 ble 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000860c: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 30008610: ca000030 bgt 300086d8 <readv+0x118> <== NOT EXECUTED 30008614: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
30008618: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000861c: e1a03001 mov r3, r1 <== NOT EXECUTED 30008620: e3a07001 mov r7, #1 <== NOT EXECUTED 30008624: e1a01002 mov r1, r2 <== NOT EXECUTED 30008628: ea000000 b 30008630 <readv+0x70> <== NOT EXECUTED
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000862c: e1a0100c mov r1, ip <== NOT EXECUTED
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
30008630: e5930000 ldr r0, [r3] <== NOT EXECUTED
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
30008634: e2822001 add r2, r2, #1 <== NOT EXECUTED
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
30008638: e3500000 cmp r0, #0 <== NOT EXECUTED 3000863c: 0a000025 beq 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
30008640: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
30008644: e2833008 add r3, r3, #8 <== NOT EXECUTED
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
30008648: e081c000 add ip, r1, r0 <== NOT EXECUTED
if ( total < old )
3000864c: e151000c cmp r1, ip <== NOT EXECUTED 30008650: ca000020 bgt 300086d8 <readv+0x118> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
30008654: e3500000 cmp r0, #0 <== NOT EXECUTED 30008658: 13a07000 movne r7, #0 <== NOT EXECUTED
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000865c: e1540002 cmp r4, r2 <== NOT EXECUTED 30008660: cafffff1 bgt 3000862c <readv+0x6c> <== NOT EXECUTED
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
30008664: e3570000 cmp r7, #0 <== NOT EXECUTED
return 0;
30008668: 13a08000 movne r8, #0 <== NOT EXECUTED
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
3000866c: 1a00001d bne 300086e8 <readv+0x128> <== NOT EXECUTED 30008670: e1a08007 mov r8, r7 <== NOT EXECUTED 30008674: ea00000d b 300086b0 <readv+0xf0> <== NOT EXECUTED
);
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
30008678: 0a000006 beq 30008698 <readv+0xd8> <== NOT EXECUTED
iop->offset += bytes;
3000867c: e286300c add r3, r6, #12 <== NOT EXECUTED
30008680: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30008684: e0922000 adds r2, r2, r0 <== NOT EXECUTED
30008688: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
3000868c: e586200c str r2, [r6, #12] <== NOT EXECUTED
30008690: e5863010 str r3, [r6, #16] <== NOT EXECUTED
total += bytes;
30008694: e0888000 add r8, r8, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
30008698: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000869c: e2855008 add r5, r5, #8 <== NOT EXECUTED
if ( bytes > 0 ) {
iop->offset += bytes;
total += bytes;
}
if (bytes != iov[ v ].iov_len)
300086a0: e1500003 cmp r0, r3 <== NOT EXECUTED 300086a4: 1a00000f bne 300086e8 <readv+0x128> <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300086a8: e1540007 cmp r4, r7 <== NOT EXECUTED 300086ac: da00000d ble 300086e8 <readv+0x128> <== NOT EXECUTED
bytes = (*iop->pathinfo.handlers->read_h)(
300086b0: e8950006 ldm r5, {r1, r2} <== NOT EXECUTED
300086b4: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
300086b8: e1a00006 mov r0, r6 <== NOT EXECUTED
300086bc: e1a0e00f mov lr, pc <== NOT EXECUTED
300086c0: e593f008 ldr pc, [r3, #8] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
300086c4: e3500000 cmp r0, #0 <== NOT EXECUTED
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
300086c8: e2877001 add r7, r7, #1 <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
300086cc: aaffffe9 bge 30008678 <readv+0xb8> <== NOT EXECUTED
return -1;
300086d0: e3e08000 mvn r8, #0 <== NOT EXECUTED 300086d4: ea000003 b 300086e8 <readv+0x128> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
300086d8: eb0026bc bl 300121d0 <__errno> <== NOT EXECUTED 300086dc: e3a03016 mov r3, #22 <== NOT EXECUTED 300086e0: e5803000 str r3, [r0] <== NOT EXECUTED 300086e4: e3e08000 mvn r8, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
300086e8: e1a00008 mov r0, r8 <== NOT EXECUTED
300086ec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
300086f0: eb0026b6 bl 300121d0 <__errno> <== NOT EXECUTED 300086f4: e3a03009 mov r3, #9 <== NOT EXECUTED 300086f8: e5803000 str r3, [r0] <== NOT EXECUTED 300086fc: e3e08000 mvn r8, #0 <== NOT EXECUTED 30008700: eafffff8 b 300086e8 <readv+0x128> <== NOT EXECUTED
30016abc <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
30016abc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30016ac0: e59f2118 ldr r2, [pc, #280] ; 30016be0 <realloc+0x124>
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016ac4: e59f5118 ldr r5, [pc, #280] ; 30016be4 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30016ac8: e5922000 ldr r2, [r2]
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016acc: e5953010 ldr r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30016ad0: e3520003 cmp r2, #3
)
{
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016ad4: e2833001 add r3, r3, #1
void *realloc(
void *ptr,
size_t size
)
{
30016ad8: e24dd004 sub sp, sp, #4 30016adc: e1a04000 mov r4, r0 30016ae0: e1a06001 mov r6, r1
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
30016ae4: e5853010 str r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
30016ae8: 0a000020 beq 30016b70 <realloc+0xb4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
30016aec: e3540000 cmp r4, #0
30016af0: 0a00001a beq 30016b60 <realloc+0xa4>
return malloc( size );
if ( !size ) {
30016af4: e3560000 cmp r6, #0
30016af8: 0a00000f beq 30016b3c <realloc+0x80>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
30016afc: e59f70e4 ldr r7, [pc, #228] ; 30016be8 <realloc+0x12c> 30016b00: e1a01004 mov r1, r4 30016b04: e5970000 ldr r0, [r7] 30016b08: e1a0200d mov r2, sp 30016b0c: eb000065 bl 30016ca8 <_Protected_heap_Get_block_size> 30016b10: e2508000 subs r8, r0, #0
30016b14: 0a00000c beq 30016b4c <realloc+0x90>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
30016b18: e5970000 ldr r0, [r7] 30016b1c: e1a01004 mov r1, r4 30016b20: e1a02006 mov r2, r6 30016b24: eb000070 bl 30016cec <_Protected_heap_Resize_block> 30016b28: e3500000 cmp r0, #0
30016b2c: 0a00001a beq 30016b9c <realloc+0xe0>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
30016b30: e1a00004 mov r0, r4
30016b34: e28dd004 add sp, sp, #4
30016b38: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
30016b3c: e1a00004 mov r0, r4 <== NOT EXECUTED 30016b40: ebffbe54 bl 30006498 <free> <== NOT EXECUTED
return (void *) 0;
30016b44: e1a04006 mov r4, r6 <== NOT EXECUTED 30016b48: eafffff8 b 30016b30 <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
30016b4c: ebffe975 bl 30011128 <__errno> <== NOT EXECUTED 30016b50: e3a03016 mov r3, #22 <== NOT EXECUTED 30016b54: e5803000 str r3, [r0] <== NOT EXECUTED
return (void *) 0;
30016b58: e1a04008 mov r4, r8 <== NOT EXECUTED 30016b5c: eafffff3 b 30016b30 <realloc+0x74> <== NOT EXECUTED
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
30016b60: e1a00006 mov r0, r6 30016b64: ebffbf25 bl 30006800 <malloc> 30016b68: e1a04000 mov r4, r0 30016b6c: eaffffef b 30016b30 <realloc+0x74>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
30016b70: e59f3074 ldr r3, [pc, #116] ; 30016bec <realloc+0x130> 30016b74: e5933000 ldr r3, [r3] 30016b78: e3530000 cmp r3, #0
return (void *) 0;
30016b7c: 13a04000 movne r4, #0
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
30016b80: 1affffea bne 30016b30 <realloc+0x74>
return (void *) 0;
if (_ISR_Nest_level > 0)
30016b84: e59f2064 ldr r2, [pc, #100] ; 30016bf0 <realloc+0x134> 30016b88: e5922000 ldr r2, [r2] 30016b8c: e3520000 cmp r2, #0
return (void *) 0;
30016b90: 11a04003 movne r4, r3
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
30016b94: 0affffd4 beq 30016aec <realloc+0x30>
30016b98: eaffffe4 b 30016b30 <realloc+0x74> <== NOT EXECUTED
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
30016b9c: e1a00006 mov r0, r6 30016ba0: ebffbf16 bl 30006800 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30016ba4: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
30016ba8: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
30016bac: e2433001 sub r3, r3, #1 30016bb0: e5853004 str r3, [r5, #4]
if ( !new_area ) {
return (void *) 0;
30016bb4: 01a04007 moveq r4, r7
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
30016bb8: 0affffdc beq 30016b30 <realloc+0x74>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
30016bbc: e59d2000 ldr r2, [sp] <== NOT EXECUTED 30016bc0: e1a01004 mov r1, r4 <== NOT EXECUTED 30016bc4: e1560002 cmp r6, r2 <== NOT EXECUTED 30016bc8: 31a02006 movcc r2, r6 <== NOT EXECUTED 30016bcc: ebffeb83 bl 300119e0 <memcpy> <== NOT EXECUTED
free( ptr );
30016bd0: e1a00004 mov r0, r4 <== NOT EXECUTED 30016bd4: ebffbe2f bl 30006498 <free> <== NOT EXECUTED
return new_area;
30016bd8: e1a04007 mov r4, r7 <== NOT EXECUTED 30016bdc: eaffffd3 b 30016b30 <realloc+0x74> <== NOT EXECUTED
30007820 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
30007820: e92d40f0 push {r4, r5, r6, r7, lr}
30007824: e24dd030 sub sp, sp, #48 ; 0x30
30007828: e1a07000 mov r7, r0
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
3000782c: ebfffc2c bl 300068e4 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
30007830: e2505000 subs r5, r0, #0
30007834: 1a000045 bne 30007950 <rmdir+0x130>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
30007838: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000783c: e1a00007 mov r0, r7 <== NOT EXECUTED 30007840: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 30007844: e1a02004 mov r2, r4 <== NOT EXECUTED 30007848: eb00004c bl 30007980 <rtems_filesystem_get_start_loc> <== NOT EXECUTED
const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false;
3000784c: e1a06005 mov r6, r5 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007850: e28dc004 add ip, sp, #4
30007854: e1a0e004 mov lr, r4
30007858: e8be000f ldm lr!, {r0, r1, r2, r3}
3000785c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = pathname + parentpathlen;
30007860: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
30007864: e59e3000 ldr r3, [lr]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007868: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000786c: e58c3000 str r3, [ip]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
30007870: eb002c1b bl 300128e4 <strlen> 30007874: e1a01000 mov r1, r0 30007878: e1a00005 mov r0, r5 3000787c: ebfffc27 bl 30006920 <rtems_filesystem_prefix_separators> 30007880: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
30007884: e1a00007 mov r0, r7 30007888: eb002c15 bl 300128e4 <strlen> 3000788c: e28d5004 add r5, sp, #4 30007890: e1a01000 mov r1, r0 30007894: e3a02000 mov r2, #0 30007898: e1a00007 mov r0, r7 3000789c: e1a03005 mov r3, r5 300078a0: e58d2000 str r2, [sp] 300078a4: ebfffbdc bl 3000681c <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
300078a8: e3500000 cmp r0, #0
300078ac: 1a000015 bne 30007908 <rmdir+0xe8>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
300078b0: e1a00005 mov r0, r5 300078b4: e59d3010 ldr r3, [sp, #16] 300078b8: e1a0e00f mov lr, pc 300078bc: e593f010 ldr pc, [r3, #16] 300078c0: e3500001 cmp r0, #1
300078c4: 1a000013 bne 30007918 <rmdir+0xf8>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
300078c8: e1a01005 mov r1, r5 300078cc: e59d300c ldr r3, [sp, #12] 300078d0: e1a00004 mov r0, r4 300078d4: e1a0e00f mov lr, pc 300078d8: e593f034 ldr pc, [r3, #52] ; 0x34 300078dc: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
300078e0: e1a00005 mov r0, r5 300078e4: ebfffc22 bl 30006974 <rtems_filesystem_freenode>
if ( free_parentloc )
300078e8: e3560000 cmp r6, #0
300078ec: 1a000002 bne 300078fc <rmdir+0xdc>
rtems_filesystem_freenode( &parentloc );
return result;
}
300078f0: e1a00007 mov r0, r7
300078f4: e28dd030 add sp, sp, #48 ; 0x30
300078f8: e8bd80f0 pop {r4, r5, r6, r7, pc}
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
300078fc: e1a00004 mov r0, r4 30007900: ebfffc1b bl 30006974 <rtems_filesystem_freenode> 30007904: eafffff9 b 300078f0 <rmdir+0xd0>
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
30007908: e3560000 cmp r6, #0 <== NOT EXECUTED 3000790c: 1a00000b bne 30007940 <rmdir+0x120> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
return -1;
30007910: e3e07000 mvn r7, #0 <== NOT EXECUTED 30007914: eafffff5 b 300078f0 <rmdir+0xd0> <== NOT EXECUTED
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
30007918: e1a00005 mov r0, r5 <== NOT EXECUTED 3000791c: ebfffc14 bl 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
30007920: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
30007924: 11a00004 movne r0, r4 <== NOT EXECUTED 30007928: 1bfffc11 blne 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
3000792c: eb00282d bl 300119e8 <__errno> <== NOT EXECUTED 30007930: e3a03014 mov r3, #20 <== NOT EXECUTED 30007934: e5803000 str r3, [r0] <== NOT EXECUTED 30007938: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000793c: eaffffeb b 300078f0 <rmdir+0xd0> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
30007940: e1a00004 mov r0, r4 <== NOT EXECUTED 30007944: ebfffc0a bl 30006974 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
30007948: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000794c: eaffffe7 b 300078f0 <rmdir+0xd0> <== NOT EXECUTED
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
30007950: e3a03000 mov r3, #0 30007954: e28d4018 add r4, sp, #24 30007958: e58d3000 str r3, [sp] 3000795c: e3a02002 mov r2, #2 30007960: e1a00007 mov r0, r7 30007964: e1a01005 mov r1, r5 30007968: e1a03004 mov r3, r4 3000796c: ebfffbc6 bl 3000688c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
30007970: e3500000 cmp r0, #0
30007974: 1affffe5 bne 30007910 <rmdir+0xf0>
return -1;
free_parentloc = true;
30007978: e3a06001 mov r6, #1 3000797c: eaffffb3 b 30007850 <rmdir+0x30>
30006e3c <rtems_assoc_local_by_name>:
uint32_t rtems_assoc_local_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30006e3c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
30006e40: eb000091 bl 3000708c <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30006e44: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->local_value;
30006e48: 15900004 ldrne r0, [r0, #4] <== NOT EXECUTED
return 0;
}
30006e4c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3001649c <rtems_assoc_name_bad>:
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
}
3001649c: e59f0000 ldr r0, [pc, #0] ; 300164a4 <rtems_assoc_name_bad+0x8><== NOT EXECUTED 300164a0: e12fff1e bx lr <== NOT EXECUTED
30013a6c <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013a6c: e92d4010 push {r4, lr} <== NOT EXECUTED
30013a70: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
30013a74: eb000006 bl 30013a94 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
30013a78: e3500000 cmp r0, #0 <== NOT EXECUTED 30013a7c: 0a000001 beq 30013a88 <rtems_assoc_name_by_local+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
30013a80: e5900000 ldr r0, [r0] <== NOT EXECUTED
30013a84: e8bd8010 pop {r4, pc} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
30013a88: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30013a8c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
30013a90: ea000a81 b 3001649c <rtems_assoc_name_bad> <== NOT EXECUTED
30006eb8 <rtems_assoc_name_by_local_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006eb8: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006ebc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006ec0: e1a06002 mov r6, r2 <== NOT EXECUTED
30006ec4: e1a08000 mov r8, r0 <== NOT EXECUTED
30006ec8: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006ecc: e5c23000 strb r3, [r2] <== NOT EXECUTED 30006ed0: e3a05020 mov r5, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006ed4: e3a04001 mov r4, #1 <== NOT EXECUTED 30006ed8: ea000008 b 30006f00 <rtems_assoc_name_by_local_bitfield+0x48><== NOT EXECUTED
if (b & value) {
if (*buffer)
strcat(buffer, " ");
strcat(buffer, rtems_assoc_name_by_local(ap, b));
30006edc: e1a01004 mov r1, r4 <== NOT EXECUTED 30006ee0: e1a00008 mov r0, r8 <== NOT EXECUTED 30006ee4: eb000014 bl 30006f3c <rtems_assoc_name_by_local> <== NOT EXECUTED 30006ee8: e1a01000 mov r1, r0 <== NOT EXECUTED 30006eec: e1a00006 mov r0, r6 <== NOT EXECUTED 30006ef0: eb002f14 bl 30012b48 <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006ef4: e2555001 subs r5, r5, #1 <== NOT EXECUTED 30006ef8: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 30006efc: 0a00000b beq 30006f30 <rtems_assoc_name_by_local_bitfield+0x78><== NOT EXECUTED
if (b & value) {
30006f00: e1140007 tst r4, r7 <== NOT EXECUTED 30006f04: 0afffffa beq 30006ef4 <rtems_assoc_name_by_local_bitfield+0x3c><== NOT EXECUTED
if (*buffer)
30006f08: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006f0c: e3530000 cmp r3, #0 <== NOT EXECUTED 30006f10: 0afffff1 beq 30006edc <rtems_assoc_name_by_local_bitfield+0x24><== NOT EXECUTED
strcat(buffer, " ");
30006f14: e1a00006 mov r0, r6 <== NOT EXECUTED 30006f18: eb003011 bl 30012f64 <strlen> <== NOT EXECUTED 30006f1c: e3a02002 mov r2, #2 <== NOT EXECUTED 30006f20: e0860000 add r0, r6, r0 <== NOT EXECUTED 30006f24: e59f100c ldr r1, [pc, #12] ; 30006f38 <rtems_assoc_name_by_local_bitfield+0x80><== NOT EXECUTED 30006f28: eb002e51 bl 30012874 <memcpy> <== NOT EXECUTED 30006f2c: eaffffea b 30006edc <rtems_assoc_name_by_local_bitfield+0x24><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_local(ap, b));
}
}
return buffer;
}
30006f30: e1a00006 mov r0, r6 <== NOT EXECUTED
30006f34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006fe8 <rtems_assoc_name_by_remote>:
const char *rtems_assoc_name_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30006fe8: e92d4010 push {r4, lr} <== NOT EXECUTED
30006fec: e1a04001 mov r4, r1 <== NOT EXECUTED
const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value);
30006ff0: eb00004b bl 30007124 <rtems_assoc_ptr_by_remote> <== NOT EXECUTED
if (nap)
30006ff4: e3500000 cmp r0, #0 <== NOT EXECUTED 30006ff8: 0a000001 beq 30007004 <rtems_assoc_name_by_remote+0x1c> <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(remote_value);
}
30006ffc: e5900000 ldr r0, [r0] <== NOT EXECUTED
30007000: e8bd8010 pop {r4, pc} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
30007004: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30007008: e8bd4010 pop {r4, lr} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(remote_value);
3000700c: ea0020ed b 3000f3c8 <rtems_assoc_name_bad> <== NOT EXECUTED
30006f64 <rtems_assoc_name_by_remote_bitfield>:
char *buffer
)
{
uint32_t b;
*buffer = 0;
30006f64: e3a03000 mov r3, #0 <== NOT EXECUTED
char *rtems_assoc_name_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t value,
char *buffer
)
{
30006f68: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006f6c: e1a06002 mov r6, r2 <== NOT EXECUTED
30006f70: e1a08000 mov r8, r0 <== NOT EXECUTED
30006f74: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t b;
*buffer = 0;
30006f78: e5c23000 strb r3, [r2] <== NOT EXECUTED 30006f7c: e3a05020 mov r5, #32 <== NOT EXECUTED
for (b = 1; b; b <<= 1) {
30006f80: e3a04001 mov r4, #1 <== NOT EXECUTED 30006f84: ea000008 b 30006fac <rtems_assoc_name_by_remote_bitfield+0x48><== NOT EXECUTED
if (b & value) {
if (*buffer)
strcat(buffer, " ");
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
30006f88: e1a01004 mov r1, r4 <== NOT EXECUTED 30006f8c: e1a00008 mov r0, r8 <== NOT EXECUTED 30006f90: eb000014 bl 30006fe8 <rtems_assoc_name_by_remote> <== NOT EXECUTED 30006f94: e1a01000 mov r1, r0 <== NOT EXECUTED 30006f98: e1a00006 mov r0, r6 <== NOT EXECUTED 30006f9c: eb002ee9 bl 30012b48 <strcat> <== NOT EXECUTED
{
uint32_t b;
*buffer = 0;
for (b = 1; b; b <<= 1) {
30006fa0: e2555001 subs r5, r5, #1 <== NOT EXECUTED 30006fa4: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 30006fa8: 0a00000b beq 30006fdc <rtems_assoc_name_by_remote_bitfield+0x78><== NOT EXECUTED
if (b & value) {
30006fac: e1140007 tst r4, r7 <== NOT EXECUTED 30006fb0: 0afffffa beq 30006fa0 <rtems_assoc_name_by_remote_bitfield+0x3c><== NOT EXECUTED
if (*buffer)
30006fb4: e5d63000 ldrb r3, [r6] <== NOT EXECUTED 30006fb8: e3530000 cmp r3, #0 <== NOT EXECUTED 30006fbc: 0afffff1 beq 30006f88 <rtems_assoc_name_by_remote_bitfield+0x24><== NOT EXECUTED
strcat(buffer, " ");
30006fc0: e1a00006 mov r0, r6 <== NOT EXECUTED 30006fc4: eb002fe6 bl 30012f64 <strlen> <== NOT EXECUTED 30006fc8: e3a02002 mov r2, #2 <== NOT EXECUTED 30006fcc: e0860000 add r0, r6, r0 <== NOT EXECUTED 30006fd0: e59f100c ldr r1, [pc, #12] ; 30006fe4 <rtems_assoc_name_by_remote_bitfield+0x80><== NOT EXECUTED 30006fd4: eb002e26 bl 30012874 <memcpy> <== NOT EXECUTED 30006fd8: eaffffea b 30006f88 <rtems_assoc_name_by_remote_bitfield+0x24><== NOT EXECUTED
strcat(buffer, rtems_assoc_name_by_remote(ap, b));
}
}
return buffer;
}
30006fdc: e1a00006 mov r0, r6 <== NOT EXECUTED
30006fe0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30013a94 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013a94: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30013a98: e1a04000 mov r4, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30013a9c: e5900000 ldr r0, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
30013aa0: e1a05001 mov r5, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30013aa4: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
30013aa8: 01a04000 moveq r4, r0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30013aac: 0a00000a beq 30013adc <rtems_assoc_ptr_by_local+0x48> <== NOT EXECUTED 30013ab0: e59f1054 ldr r1, [pc, #84] ; 30013b0c <rtems_assoc_ptr_by_local+0x78><== NOT EXECUTED 30013ab4: eb000f66 bl 30017854 <strcmp> <== NOT EXECUTED 30013ab8: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
30013abc: 13a02000 movne r2, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
30013ac0: 1a00000a bne 30013af0 <rtems_assoc_ptr_by_local+0x5c> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
30013ac4: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
30013ac8: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
30013acc: e3520000 cmp r2, #0 <== NOT EXECUTED 30013ad0: 11a02004 movne r2, r4 <== NOT EXECUTED 30013ad4: 11a04003 movne r4, r3 <== NOT EXECUTED 30013ad8: 1a000004 bne 30013af0 <rtems_assoc_ptr_by_local+0x5c> <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
}
30013adc: e1a00004 mov r0, r4 <== NOT EXECUTED
30013ae0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30013ae4: e5b4300c ldr r3, [r4, #12]! <== NOT EXECUTED 30013ae8: e3530000 cmp r3, #0 <== NOT EXECUTED 30013aec: 0a000003 beq 30013b00 <rtems_assoc_ptr_by_local+0x6c> <== NOT EXECUTED
if (ap->local_value == local_value)
30013af0: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30013af4: e1530005 cmp r3, r5 <== NOT EXECUTED 30013af8: 1afffff9 bne 30013ae4 <rtems_assoc_ptr_by_local+0x50> <== NOT EXECUTED 30013afc: eafffff6 b 30013adc <rtems_assoc_ptr_by_local+0x48> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30013b00: e1a04002 mov r4, r2 <== NOT EXECUTED
if (ap->local_value == local_value)
return ap;
return default_ap;
}
30013b04: e1a00004 mov r0, r4 <== NOT EXECUTED
30013b08: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000708c <rtems_assoc_ptr_by_name>:
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
3000708c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30007090: e5904000 ldr r4, [r0] <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30007094: e1a06000 mov r6, r0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30007098: e3540000 cmp r4, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
3000709c: e1a07001 mov r7, r1 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
300070a0: 01a06004 moveq r6, r4 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
300070a4: 0a000011 beq 300070f0 <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED 300070a8: e1a00004 mov r0, r4 <== NOT EXECUTED 300070ac: e59f106c ldr r1, [pc, #108] ; 30007120 <rtems_assoc_ptr_by_name+0x94><== NOT EXECUTED 300070b0: eb002ecf bl 30012bf4 <strcmp> <== NOT EXECUTED 300070b4: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *rtems_assoc_ptr_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
const rtems_assoc_t *default_ap = 0;
300070b8: 13a08000 movne r8, #0 <== NOT EXECUTED
if (rtems_assoc_is_default(ap))
300070bc: 0a00000d beq 300070f8 <rtems_assoc_ptr_by_name+0x6c> <== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
300070c0: e1a05006 mov r5, r6 <== NOT EXECUTED 300070c4: ea000003 b 300070d8 <rtems_assoc_ptr_by_name+0x4c> <== NOT EXECUTED 300070c8: e595400c ldr r4, [r5, #12] <== NOT EXECUTED 300070cc: e285500c add r5, r5, #12 <== NOT EXECUTED 300070d0: e3540000 cmp r4, #0 <== NOT EXECUTED 300070d4: 0a00000e beq 30007114 <rtems_assoc_ptr_by_name+0x88> <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
300070d8: e1a00004 mov r0, r4 <== NOT EXECUTED 300070dc: e1a01007 mov r1, r7 <== NOT EXECUTED 300070e0: eb002ec3 bl 30012bf4 <strcmp> <== NOT EXECUTED 300070e4: e3500000 cmp r0, #0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
300070e8: e1a06005 mov r6, r5 <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
300070ec: 1afffff5 bne 300070c8 <rtems_assoc_ptr_by_name+0x3c> <== NOT EXECUTED
return ap;
return default_ap;
}
300070f0: e1a00006 mov r0, r6 <== NOT EXECUTED
300070f4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
300070f8: e596400c ldr r4, [r6, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
300070fc: e286300c add r3, r6, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
30007100: e3540000 cmp r4, #0 <== NOT EXECUTED 30007104: 11a08006 movne r8, r6 <== NOT EXECUTED 30007108: 11a06003 movne r6, r3 <== NOT EXECUTED 3000710c: 1affffeb bne 300070c0 <rtems_assoc_ptr_by_name+0x34> <== NOT EXECUTED 30007110: eafffff6 b 300070f0 <rtems_assoc_ptr_by_name+0x64> <== NOT EXECUTED 30007114: e1a06008 mov r6, r8 <== NOT EXECUTED
if (strcmp(ap->name, name) == 0)
return ap;
return default_ap;
}
30007118: e1a00006 mov r0, r6 <== NOT EXECUTED
3000711c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30010c2c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30010c2c: e92d4030 push {r4, r5, lr}
30010c30: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30010c34: e5900000 ldr r0, [r0]
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
30010c38: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
30010c3c: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
30010c40: 01a04000 moveq r4, r0
if (rtems_assoc_is_default(ap))
30010c44: 0a00000a beq 30010c74 <rtems_assoc_ptr_by_remote+0x48>
30010c48: e59f1054 ldr r1, [pc, #84] ; 30010ca4 <rtems_assoc_ptr_by_remote+0x78> 30010c4c: eb000443 bl 30011d60 <strcmp> 30010c50: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
30010c54: 13a02000 movne r2, #0
if (rtems_assoc_is_default(ap))
30010c58: 1a00000a bne 30010c88 <rtems_assoc_ptr_by_remote+0x5c>
default_ap = ap++;
for ( ; ap->name; ap++)
30010c5c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
30010c60: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
30010c64: e3520000 cmp r2, #0 <== NOT EXECUTED 30010c68: 11a02004 movne r2, r4 <== NOT EXECUTED 30010c6c: 11a04003 movne r4, r3 <== NOT EXECUTED 30010c70: 1a000004 bne 30010c88 <rtems_assoc_ptr_by_remote+0x5c> <== NOT EXECUTED
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
30010c74: e1a00004 mov r0, r4
30010c78: e8bd8030 pop {r4, r5, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30010c7c: e5b4300c ldr r3, [r4, #12]! 30010c80: e3530000 cmp r3, #0
30010c84: 0a000003 beq 30010c98 <rtems_assoc_ptr_by_remote+0x6c>
if (ap->remote_value == remote_value)
30010c88: e5943008 ldr r3, [r4, #8] 30010c8c: e1530005 cmp r3, r5
30010c90: 1afffff9 bne 30010c7c <rtems_assoc_ptr_by_remote+0x50>
30010c94: eafffff6 b 30010c74 <rtems_assoc_ptr_by_remote+0x48>
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
30010c98: e1a04002 mov r4, r2
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
30010c9c: e1a00004 mov r0, r4
30010ca0: e8bd8030 pop {r4, r5, pc}
300071f4 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300071f4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
300071f8: ebffff84 bl 30007010 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
300071fc: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30007200: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30007204: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300071a0 <rtems_assoc_remote_by_local_bitfield>:
uint32_t rtems_assoc_remote_by_local_bitfield(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
300071a0: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
300071a4: e1a08000 mov r8, r0 <== NOT EXECUTED
300071a8: e1a06001 mov r6, r1 <== NOT EXECUTED
300071ac: e3a05020 mov r5, #32 <== NOT EXECUTED
uint32_t b; uint32_t remote_value = 0;
300071b0: e3a07000 mov r7, #0 <== NOT EXECUTED
for (b = 1; b; b <<= 1)
300071b4: e3a04001 mov r4, #1 <== NOT EXECUTED 300071b8: ea000002 b 300071c8 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED 300071bc: e2555001 subs r5, r5, #1 <== NOT EXECUTED 300071c0: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 300071c4: 0a000008 beq 300071ec <rtems_assoc_remote_by_local_bitfield+0x4c><== NOT EXECUTED
if (b & local_value)
300071c8: e1140006 tst r4, r6 <== NOT EXECUTED 300071cc: 0afffffa beq 300071bc <rtems_assoc_remote_by_local_bitfield+0x1c><== NOT EXECUTED
remote_value |= rtems_assoc_remote_by_local(ap, b);
300071d0: e1a01004 mov r1, r4 <== NOT EXECUTED 300071d4: e1a00008 mov r0, r8 <== NOT EXECUTED 300071d8: eb000005 bl 300071f4 <rtems_assoc_remote_by_local> <== NOT EXECUTED
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
300071dc: e2555001 subs r5, r5, #1 <== NOT EXECUTED
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
300071e0: e1877000 orr r7, r7, r0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t remote_value = 0;
for (b = 1; b; b <<= 1)
300071e4: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED 300071e8: 1afffff6 bne 300071c8 <rtems_assoc_remote_by_local_bitfield+0x28><== NOT EXECUTED
if (b & local_value)
remote_value |= rtems_assoc_remote_by_local(ap, b);
return remote_value;
}
300071ec: e1a00007 mov r0, r7 <== NOT EXECUTED
300071f0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30007208 <rtems_assoc_remote_by_name>:
uint32_t rtems_assoc_remote_by_name(
const rtems_assoc_t *ap,
const char *name
)
{
30007208: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_name(ap, name);
3000720c: ebffff9e bl 3000708c <rtems_assoc_ptr_by_name> <== NOT EXECUTED
if (nap)
30007210: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
30007214: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
30007218: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30011900 <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011900: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30011904: e2504000 subs r4, r0, #0
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
30011908: e24dd008 sub sp, sp, #8 3001190c: e1a05001 mov r5, r1 30011910: e1a07003 mov r7, r3
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30011914: 03a00003 moveq r0, #3
)
{
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
30011918: 0a00001e beq 30011998 <rtems_barrier_create+0x98>
return RTEMS_INVALID_NAME;
if ( !id )
3001191c: e3530000 cmp r3, #0
return RTEMS_INVALID_ADDRESS;
30011920: 03a00009 moveq r0, #9
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30011924: 0a00001b beq 30011998 <rtems_barrier_create+0x98>
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
30011928: e3110010 tst r1, #16
3001192c: 0a00001b beq 300119a0 <rtems_barrier_create+0xa0>
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30011930: e3a03000 mov r3, #0 <== NOT EXECUTED
if ( maximum_waiters == 0 )
30011934: e3520000 cmp r2, #0 <== NOT EXECUTED
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
30011938: e58d3000 str r3, [sp] <== NOT EXECUTED
if ( maximum_waiters == 0 )
3001193c: 0a00001a beq 300119ac <rtems_barrier_create+0xac> <== NOT EXECUTED
30011940: e59f3078 ldr r3, [pc, #120] ; 300119c0 <rtems_barrier_create+0xc0>
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
30011944: e58d2004 str r2, [sp, #4] 30011948: e5932000 ldr r2, [r3] 3001194c: e2822001 add r2, r2, #1 30011950: e5832000 str r2, [r3]
* This function allocates a barrier control block from
* the inactive chain of free barrier control blocks.
*/
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Allocate( void )
{
return (Barrier_Control *) _Objects_Allocate( &_Barrier_Information );
30011954: e59f8068 ldr r8, [pc, #104] ; 300119c4 <rtems_barrier_create+0xc4> 30011958: e1a00008 mov r0, r8 3001195c: ebffeda3 bl 3000cff0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
30011960: e2506000 subs r6, r0, #0
30011964: 0a000012 beq 300119b4 <rtems_barrier_create+0xb4>
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30011968: e2860014 add r0, r6, #20 3001196c: e1a0100d mov r1, sp
if ( !the_barrier ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
30011970: e5865010 str r5, [r6, #16]
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
30011974: eb00024c bl 300122ac <_CORE_barrier_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30011978: e5963008 ldr r3, [r6, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001197c: e598201c ldr r2, [r8, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30011980: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30011984: e7826721 str r6, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30011988: e586400c str r4, [r6, #12]
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
3001198c: e5873000 str r3, [r7]
_Thread_Enable_dispatch();
30011990: ebfff202 bl 3000e1a0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30011994: e3a00000 mov r0, #0
}
30011998: e28dd008 add sp, sp, #8
3001199c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
300119a0: e3a03001 mov r3, #1 300119a4: e58d3000 str r3, [sp] 300119a8: eaffffe4 b 30011940 <rtems_barrier_create+0x40>
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
300119ac: e3a0000a mov r0, #10 <== NOT EXECUTED 300119b0: eafffff8 b 30011998 <rtems_barrier_create+0x98> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
_Thread_Enable_dispatch();
300119b4: ebfff1f9 bl 3000e1a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
300119b8: e3a00005 mov r0, #5 <== NOT EXECUTED 300119bc: eafffff5 b 30011998 <rtems_barrier_create+0x98> <== NOT EXECUTED
30011a78 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
30011a78: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
30011a7c: e2516000 subs r6, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
30011a80: e1a05000 mov r5, r0 <== NOT EXECUTED 30011a84: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
return RTEMS_INVALID_ADDRESS;
30011a88: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
30011a8c: 0a00000e beq 30011acc <rtems_barrier_release+0x54> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
_Objects_Get( &_Barrier_Information, id, location );
30011a90: e59f003c ldr r0, [pc, #60] ; 30011ad4 <rtems_barrier_release+0x5c><== NOT EXECUTED 30011a94: e1a01005 mov r1, r5 <== NOT EXECUTED 30011a98: e1a0200d mov r2, sp <== NOT EXECUTED 30011a9c: ebffee84 bl 3000d4b4 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
30011aa0: e59d4000 ldr r4, [sp] <== NOT EXECUTED 30011aa4: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30011aa8: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !released )
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
30011aac: 1a000006 bne 30011acc <rtems_barrier_release+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
30011ab0: e1a01005 mov r1, r5 <== NOT EXECUTED 30011ab4: e1a02004 mov r2, r4 <== NOT EXECUTED 30011ab8: e2800014 add r0, r0, #20 <== NOT EXECUTED 30011abc: eb000205 bl 300122d8 <_CORE_barrier_Release> <== NOT EXECUTED 30011ac0: e5860000 str r0, [r6] <== NOT EXECUTED
_Thread_Enable_dispatch();
30011ac4: ebfff1b5 bl 3000e1a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30011ac8: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30011acc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30011ad0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30011ad8 <rtems_barrier_wait>:
rtems_status_code rtems_barrier_wait(
rtems_id id,
rtems_interval timeout
)
{
30011ad8: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
30011adc: e1a04000 mov r4, r0 <== NOT EXECUTED
30011ae0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30011ae4: e1a05001 mov r5, r1 <== NOT EXECUTED
30011ae8: e59f004c ldr r0, [pc, #76] ; 30011b3c <rtems_barrier_wait+0x64><== NOT EXECUTED
30011aec: e1a01004 mov r1, r4 <== NOT EXECUTED
30011af0: e28d2004 add r2, sp, #4 <== NOT EXECUTED
30011af4: ebffee6e bl 3000d4b4 <_Objects_Get> <== NOT EXECUTED
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
30011af8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30011afc: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30011b00: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
30011b04: 1a00000a bne 30011b34 <rtems_barrier_wait+0x5c> <== NOT EXECUTED
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
30011b08: e2800014 add r0, r0, #20 <== NOT EXECUTED 30011b0c: e58d3000 str r3, [sp] <== NOT EXECUTED 30011b10: e3a02001 mov r2, #1 <== NOT EXECUTED 30011b14: e1a03005 mov r3, r5 <== NOT EXECUTED 30011b18: e1a01004 mov r1, r4 <== NOT EXECUTED 30011b1c: eb0001f9 bl 30012308 <_CORE_barrier_Wait> <== NOT EXECUTED
id,
true,
timeout,
NULL
);
_Thread_Enable_dispatch();
30011b20: ebfff19e bl 3000e1a0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return _Barrier_Translate_core_barrier_return_code(
_Thread_Executing->Wait.return_code );
30011b24: e59f3014 ldr r3, [pc, #20] ; 30011b40 <rtems_barrier_wait+0x68><== NOT EXECUTED 30011b28: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
true,
timeout,
NULL
);
_Thread_Enable_dispatch();
return _Barrier_Translate_core_barrier_return_code(
30011b2c: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 30011b30: eb000478 bl 30012d18 <_Barrier_Translate_core_barrier_return_code><== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30011b34: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30011b38: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b9e4 <rtems_build_id>:
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
3000b9e4: e1a00c00 lsl r0, r0, #24 <== NOT EXECUTED 3000b9e8: e1800d81 orr r0, r0, r1, lsl #27 <== NOT EXECUTED
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
3000b9ec: e1800003 orr r0, r0, r3 <== NOT EXECUTED
uint32_t node,
uint32_t index
)
{
return _Objects_Build_id( api, class, node, index );
}
3000b9f0: e1800802 orr r0, r0, r2, lsl #16 <== NOT EXECUTED 3000b9f4: e12fff1e bx lr <== NOT EXECUTED
3000b9f8 <rtems_build_name>:
char C1,
char C2,
char C3,
char C4
)
{
3000b9f8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000b9fc: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000ba00: e20118ff and r1, r1, #16711680 ; 0xff0000 <== NOT EXECUTED 3000ba04: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3000ba08: e2022cff and r2, r2, #65280 ; 0xff00 <== NOT EXECUTED
char C1,
char C2,
char C3,
char C4
)
{
3000ba0c: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED
return _Objects_Build_name( C1, C2, C3, C4 );
3000ba10: e1811002 orr r1, r1, r2 <== NOT EXECUTED
}
3000ba14: e1810003 orr r0, r1, r3 <== NOT EXECUTED 3000ba18: e12fff1e bx lr <== NOT EXECUTED
3000aa20 <rtems_chain_append_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000aa20: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aa24: e1a04002 mov r4, r2 <== NOT EXECUTED
3000aa28: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Append_with_empty_check( chain, node );
3000aa2c: eb000134 bl 3000af04 <_Chain_Append_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
3000aa30: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aa34: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aa38: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa3c: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aa40: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_append_with_empty_check( chain, node );
if ( was_empty ) {
sc = rtems_event_send( task, events );
3000aa44: eafffd87 b 3000a068 <rtems_event_send> <== NOT EXECUTED
3000aa48 <rtems_chain_get_with_notification>:
rtems_chain_control *chain,
rtems_id task,
rtems_event_set events,
rtems_chain_node **node
)
{
3000aa48: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aa4c: e1a04001 mov r4, r1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_get_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node **node
)
{
return _Chain_Get_with_empty_check( chain, node );
3000aa50: e1a01003 mov r1, r3 <== NOT EXECUTED 3000aa54: e1a05002 mov r5, r2 <== NOT EXECUTED 3000aa58: eb00014c bl 3000af90 <_Chain_Get_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
3000aa5c: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aa60: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aa64: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aa68: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aa6c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool is_empty = rtems_chain_get_with_empty_check( chain, node );
if ( is_empty ) {
sc = rtems_event_send( task, events );
3000aa70: eafffd7c b 3000a068 <rtems_event_send> <== NOT EXECUTED
3000aa74 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
3000aa74: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3000aa78: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000aa7c: e1a07000 mov r7, r0 <== NOT EXECUTED
3000aa80: e1a06001 mov r6, r1 <== NOT EXECUTED
3000aa84: e1a05002 mov r5, r2 <== NOT EXECUTED
3000aa88: e1a0a003 mov sl, r3 <== NOT EXECUTED
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aa8c: e1a0800d mov r8, sp <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
3000aa90: e1a00007 mov r0, r7 <== NOT EXECUTED 3000aa94: eb000152 bl 3000afe4 <_Chain_Get> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aa98: e2504000 subs r4, r0, #0 <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aa9c: e1a02005 mov r2, r5 <== NOT EXECUTED 3000aaa0: e1a0300d mov r3, sp <== NOT EXECUTED 3000aaa4: e1a01004 mov r1, r4 <== NOT EXECUTED 3000aaa8: e1a00006 mov r0, r6 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aaac: 1a000005 bne 3000aac8 <rtems_chain_get_with_wait+0x54> <== NOT EXECUTED
) {
rtems_event_set out;
sc = rtems_event_receive(
3000aab0: ebfffd0f bl 30009ef4 <rtems_event_receive> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
3000aab4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aab8: 0afffff4 beq 3000aa90 <rtems_chain_get_with_wait+0x1c> <== NOT EXECUTED
timeout,
&out
);
}
*node_ptr = node;
3000aabc: e58a4000 str r4, [sl] <== NOT EXECUTED
return sc;
}
3000aac0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aac4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
3000aac8: e3a00000 mov r0, #0 <== NOT EXECUTED 3000aacc: eafffffa b 3000aabc <rtems_chain_get_with_wait+0x48> <== NOT EXECUTED
3000aad0 <rtems_chain_prepend_with_notification>:
rtems_chain_control *chain,
rtems_chain_node *node,
rtems_id task,
rtems_event_set events
)
{
3000aad0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000aad4: e1a04002 mov r4, r2 <== NOT EXECUTED
3000aad8: e1a05003 mov r5, r3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check(
rtems_chain_control *chain,
rtems_chain_node *node
)
{
return _Chain_Prepend_with_empty_check( chain, node );
3000aadc: eb000157 bl 3000b040 <_Chain_Prepend_with_empty_check> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
3000aae0: e3500000 cmp r0, #0 <== NOT EXECUTED
3000aae4: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
sc = rtems_event_send( task, events );
3000aae8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aaec: e1a01005 mov r1, r5 <== NOT EXECUTED
}
return sc;
}
3000aaf0: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool was_empty = rtems_chain_prepend_with_empty_check( chain, node );
if (was_empty) {
sc = rtems_event_send( task, events );
3000aaf4: eafffd5b b 3000a068 <rtems_event_send> <== NOT EXECUTED
30017014 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
30017014: e92d4010 push {r4, lr} <== NOT EXECUTED
if ( !time_buffer )
30017018: e2514000 subs r4, r1, #0 <== NOT EXECUTED 3001701c: 0a000012 beq 3001706c <rtems_clock_get+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
30017020: e3500000 cmp r0, #0 <== NOT EXECUTED 30017024: 0a00000d beq 30017060 <rtems_clock_get+0x4c> <== NOT EXECUTED
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
30017028: e3500001 cmp r0, #1 <== NOT EXECUTED 3001702c: 0a000011 beq 30017078 <rtems_clock_get+0x64> <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
30017030: e3500002 cmp r0, #2 <== NOT EXECUTED 30017034: 0a000012 beq 30017084 <rtems_clock_get+0x70> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_since_boot();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
30017038: e3500003 cmp r0, #3 <== NOT EXECUTED 3001703c: 0a000014 beq 30017094 <rtems_clock_get+0x80> <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
30017040: e3500004 cmp r0, #4 <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
30017044: 13a0300a movne r3, #10 <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
30017048: 0a000001 beq 30017054 <rtems_clock_get+0x40> <== NOT EXECUTED
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3001704c: e1a00003 mov r0, r3 <== NOT EXECUTED
30017050: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
30017054: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
30017058: e8bd4010 pop {r4, lr} <== NOT EXECUTED
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
3001705c: ea000060 b 300171e4 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
30017060: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
30017064: e8bd4010 pop {r4, lr} <== NOT EXECUTED
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
30017068: ea000027 b 3001710c <rtems_clock_get_tod> <== NOT EXECUTED
rtems_clock_get_options option,
void *time_buffer
)
{
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
3001706c: e3a03009 mov r3, #9 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
30017070: e1a00003 mov r0, r3 <== NOT EXECUTED
30017074: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
30017078: e1a00004 mov r0, r4 <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TIME_VALUE )
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
return RTEMS_INVALID_NUMBER;
}
3001707c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TOD )
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH )
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
30017080: ea000007 b 300170a4 <rtems_clock_get_seconds_since_epoch> <== NOT EXECUTED
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
30017084: eb00001c bl 300170fc <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017088: e3a03000 mov r3, #0 <== NOT EXECUTED
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
3001708c: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017090: eaffffed b 3001704c <rtems_clock_get+0x38> <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
30017094: eb000010 bl 300170dc <rtems_clock_get_ticks_per_second> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017098: e3a03000 mov r3, #0 <== NOT EXECUTED
}
if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
3001709c: e5840000 str r0, [r4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300170a0: eaffffe9 b 3001704c <rtems_clock_get+0x38> <== NOT EXECUTED
3000a904 <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a904: e2502000 subs r2, r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000a908: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
3000a90c: 012fff1e bxeq lr <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
3000a910: e59f301c ldr r3, [pc, #28] ; 3000a934 <rtems_clock_get_seconds_since_epoch+0x30><== NOT EXECUTED 3000a914: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3000a918: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a91c: 159f3014 ldrne r3, [pc, #20] ; 3000a938 <rtems_clock_get_seconds_since_epoch+0x34><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a920: 13a00000 movne r0, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch();
3000a924: 15933000 ldrne r3, [r3] <== NOT EXECUTED
{
if ( !the_interval )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3000a928: 03a0000b moveq r0, #11 <== NOT EXECUTED
*the_interval = _TOD_Seconds_since_epoch();
3000a92c: 15823000 strne r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL; }
3000a930: e12fff1e bx lr <== NOT EXECUTED
300094b4 <rtems_clock_get_ticks_per_second>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_per_second(void)
{
return TOD_MICROSECONDS_PER_SECOND /
300094b4: e59f3010 ldr r3, [pc, #16] ; 300094cc <rtems_clock_get_ticks_per_second+0x18><== NOT EXECUTED
#include <rtems/score/thread.h>
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_per_second(void)
{
300094b8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return TOD_MICROSECONDS_PER_SECOND /
300094bc: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 300094c0: e59f0008 ldr r0, [pc, #8] ; 300094d0 <rtems_clock_get_ticks_per_second+0x1c><== NOT EXECUTED 300094c4: eb002cda bl 30014834 <__aeabi_uidiv> <== NOT EXECUTED
rtems_configuration_get_microseconds_per_tick();
}
300094c8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300094d4 <rtems_clock_get_ticks_since_boot>:
#include <rtems/score/tod.h>
#include <rtems/score/watchdog.h>
rtems_interval rtems_clock_get_ticks_since_boot(void)
{
return _Watchdog_Ticks_since_boot;
300094d4: e59f3004 ldr r3, [pc, #4] ; 300094e0 <rtems_clock_get_ticks_since_boot+0xc><== NOT EXECUTED 300094d8: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
300094dc: e12fff1e bx lr <== NOT EXECUTED
300171e4 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
300171e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if ( !time )
300171e8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
300171ec: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
if ( !time )
return RTEMS_INVALID_ADDRESS;
300171f0: 03a00009 moveq r0, #9 <== NOT EXECUTED
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
if ( !time )
300171f4: 0a000012 beq 30017244 <rtems_clock_get_tod_timeval+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
300171f8: e59f304c ldr r3, [pc, #76] ; 3001724c <rtems_clock_get_tod_timeval+0x68><== NOT EXECUTED 300171fc: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 30017200: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30017204: 03a0000b moveq r0, #11 <== NOT EXECUTED
)
{
if ( !time )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
30017208: 0a00000d beq 30017244 <rtems_clock_get_tod_timeval+0x60> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001720c: e10f5000 mrs r5, CPSR <== NOT EXECUTED 30017210: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED 30017214: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
30017218: e1a0000d mov r0, sp <== NOT EXECUTED 3001721c: eb0011bb bl 3001b910 <_TOD_Get> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30017220: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30017224: e59f2024 ldr r2, [pc, #36] ; 30017250 <rtems_clock_get_tod_timeval+0x6c><== NOT EXECUTED
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
30017228: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
3001722c: e3a00000 mov r0, #0 <== NOT EXECUTED
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
30017230: e0c21293 smull r1, r2, r3, r2 <== NOT EXECUTED 30017234: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED 30017238: e0633342 rsb r3, r3, r2, asr #6 <== NOT EXECUTED
time->tv_sec = now.tv_sec;
3001723c: e59d2000 ldr r2, [sp] <== NOT EXECUTED
time->tv_usec = useconds;
30017240: e884000c stm r4, {r2, r3} <== NOT EXECUTED
}
30017244: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30017248: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30009708 <rtems_clock_get_uptime>:
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
30009708: e3500000 cmp r0, #0 <== NOT EXECUTED
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
3000970c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if ( !uptime )
30009710: 0a000002 beq 30009720 <rtems_clock_get_uptime+0x18> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime_as_timespec( uptime );
30009714: eb000588 bl 3000ad3c <_TOD_Get_uptime_as_timespec> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009718: e3a00000 mov r0, #0 <== NOT EXECUTED
3000971c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
if ( !uptime )
return RTEMS_INVALID_ADDRESS;
30009720: e3a00009 mov r0, #9 <== NOT EXECUTED
_TOD_Get_uptime_as_timespec( uptime );
return RTEMS_SUCCESSFUL;
}
30009724: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30009500 <rtems_clock_tick>:
*
* NOTE: This routine only works for leap-years through 2099.
*/
rtems_status_code rtems_clock_tick( void )
{
30009500: e52de004 push {lr} ; (str lr, [sp, #-4]!)
_TOD_Tickle_ticks();
30009504: eb000524 bl 3000a99c <_TOD_Tickle_ticks>
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{
_Watchdog_Tickle( &_Watchdog_Ticks_chain );
30009508: e59f0038 ldr r0, [pc, #56] ; 30009548 <rtems_clock_tick+0x48> 3000950c: eb000ef0 bl 3000d0d4 <_Watchdog_Tickle>
_Watchdog_Tickle_ticks();
_Thread_Tickle_timeslice();
30009510: eb000d5f bl 3000ca94 <_Thread_Tickle_timeslice>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
return ( _Thread_Dispatch_necessary );
30009514: e59f3030 ldr r3, [pc, #48] ; 3000954c <rtems_clock_tick+0x4c> 30009518: e5d33010 ldrb r3, [r3, #16]
if ( _Thread_Is_context_switch_necessary() &&
3000951c: e3530000 cmp r3, #0
30009520: 0a000003 beq 30009534 <rtems_clock_tick+0x34>
* otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
return ( _Thread_Dispatch_disable_level == 0 );
30009524: e59f3024 ldr r3, [pc, #36] ; 30009550 <rtems_clock_tick+0x50><== NOT EXECUTED 30009528: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000952c: e3530000 cmp r3, #0 <== NOT EXECUTED 30009530: 0a000001 beq 3000953c <rtems_clock_tick+0x3c> <== NOT EXECUTED
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
30009534: e3a00000 mov r0, #0
30009538: e49df004 pop {pc} ; (ldr pc, [sp], #4)
_Thread_Tickle_timeslice();
if ( _Thread_Is_context_switch_necessary() &&
_Thread_Is_dispatching_enabled() )
_Thread_Dispatch();
3000953c: eb000a7a bl 3000bf2c <_Thread_Dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
30009540: e3a00000 mov r0, #0 <== NOT EXECUTED
30009544: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006c70 <rtems_cpu_usage_report>:
void rtems_cpu_usage_report( void )
{
rtems_cpu_usage_report_with_plugin( NULL, printk_plugin );
30006c70: e59f1004 ldr r1, [pc, #4] ; 30006c7c <rtems_cpu_usage_report+0xc><== NOT EXECUTED 30006c74: e3a00000 mov r0, #0 <== NOT EXECUTED 30006c78: eaffff7e b 30006a78 <rtems_cpu_usage_report_with_plugin> <== NOT EXECUTED
30006a78 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006a78: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
30006a7c: e251a000 subs sl, r1, #0 <== NOT EXECUTED
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30006a80: e24dd058 sub sp, sp, #88 ; 0x58 <== NOT EXECUTED 30006a84: e1a09000 mov r9, r0 <== NOT EXECUTED
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
30006a88: 0a00006c beq 30006c40 <rtems_cpu_usage_report_with_plugin+0x1c8><== NOT EXECUTED
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006a8c: e59f31b4 ldr r3, [pc, #436] ; 30006c48 <rtems_cpu_usage_report_with_plugin+0x1d0><== NOT EXECUTED
}
}
}
#endif
(*print)(
30006a90: e59f11b4 ldr r1, [pc, #436] ; 30006c4c <rtems_cpu_usage_report_with_plugin+0x1d4><== NOT EXECUTED
* When not using nanosecond CPU usage resolution, we have to count
* the number of "ticks" we gave credit for to give the user a rough
* guideline as to what each number means proportionally.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
30006a94: e8930018 ldm r3, {r3, r4} <== NOT EXECUTED
30006a98: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
30006a9c: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED
}
}
}
#endif
(*print)(
30006aa0: e1a0e00f mov lr, pc <== NOT EXECUTED 30006aa4: e12fff1a bx sl <== NOT EXECUTED 30006aa8: e59f11a0 ldr r1, [pc, #416] ; 30006c50 <rtems_cpu_usage_report_with_plugin+0x1d8><== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006aac: e28d7010 add r7, sp, #16 <== NOT EXECUTED
}
}
}
#endif
(*print)(
30006ab0: e58d100c str r1, [sp, #12] <== NOT EXECUTED
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
30006ab4: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006ab8: e5b23004 ldr r3, [r2, #4]! <== NOT EXECUTED 30006abc: e3530000 cmp r3, #0 <== NOT EXECUTED 30006ac0: e58d200c str r2, [sp, #12] <== NOT EXECUTED 30006ac4: 0a000050 beq 30006c0c <rtems_cpu_usage_report_with_plugin+0x194><== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
30006ac8: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED
if ( information ) {
30006acc: e3560000 cmp r6, #0 <== NOT EXECUTED 30006ad0: 0a00004d beq 30006c0c <rtems_cpu_usage_report_with_plugin+0x194><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
30006ad4: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED 30006ad8: e3530000 cmp r3, #0 <== NOT EXECUTED 30006adc: 0a00004a beq 30006c0c <rtems_cpu_usage_report_with_plugin+0x194><== NOT EXECUTED 30006ae0: e3a05001 mov r5, #1 <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
30006ae4: e28db040 add fp, sp, #64 ; 0x40 <== NOT EXECUTED
Timestamp_Control last = _Thread_Time_of_last_context_switch;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
30006ae8: e28d8048 add r8, sp, #72 ; 0x48 <== NOT EXECUTED 30006aec: ea00001c b 30006b64 <rtems_cpu_usage_report_with_plugin+0xec><== NOT EXECUTED 30006af0: e1a00008 mov r0, r8 <== NOT EXECUTED 30006af4: eb001615 bl 3000c350 <_TOD_Get_uptime> <== NOT EXECUTED 30006af8: e28d4038 add r4, sp, #56 ; 0x38 <== NOT EXECUTED
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
30006afc: e28d0030 add r0, sp, #48 ; 0x30 <== NOT EXECUTED 30006b00: e1a01008 mov r1, r8 <== NOT EXECUTED 30006b04: e1a0200b mov r2, fp <== NOT EXECUTED 30006b08: eb001f4e bl 3000e848 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Divide( &ran, &total, &ival, &fval );
30006b0c: e1a0100b mov r1, fp <== NOT EXECUTED 30006b10: e1a00004 mov r0, r4 <== NOT EXECUTED 30006b14: e28d2054 add r2, sp, #84 ; 0x54 <== NOT EXECUTED 30006b18: e28d3050 add r3, sp, #80 ; 0x50 <== NOT EXECUTED 30006b1c: eb001f25 bl 3000e7b8 <_Timespec_Divide> <== NOT EXECUTED
/*
* Print the information
*/
(*print)( context,
30006b20: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 30006b24: e59f2128 ldr r2, [pc, #296] ; 30006c54 <rtems_cpu_usage_report_with_plugin+0x1dc><== NOT EXECUTED 30006b28: e1a00009 mov r0, r9 <== NOT EXECUTED 30006b2c: e0831392 umull r1, r3, r2, r3 <== NOT EXECUTED 30006b30: e59d2054 ldr r2, [sp, #84] ; 0x54 <== NOT EXECUTED 30006b34: e1a03323 lsr r3, r3, #6 <== NOT EXECUTED 30006b38: e58d2000 str r2, [sp] <== NOT EXECUTED 30006b3c: e59d2050 ldr r2, [sp, #80] ; 0x50 <== NOT EXECUTED 30006b40: e59f1110 ldr r1, [pc, #272] ; 30006c58 <rtems_cpu_usage_report_with_plugin+0x1e0><== NOT EXECUTED 30006b44: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 30006b48: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 30006b4c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006b50: e12fff1a bx sl <== NOT EXECUTED 30006b54: e1d631b0 ldrh r3, [r6, #16] <== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
30006b58: e2855001 add r5, r5, #1 <== NOT EXECUTED 30006b5c: e1530005 cmp r3, r5 <== NOT EXECUTED 30006b60: 3a000029 bcc 30006c0c <rtems_cpu_usage_report_with_plugin+0x194><== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
30006b64: e596001c ldr r0, [r6, #28] <== NOT EXECUTED
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b68: e1a02007 mov r2, r7 <== NOT EXECUTED
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
30006b6c: e7904105 ldr r4, [r0, r5, lsl #2] <== NOT EXECUTED
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b70: e3a0100d mov r1, #13 <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
30006b74: e3540000 cmp r4, #0 <== NOT EXECUTED 30006b78: 0afffff6 beq 30006b58 <rtems_cpu_usage_report_with_plugin+0xe0><== NOT EXECUTED
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
30006b7c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 30006b80: eb00112d bl 3000b03c <rtems_object_get_name> <== NOT EXECUTED
(*print)(
30006b84: e1a03007 mov r3, r7 <== NOT EXECUTED 30006b88: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 30006b8c: e59f10c8 ldr r1, [pc, #200] ; 30006c5c <rtems_cpu_usage_report_with_plugin+0x1e4><== NOT EXECUTED 30006b90: e1a00009 mov r0, r9 <== NOT EXECUTED 30006b94: e1a0e00f mov lr, pc <== NOT EXECUTED 30006b98: e12fff1a bx sl <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
30006b9c: e2841084 add r1, r4, #132 ; 0x84 <== NOT EXECUTED
30006ba0: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
30006ba4: e59f30b4 ldr r3, [pc, #180] ; 30006c60 <rtems_cpu_usage_report_with_plugin+0x1e8><== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
30006ba8: e58d0038 str r0, [sp, #56] ; 0x38 <== NOT EXECUTED 30006bac: e58d103c str r1, [sp, #60] ; 0x3c <== NOT EXECUTED
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
30006bb0: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 30006bb4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30006bb8: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30006bbc: e1520003 cmp r2, r3 <== NOT EXECUTED 30006bc0: 1affffca bne 30006af0 <rtems_cpu_usage_report_with_plugin+0x78><== NOT EXECUTED
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
30006bc4: e59f1098 ldr r1, [pc, #152] ; 30006c64 <rtems_cpu_usage_report_with_plugin+0x1ec><== NOT EXECUTED
_TOD_Get_uptime( &uptime );
30006bc8: e1a00008 mov r0, r8 <== NOT EXECUTED
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
Timestamp_Control used;
Timestamp_Control last = _Thread_Time_of_last_context_switch;
30006bcc: e8910018 ldm r1, {r3, r4} <== NOT EXECUTED
30006bd0: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
30006bd4: e58d4024 str r4, [sp, #36] ; 0x24 <== NOT EXECUTED
_TOD_Get_uptime( &uptime );
30006bd8: eb0015dc bl 3000c350 <_TOD_Get_uptime> <== NOT EXECUTED
_Timestamp_Subtract( &last, &uptime, &used );
30006bdc: e28d3028 add r3, sp, #40 ; 0x28 <== NOT EXECUTED 30006be0: e28d0020 add r0, sp, #32 <== NOT EXECUTED 30006be4: e1a01008 mov r1, r8 <== NOT EXECUTED 30006be8: e1a02003 mov r2, r3 <== NOT EXECUTED 30006bec: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 30006bf0: eb001f14 bl 3000e848 <_Timespec_Subtract> <== NOT EXECUTED
_Timestamp_Add_to( &ran, &used );
30006bf4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30006bf8: e28d4038 add r4, sp, #56 ; 0x38 <== NOT EXECUTED 30006bfc: e1a00004 mov r0, r4 <== NOT EXECUTED 30006c00: e1a01003 mov r1, r3 <== NOT EXECUTED 30006c04: eb001ed4 bl 3000e75c <_Timespec_Add_to> <== NOT EXECUTED 30006c08: eaffffbb b 30006afc <rtems_cpu_usage_report_with_plugin+0x84><== NOT EXECUTED
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
30006c0c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006c10: e59f3050 ldr r3, [pc, #80] ; 30006c68 <rtems_cpu_usage_report_with_plugin+0x1f0><== NOT EXECUTED 30006c14: e1520003 cmp r2, r3 <== NOT EXECUTED 30006c18: 1affffa5 bne 30006ab4 <rtems_cpu_usage_report_with_plugin+0x3c><== NOT EXECUTED
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
30006c1c: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED 30006c20: e59f302c ldr r3, [pc, #44] ; 30006c54 <rtems_cpu_usage_report_with_plugin+0x1dc><== NOT EXECUTED 30006c24: e1a00009 mov r0, r9 <== NOT EXECUTED 30006c28: e0831392 umull r1, r3, r2, r3 <== NOT EXECUTED 30006c2c: e59f1038 ldr r1, [pc, #56] ; 30006c6c <rtems_cpu_usage_report_with_plugin+0x1f4><== NOT EXECUTED 30006c30: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED 30006c34: e1a03323 lsr r3, r3, #6 <== NOT EXECUTED 30006c38: e1a0e00f mov lr, pc <== NOT EXECUTED 30006c3c: e12fff1a bx sl <== NOT EXECUTED
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
30006c40: e28dd058 add sp, sp, #88 ; 0x58 <== NOT EXECUTED
30006c44: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006c90 <rtems_cpu_usage_reset>:
/*
* rtems_cpu_usage_reset
*/
void rtems_cpu_usage_reset( void )
{
30006c90: e92d4010 push {r4, lr} <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
30006c94: e59f401c ldr r4, [pc, #28] ; 30006cb8 <rtems_cpu_usage_reset+0x28><== NOT EXECUTED 30006c98: e1a00004 mov r0, r4 <== NOT EXECUTED 30006c9c: eb0015ab bl 3000c350 <_TOD_Get_uptime> <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006ca0: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
30006ca4: e59f3010 ldr r3, [pc, #16] ; 30006cbc <rtems_cpu_usage_reset+0x2c><== NOT EXECUTED
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
30006ca8: e59f0010 ldr r0, [pc, #16] ; 30006cc0 <rtems_cpu_usage_reset+0x30><== NOT EXECUTED
*/
void rtems_cpu_usage_reset( void )
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset );
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
30006cac: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
}
30006cb0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
_Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset;
#else
CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot;
#endif
rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler);
30006cb4: ea001727 b 3000c958 <rtems_iterate_over_all_threads> <== NOT EXECUTED
300110dc <rtems_deviceio_errno>:
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
300110dc: e2503000 subs r3, r0, #0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
300110e0: e92d4010 push {r4, lr}
if (sc == RTEMS_SUCCESSFUL) {
300110e4: 1a000001 bne 300110f0 <rtems_deviceio_errno+0x14>
errno = eno;
return -1;
}
}
300110e8: e1a00003 mov r0, r3
300110ec: e8bd8010 pop {r4, pc}
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
300110f0: e353001c cmp r3, #28 <== NOT EXECUTED
eno = status_code_to_errno [sc];
300110f4: 959f2014 ldrls r2, [pc, #20] ; 30011110 <rtems_deviceio_errno+0x34><== NOT EXECUTED
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
300110f8: 83a04016 movhi r4, #22 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
300110fc: 97924103 ldrls r4, [r2, r3, lsl #2] <== NOT EXECUTED
}
errno = eno;
30011100: eb000008 bl 30011128 <__errno> <== NOT EXECUTED
return -1;
30011104: e3e03000 mvn r3, #0 <== NOT EXECUTED
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
30011108: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
3001110c: eafffff5 b 300110e8 <rtems_deviceio_errno+0xc> <== NOT EXECUTED
3000b0ac <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000b0ac: e92d000e push {r1, r2, r3} <== NOT EXECUTED
3000b0b0: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b0b4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
3000b0b8: e28d3010 add r3, sp, #16 <== NOT EXECUTED
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
3000b0bc: e1a04000 mov r4, r0 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000b0c0: e1a02003 mov r2, r3 <== NOT EXECUTED 3000b0c4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
3000b0c8: e58d3000 str r3, [sp] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
3000b0cc: ebffff9c bl 3000af44 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
3000b0d0: e2143202 ands r3, r4, #536870912 ; 0x20000000 <== NOT EXECUTED 3000b0d4: 1a000005 bne 3000b0f0 <rtems_error+0x44> <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(errno);
}
if (error_flag & RTEMS_ERROR_ABORT) {
3000b0d8: e3140201 tst r4, #268435456 ; 0x10000000 <== NOT EXECUTED 3000b0dc: 1a000009 bne 3000b108 <rtems_error+0x5c> <== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
abort();
}
return chars_written;
}
3000b0e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b0e4: e8bd4010 pop {r4, lr} <== NOT EXECUTED
3000b0e8: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3000b0ec: e12fff1e bx lr <== NOT EXECUTED
va_start(arglist, printf_format);
chars_written = rtems_verror(error_flag, printf_format, arglist);
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
rtems_error(0, "fatal error, exiting");
3000b0f0: e59f1020 ldr r1, [pc, #32] ; 3000b118 <rtems_error+0x6c> <== NOT EXECUTED 3000b0f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b0f8: ebffffeb bl 3000b0ac <rtems_error> <== NOT EXECUTED
_exit(errno);
3000b0fc: eb002dd0 bl 30016844 <__errno> <== NOT EXECUTED 3000b100: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b104: eb0002c4 bl 3000bc1c <_exit> <== NOT EXECUTED
}
if (error_flag & RTEMS_ERROR_ABORT) {
rtems_error(0, "fatal error, aborting");
3000b108: e59f100c ldr r1, [pc, #12] ; 3000b11c <rtems_error+0x70> <== NOT EXECUTED 3000b10c: e1a00003 mov r0, r3 <== NOT EXECUTED 3000b110: ebffffe5 bl 3000b0ac <rtems_error> <== NOT EXECUTED
abort();
3000b114: eb002dc0 bl 3001681c <abort> <== NOT EXECUTED
30009554 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
30009554: e92d4070 push {r4, r5, r6, lr}
RTEMS_API_Control *api;
if ( !event_out )
30009558: e2536000 subs r6, r3, #0
3000955c: 0a000010 beq 300095a4 <rtems_event_receive+0x50>
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30009560: e59f4044 ldr r4, [pc, #68] ; 300095ac <rtems_event_receive+0x58>
if ( _Event_sets_Is_empty( event_in ) ) {
30009564: e3500000 cmp r0, #0
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
30009568: e5945004 ldr r5, [r4, #4] 3000956c: e59550f4 ldr r5, [r5, #244] ; 0xf4
if ( _Event_sets_Is_empty( event_in ) ) {
30009570: 1a000002 bne 30009580 <rtems_event_receive+0x2c>
*event_out = api->pending_events;
30009574: e5953000 ldr r3, [r5] 30009578: e5863000 str r3, [r6]
return RTEMS_SUCCESSFUL;
3000957c: e8bd8070 pop {r4, r5, r6, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009580: e59fc028 ldr ip, [pc, #40] ; 300095b0 <rtems_event_receive+0x5c> 30009584: e59ce000 ldr lr, [ip] 30009588: e28ee001 add lr, lr, #1 3000958c: e58ce000 str lr, [ip]
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
30009590: eb000007 bl 300095b4 <_Event_Seize>
_Thread_Enable_dispatch();
30009594: eb000aba bl 3000c084 <_Thread_Enable_dispatch>
return( _Thread_Executing->Wait.return_code );
30009598: e5943004 ldr r3, [r4, #4]
3000959c: e5930034 ldr r0, [r3, #52] ; 0x34
300095a0: e8bd8070 pop {r4, r5, r6, pc}
)
{
RTEMS_API_Control *api;
if ( !event_out )
return RTEMS_INVALID_ADDRESS;
300095a4: e3a00009 mov r0, #9 <== NOT EXECUTED
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
_Thread_Enable_dispatch();
return( _Thread_Executing->Wait.return_code );
}
300095a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000baf0 <rtems_extension_create>:
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000baf0: e92d41f0 push {r4, r5, r6, r7, r8, lr}
Extension_Control *the_extension;
if ( !id )
3000baf4: e2526000 subs r6, r2, #0
rtems_status_code rtems_extension_create(
rtems_name name,
const rtems_extensions_table *extension_table,
rtems_id *id
)
{
3000baf8: e1a04000 mov r4, r0 3000bafc: e1a08001 mov r8, r1
Extension_Control *the_extension;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000bb00: 03a00009 moveq r0, #9
rtems_id *id
)
{
Extension_Control *the_extension;
if ( !id )
3000bb04: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc}
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
3000bb08: e3540000 cmp r4, #0
3000bb0c: 1a000001 bne 3000bb18 <rtems_extension_create+0x28>
return RTEMS_INVALID_NAME;
3000bb10: e3a00003 mov r0, #3 <== NOT EXECUTED
);
*id = the_extension->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000bb14: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000bb18: e59f306c ldr r3, [pc, #108] ; 3000bb8c <rtems_extension_create+0x9c> 3000bb1c: e5932000 ldr r2, [r3] 3000bb20: e2822001 add r2, r2, #1 3000bb24: e5832000 str r2, [r3]
#ifndef __EXTENSION_MANAGER_inl
#define __EXTENSION_MANAGER_inl
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void )
{
return (Extension_Control *) _Objects_Allocate( &_Extension_Information );
3000bb28: e59f7060 ldr r7, [pc, #96] ; 3000bb90 <rtems_extension_create+0xa0> 3000bb2c: e1a00007 mov r0, r7 3000bb30: eb0003a5 bl 3000c9cc <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
3000bb34: e2505000 subs r5, r0, #0
3000bb38: 0a000010 beq 3000bb80 <rtems_extension_create+0x90>
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
3000bb3c: e285c024 add ip, r5, #36 ; 0x24
3000bb40: e1a0e008 mov lr, r8
3000bb44: e8be000f ldm lr!, {r0, r1, r2, r3}
3000bb48: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000bb4c: e89e000f ldm lr, {r0, r1, r2, r3}
3000bb50: e88c000f stm ip, {r0, r1, r2, r3}
_User_extensions_Add_set( extension );
3000bb54: e2850010 add r0, r5, #16 3000bb58: eb000b50 bl 3000e8a0 <_User_extensions_Add_set>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000bb5c: e5953008 ldr r3, [r5, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bb60: e597201c ldr r2, [r7, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000bb64: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000bb68: e7825721 str r5, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000bb6c: e585400c str r4, [r5, #12]
&_Extension_Information,
&the_extension->Object,
(Objects_Name) name
);
*id = the_extension->Object.id;
3000bb70: e5863000 str r3, [r6]
_Thread_Enable_dispatch();
3000bb74: eb000833 bl 3000dc48 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000bb78: e3a00000 mov r0, #0
3000bb7c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_extension = _Extension_Allocate();
if ( !the_extension ) {
_Thread_Enable_dispatch();
3000bb80: eb000830 bl 3000dc48 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000bb84: e3a00005 mov r0, #5 <== NOT EXECUTED
3000bb88: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c788 <rtems_extension_ident>:
rtems_status_code rtems_extension_ident(
rtems_name name,
rtems_id *id
)
{
3000c788: e1a02000 mov r2, r0 <== NOT EXECUTED
3000c78c: e1a03001 mov r3, r1 <== NOT EXECUTED
3000c790: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
status = _Objects_Name_to_id_u32(
3000c794: e1a01002 mov r1, r2 <== NOT EXECUTED 3000c798: e59f0010 ldr r0, [pc, #16] ; 3000c7b0 <rtems_extension_ident+0x28><== NOT EXECUTED 3000c79c: e3e02102 mvn r2, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000c7a0: eb0004c0 bl 3000daa8 <_Objects_Name_to_id_u32> <== NOT EXECUTED
name,
OBJECTS_SEARCH_LOCAL_NODE,
id
);
return _Status_Object_name_errors_to_status[ status ];
3000c7a4: e59f3008 ldr r3, [pc, #8] ; 3000c7b4 <rtems_extension_ident+0x2c><== NOT EXECUTED
}
3000c7a8: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
3000c7ac: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300063f4 <rtems_filesystem_dirname>:
int rtems_filesystem_dirname(
const char *pathname
)
{
300063f4: e92d4030 push {r4, r5, lr}
300063f8: e1a05000 mov r5, r0
int len = strlen( pathname );
300063fc: eb002f33 bl 300120d0 <strlen>
while ( len ) {
30006400: e2504000 subs r4, r0, #0
30006404: 1a000002 bne 30006414 <rtems_filesystem_dirname+0x20>
30006408: ea000006 b 30006428 <rtems_filesystem_dirname+0x34> <== NOT EXECUTED
3000640c: e3540000 cmp r4, #0
30006410: 0a000004 beq 30006428 <rtems_filesystem_dirname+0x34>
len--;
30006414: e2444001 sub r4, r4, #1
if ( rtems_filesystem_is_separator( pathname[len] ) )
30006418: e7d50004 ldrb r0, [r5, r4] 3000641c: eb0003de bl 3000739c <rtems_filesystem_is_separator> 30006420: e3500000 cmp r0, #0
30006424: 0afffff8 beq 3000640c <rtems_filesystem_dirname+0x18>
break;
}
return len;
}
30006428: e1a00004 mov r0, r4
3000642c: e8bd8030 pop {r4, r5, pc}
300061cc <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
300061cc: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_umask = 022;
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061d0: e59f20e8 ldr r2, [pc, #232] ; 300062c0 <rtems_filesystem_initialize+0xf4>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061d4: e59f60e8 ldr r6, [pc, #232] ; 300062c4 <rtems_filesystem_initialize+0xf8>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061d8: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061dc: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061e0: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061e4: e3a02012 mov r2, #18
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
300061e8: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
300061ec: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
300061f0: 0a00002c beq 300062a8 <rtems_filesystem_initialize+0xdc>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
300061f4: e59f30cc ldr r3, [pc, #204] ; 300062c8 <rtems_filesystem_initialize+0xfc>
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
300061f8: e3a05000 mov r5, #0
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
300061fc: e5933000 ldr r3, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
30006200: e5930008 ldr r0, [r3, #8]
30006204: e593100c ldr r1, [r3, #12]
30006208: e893000c ldm r3, {r2, r3}
3000620c: e58d5000 str r5, [sp]
30006210: eb000212 bl 30006a60 <mount>
if ( status == -1 )
30006214: e3700001 cmn r0, #1
30006218: 0a000026 beq 300062b8 <rtems_filesystem_initialize+0xec>
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
3000621c: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006220: e28d4004 add r4, sp, #4
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
30006224: e1c353b0 strh r5, [r3, #48] ; 0x30
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006228: e3a01001 mov r1, #1 3000622c: e1a03004 mov r3, r4 30006230: e1a02005 mov r2, r5 30006234: e59f0090 ldr r0, [pc, #144] ; 300062cc <rtems_filesystem_initialize+0x100> 30006238: e58d5000 str r5, [sp] 3000623c: eb000056 bl 3000639c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
30006240: e596c000 ldr ip, [r6]
30006244: e1a07004 mov r7, r4
30006248: e28cc018 add ip, ip, #24
3000624c: e8b7000f ldm r7!, {r0, r1, r2, r3}
30006250: e597e000 ldr lr, [r7]
30006254: e8ac000f stmia ip!, {r0, r1, r2, r3}
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006258: e3a01001 mov r1, #1
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
3000625c: e58ce000 str lr, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
30006260: e1a02005 mov r2, r5 30006264: e1a03004 mov r3, r4 30006268: e59f005c ldr r0, [pc, #92] ; 300062cc <rtems_filesystem_initialize+0x100> 3000626c: e58d5000 str r5, [sp] 30006270: eb000049 bl 3000639c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
30006274: e8b4000f ldm r4!, {r0, r1, r2, r3}
30006278: e596c000 ldr ip, [r6]
3000627c: e597e000 ldr lr, [r7]
30006280: e28cc004 add ip, ip, #4
30006284: e8ac000f stmia ip!, {r0, r1, r2, r3}
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
30006288: e59f0040 ldr r0, [pc, #64] ; 300062d0 <rtems_filesystem_initialize+0x104>
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
3000628c: e58ce000 str lr, [ip]
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
30006290: e59f103c ldr r1, [pc, #60] ; 300062d4 <rtems_filesystem_initialize+0x108> 30006294: eb000196 bl 300068f4 <mkdir>
if ( status != 0 )
30006298: e3500000 cmp r0, #0
3000629c: 1a000003 bne 300062b0 <rtems_filesystem_initialize+0xe4> * it will be mounted onto is created. Moreover, if it is going to * use a device, then it is REALLY unfair to attempt this * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ }
300062a0: e28dd018 add sp, sp, #24
300062a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
300062a8: e59f0028 ldr r0, [pc, #40] ; 300062d8 <rtems_filesystem_initialize+0x10c><== NOT EXECUTED 300062ac: eb000fcf bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
300062b0: e59f0024 ldr r0, [pc, #36] ; 300062dc <rtems_filesystem_initialize+0x110><== NOT EXECUTED 300062b4: eb000fcd bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
300062b8: e59f0020 ldr r0, [pc, #32] ; 300062e0 <rtems_filesystem_initialize+0x114><== NOT EXECUTED 300062bc: eb000fcb bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000e8fc <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000e8fc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000e900: e59f60ac ldr r6, [pc, #172] ; 3000e9b4 <rtems_filesystem_iterate+0xb8>
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000e904: e1a04000 mov r4, r0
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000e908: e5963000 ldr r3, [r6]
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
3000e90c: e1a05001 mov r5, r1
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000e910: e3530000 cmp r3, #0
3000e914: 1a000002 bne 3000e924 <rtems_filesystem_iterate+0x28>
3000e918: ea00000c b 3000e950 <rtems_filesystem_iterate+0x54> <== NOT EXECUTED
3000e91c: e3500000 cmp r0, #0
3000e920: 1a000021 bne 3000e9ac <rtems_filesystem_iterate+0xb0>
stop = (*routine)( table_entry, routine_arg );
3000e924: e1a00006 mov r0, r6 3000e928: e1a01005 mov r1, r5 3000e92c: e1a0e00f mov lr, pc 3000e930: e12fff14 bx r4
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000e934: e5963008 ldr r3, [r6, #8]
stop = (*routine)( table_entry, routine_arg );
3000e938: e1a0a000 mov sl, r0
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
3000e93c: e3530000 cmp r3, #0 3000e940: e2866008 add r6, r6, #8
3000e944: 1afffff4 bne 3000e91c <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
3000e948: e3500000 cmp r0, #0
3000e94c: 1a000016 bne 3000e9ac <rtems_filesystem_iterate+0xb0>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
3000e950: e59f7060 ldr r7, [pc, #96] ; 3000e9b8 <rtems_filesystem_iterate+0xbc> 3000e954: e3a01000 mov r1, #0
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000e958: e59f605c ldr r6, [pc, #92] ; 3000e9bc <rtems_filesystem_iterate+0xc0> 3000e95c: e5970000 ldr r0, [r7] 3000e960: e1a02001 mov r2, r1 3000e964: ebffec7a bl 30009b54 <rtems_semaphore_obtain> 3000e968: e4968004 ldr r8, [r6], #4
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000e96c: e1580006 cmp r8, r6 3000e970: 03a0a000 moveq sl, #0
3000e974: 1a000002 bne 3000e984 <rtems_filesystem_iterate+0x88>
3000e978: ea000009 b 3000e9a4 <rtems_filesystem_iterate+0xa8>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
3000e97c: e3500000 cmp r0, #0
3000e980: 1a000007 bne 3000e9a4 <rtems_filesystem_iterate+0xa8>
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
3000e984: e2880008 add r0, r8, #8 3000e988: e1a01005 mov r1, r5 3000e98c: e1a0e00f mov lr, pc 3000e990: e12fff14 bx r4
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
3000e994: e5988000 ldr r8, [r8]
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
3000e998: e1a0a000 mov sl, r0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
3000e99c: e1580006 cmp r8, r6
3000e9a0: 1afffff5 bne 3000e97c <rtems_filesystem_iterate+0x80>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000e9a4: e5970000 ldr r0, [r7] 3000e9a8: ebffecb2 bl 30009c78 <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
3000e9ac: e1a0000a mov r0, sl
3000e9b0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
300069e8 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
300069e8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
300069ec: e59f7064 ldr r7, [pc, #100] ; 30006a58 <rtems_filesystem_mount_iterate+0x70>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
300069f0: e59f4064 ldr r4, [pc, #100] ; 30006a5c <rtems_filesystem_mount_iterate+0x74>
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
300069f4: e1a06001 mov r6, r1 300069f8: e3a01000 mov r1, #0 300069fc: e1a05000 mov r5, r0 30006a00: e1a02001 mov r2, r1 30006a04: e5970000 ldr r0, [r7] 30006a08: eb000c51 bl 30009b54 <rtems_semaphore_obtain>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006a0c: e4948004 ldr r8, [r4], #4
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30006a10: e1580004 cmp r8, r4
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
30006a14: 03a0a000 moveq sl, #0
rtems_libio_lock();
for (
30006a18: 1a000002 bne 30006a28 <rtems_filesystem_mount_iterate+0x40>
30006a1c: ea000009 b 30006a48 <rtems_filesystem_mount_iterate+0x60> <== NOT EXECUTED
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
30006a20: e3500000 cmp r0, #0
30006a24: 1a000007 bne 30006a48 <rtems_filesystem_mount_iterate+0x60>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
30006a28: e1a00008 mov r0, r8 30006a2c: e1a01006 mov r1, r6 30006a30: e1a0e00f mov lr, pc 30006a34: e12fff15 bx r5
}
rtems_libio_unlock();
return stop;
}
30006a38: e5988000 ldr r8, [r8]
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
30006a3c: e1a0a000 mov sl, r0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
30006a40: e1580004 cmp r8, r4
30006a44: 1afffff5 bne 30006a20 <rtems_filesystem_mount_iterate+0x38>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
30006a48: e5970000 ldr r0, [r7] 30006a4c: eb000c89 bl 30009c78 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
30006a50: e1a0000a mov r0, sl
30006a54: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
30006430 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
30006430: e92d4070 push {r4, r5, r6, lr}
30006434: e1a05000 mov r5, r0
/* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30006438: e5d00000 ldrb r0, [r0] 3000643c: e1a06001 mov r6, r1 30006440: e3510000 cmp r1, #0 30006444: 13500000 cmpne r0, #0 30006448: 03a04000 moveq r4, #0 3000644c: 13a04001 movne r4, #1
)
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
30006450: 13a04000 movne r4, #0
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 30006454: 1a000005 bne 30006470 <rtems_filesystem_prefix_separators+0x40>
30006458: ea000007 b 3000647c <rtems_filesystem_prefix_separators+0x4c><== NOT EXECUTED
3000645c: e5f50001 ldrb r0, [r5, #1]!
{
pathname++;
pathnamelen--;
stripped++;
30006460: e2844001 add r4, r4, #1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
30006464: e1560004 cmp r6, r4 30006468: 13500000 cmpne r0, #0
3000646c: 0a000002 beq 3000647c <rtems_filesystem_prefix_separators+0x4c>
30006470: eb0003c9 bl 3000739c <rtems_filesystem_is_separator> 30006474: e3500000 cmp r0, #0
30006478: 1afffff7 bne 3000645c <rtems_filesystem_prefix_separators+0x2c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
3000647c: e1a00004 mov r0, r4
30006480: e8bd8070 pop {r4, r5, r6, pc}
3000c5cc <rtems_get_version_string>:
#include <rtems/system.h>
const char *rtems_get_version_string(void)
{
return _RTEMS_version;
}
3000c5cc: e59f0000 ldr r0, [pc, #0] ; 3000c5d4 <rtems_get_version_string+0x8><== NOT EXECUTED 3000c5d0: e12fff1e bx lr <== NOT EXECUTED
300070ec <rtems_gxx_getspecific>:
void *rtems_gxx_getspecific(__gthread_key_t key)
{
300070ec: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300070f0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_status_code status; void *p= 0;
300070f4: e3a05000 mov r5, #0 <== NOT EXECUTED
key = NULL;
return 0;
}
void *rtems_gxx_getspecific(__gthread_key_t key)
{
300070f8: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code status; void *p= 0;
300070fc: e28d2004 add r2, sp, #4 <== NOT EXECUTED 30007100: e5225004 str r5, [r2, #-4]! <== NOT EXECUTED
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );
30007104: e1a00005 mov r0, r5 <== NOT EXECUTED 30007108: e1a01004 mov r1, r4 <== NOT EXECUTED 3000710c: e1a0200d mov r2, sp <== NOT EXECUTED 30007110: eb000f84 bl 3000af28 <rtems_task_variable_get> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30007114: e1500005 cmp r0, r5 <== NOT EXECUTED
/* We do not have to do this, but what the heck ! */
p= key->val;
30007118: 05940000 ldreq r0, [r4] <== NOT EXECUTED
rtems_status_code status;
void *p= 0;
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_get( RTEMS_SELF, (void **)key, &p );
if ( status == RTEMS_SUCCESSFUL ) {
3000711c: 1a000001 bne 30007128 <rtems_gxx_getspecific+0x3c> <== NOT EXECUTED
p,
rtems_task_self()
);
#endif
return p;
}
30007120: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007124: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
p= key->val;
} else {
/* fisrt time, always set to zero, it is unknown the value that the others
* threads are using at the moment of this call
*/
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
30007128: e1a00005 mov r0, r5 <== NOT EXECUTED 3000712c: e1a01004 mov r1, r4 <== NOT EXECUTED 30007130: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30007134: eb000f28 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL ) {
30007138: e2503000 subs r3, r0, #0 <== NOT EXECUTED
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_GXX_KEY_ADD_FAILED
);
}
key->val = (void *)0;
3000713c: 059d0000 ldreq r0, [sp] <== NOT EXECUTED 30007140: 05843000 streq r3, [r4] <== NOT EXECUTED 30007144: 0afffff5 beq 30007120 <rtems_gxx_getspecific+0x34> <== NOT EXECUTED
/* fisrt time, always set to zero, it is unknown the value that the others
* threads are using at the moment of this call
*/
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
if ( status != RTEMS_SUCCESSFUL ) {
_Internal_error_Occurred(
30007148: e1a00005 mov r0, r5 <== NOT EXECUTED 3000714c: e3a01001 mov r1, #1 <== NOT EXECUTED 30007150: e3a02015 mov r2, #21 <== NOT EXECUTED 30007154: eb001324 bl 3000bdec <_Internal_error_Occurred> <== NOT EXECUTED
30007060 <rtems_gxx_key_create>:
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
30007060: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007064: e1a06000 mov r6, r0 <== NOT EXECUTED
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
30007068: e3a00008 mov r0, #8 <== NOT EXECUTED
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
3000706c: e1a05001 mov r5, r1 <== NOT EXECUTED
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
30007070: eb000107 bl 30007494 <malloc> <== NOT EXECUTED
*key = new_key; new_key->val = NULL;
30007074: e3a03000 mov r3, #0 <== NOT EXECUTED
* pointer to the buffer that will hold the value of the key itself. * We have to to this, because the others functions on this interface * deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) );
30007078: e1a04000 mov r4, r0 <== NOT EXECUTED
*key = new_key;
3000707c: e5860000 str r0, [r6] <== NOT EXECUTED
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
30007080: e1a01004 mov r1, r4 <== NOT EXECUTED 30007084: e1a00003 mov r0, r3 <== NOT EXECUTED 30007088: e1a02005 mov r2, r5 <== NOT EXECUTED
* deal with the value of the key, as used with the POSIX API. */ /* Do not pull your hair, trust me this works. :-) */ __gthread_key_t new_key = (__gthread_key_t) malloc( sizeof( *new_key ) ); *key = new_key; new_key->val = NULL;
3000708c: e8840028 stm r4, {r3, r5} <== NOT EXECUTED
"gxx_wrappers: create key=%x, dtor=%x, new_key=%x\n", key, dtor, new_key
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)new_key, dtor );
30007090: eb000f51 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30007094: e3500000 cmp r0, #0 <== NOT EXECUTED
30007098: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return 0;
free( new_key );
3000709c: e1a00004 mov r0, r4 <== NOT EXECUTED 300070a0: ebffff87 bl 30006ec4 <free> <== NOT EXECUTED
return -1;
300070a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
300070a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
300070bc <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
300070bc: e92d4010 push {r4, lr} <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
300070c0: e1a01000 mov r1, r0 <== NOT EXECUTED
key->val = 0;
return 0;
}
int rtems_gxx_key_delete (__gthread_key_t key)
{
300070c4: e1a04000 mov r4, r0 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: delete key=%x\n", key );
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_delete( RTEMS_SELF, (void **)key );
300070c8: e3a00000 mov r0, #0 <== NOT EXECUTED 300070cc: eb000f6e bl 3000ae8c <rtems_task_variable_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
300070d0: e3500000 cmp r0, #0 <== NOT EXECUTED 300070d4: 1a000002 bne 300070e4 <rtems_gxx_key_delete+0x28> <== NOT EXECUTED
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
300070d8: e3540000 cmp r4, #0 <== NOT EXECUTED 300070dc: 15940000 ldrne r0, [r4] <== NOT EXECUTED 300070e0: 1bffff77 blne 30006ec4 <free> <== NOT EXECUTED
return 0;
}
key = NULL;
return 0;
}
300070e4: e3a00000 mov r0, #0 <== NOT EXECUTED
300070e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300070ac <rtems_gxx_key_dtor>:
{
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: dtor key=%x, ptr=%x\n", key, ptr );
#endif
key->val = 0;
300070ac: e3a03000 mov r3, #0 <== NOT EXECUTED 300070b0: e5803000 str r3, [r0] <== NOT EXECUTED
return 0; }
300070b4: e1a00003 mov r0, r3 <== NOT EXECUTED 300070b8: e12fff1e bx lr <== NOT EXECUTED
300071e8 <rtems_gxx_mutex_destroy>:
int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex)
{
300071e8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: destroy mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_delete(*(rtems_id *)mutex);
300071ec: e5900000 ldr r0, [r0] <== NOT EXECUTED 300071f0: eb000d53 bl 3000a744 <rtems_semaphore_delete> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
300071f4: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
300071f8: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300071fc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007184 <rtems_gxx_mutex_init>:
/*
* MUTEX support
*/
void rtems_gxx_mutex_init (__gthread_mutex_t *mutex)
{
30007184: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
30007188: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init =%X\n", *mutex );
#endif
status = rtems_semaphore_create(
3000718c: e58d0000 str r0, [sp] <== NOT EXECUTED 30007190: e3a01001 mov r1, #1 <== NOT EXECUTED 30007194: e59f0028 ldr r0, [pc, #40] ; 300071c4 <rtems_gxx_mutex_init+0x40><== NOT EXECUTED 30007198: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 3000719c: e3a03000 mov r3, #0 <== NOT EXECUTED 300071a0: eb000cf6 bl 3000a580 <rtems_semaphore_create> <== NOT EXECUTED
RTEMS_PRIORITY|RTEMS_BINARY_SEMAPHORE|
RTEMS_INHERIT_PRIORITY|RTEMS_NO_PRIORITY_CEILING|RTEMS_LOCAL,
0,
(rtems_id *)mutex
);
if ( status != RTEMS_SUCCESSFUL ) {
300071a4: e3500000 cmp r0, #0 <== NOT EXECUTED 300071a8: 1a000001 bne 300071b4 <rtems_gxx_mutex_init+0x30> <== NOT EXECUTED
);
}
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
300071ac: e28dd004 add sp, sp, #4 <== NOT EXECUTED
300071b0: e8bd8000 pop {pc} <== NOT EXECUTED
"gxx_wrappers: mutex init failed %s (%d)\n",
rtems_status_text(status),
status
);
#endif
_Internal_error_Occurred(
300071b4: e3a00000 mov r0, #0 <== NOT EXECUTED 300071b8: e3a01001 mov r1, #1 <== NOT EXECUTED 300071bc: e3a02016 mov r2, #22 <== NOT EXECUTED 300071c0: eb001309 bl 3000bdec <_Internal_error_Occurred> <== NOT EXECUTED
300071c8 <rtems_gxx_mutex_lock>:
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
300071c8: e3a01000 mov r1, #0 <== NOT EXECUTED
printk( "gxx_wrappers: mutex init complete =%X\n", *mutex );
#endif
}
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
300071cc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
300071d0: e1a02001 mov r2, r1 <== NOT EXECUTED 300071d4: e5900000 ldr r0, [r0] <== NOT EXECUTED 300071d8: eb000d82 bl 3000a7e8 <rtems_semaphore_obtain> <== NOT EXECUTED
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
300071dc: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
300071e0: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300071e4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007200 <rtems_gxx_mutex_trylock>:
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
30007200: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: trylock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain (*(rtems_id *)mutex, RTEMS_NO_WAIT, 0);
30007204: e3a01001 mov r1, #1 <== NOT EXECUTED 30007208: e3a02000 mov r2, #0 <== NOT EXECUTED 3000720c: e5900000 ldr r0, [r0] <== NOT EXECUTED 30007210: eb000d74 bl 3000a7e8 <rtems_semaphore_obtain> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
30007214: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30007218: 13e00000 mvnne r0, #0 <== NOT EXECUTED
3000721c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30007220 <rtems_gxx_mutex_unlock>:
int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex)
{
30007220: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: unlock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_release( *(rtems_id *)mutex );
30007224: e5900000 ldr r0, [r0] <== NOT EXECUTED 30007228: eb000db7 bl 3000a90c <rtems_semaphore_release> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL )
3000722c: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
return -1;
}
30007230: 13e00000 mvnne r0, #0 <== NOT EXECUTED
30007234: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006fe0 <rtems_gxx_once>:
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
30006fe0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006fe4: e5903000 ldr r3, [r0] <== NOT EXECUTED
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
30006fe8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006fec: e3530000 cmp r3, #0 <== NOT EXECUTED
/* uncomment this if you need to debug this interface */
/*#define DEBUG_GXX_WRAPPERS 1*/
int rtems_gxx_once(__gthread_once_t *once, void (*func) (void))
{
30006ff0: e1a04000 mov r4, r0 <== NOT EXECUTED 30006ff4: e1a05001 mov r5, r1 <== NOT EXECUTED
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
30006ff8: 0a000002 beq 30007008 <rtems_gxx_once+0x28> <== NOT EXECUTED
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
if ( o == 0 )
(*func)();
}
return 0;
}
30006ffc: e3a00000 mov r0, #0 <== NOT EXECUTED
30007000: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007004: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
30007008: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED 3000700c: e1a01000 mov r1, r0 <== NOT EXECUTED 30007010: e1a0200d mov r2, sp <== NOT EXECUTED 30007014: eb000ef9 bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30007018: e5943000 ldr r3, [r4] <== NOT EXECUTED
if ( *(volatile __gthread_once_t *)once == 0 ) {
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
3000701c: e1a0600d mov r6, sp <== NOT EXECUTED
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
30007020: e3530000 cmp r3, #0 <== NOT EXECUTED 30007024: 1a000008 bne 3000704c <rtems_gxx_once+0x6c> <== NOT EXECUTED
*(volatile __gthread_once_t *)once = 1;
30007028: e3a03001 mov r3, #1 <== NOT EXECUTED 3000702c: e5843000 str r3, [r4] <== NOT EXECUTED
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
30007030: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30007034: e1a0200d mov r2, sp <== NOT EXECUTED 30007038: e59d0000 ldr r0, [sp] <== NOT EXECUTED 3000703c: eb000eef bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED
if ( o == 0 )
(*func)();
30007040: e1a0e00f mov lr, pc <== NOT EXECUTED 30007044: e12fff15 bx r5 <== NOT EXECUTED 30007048: eaffffeb b 30006ffc <rtems_gxx_once+0x1c> <== NOT EXECUTED
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
*(volatile __gthread_once_t *)once = 1;
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
3000704c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30007050: e3a01c01 mov r1, #256 ; 0x100 <== NOT EXECUTED 30007054: e1a0200d mov r2, sp <== NOT EXECUTED 30007058: eb000ee8 bl 3000ac00 <rtems_task_mode> <== NOT EXECUTED 3000705c: eaffffe6 b 30006ffc <rtems_gxx_once+0x1c> <== NOT EXECUTED
30007238 <rtems_gxx_recursive_mutex_init>:
void rtems_gxx_recursive_mutex_init(__gthread_recursive_mutex_t *mutex)
{
rtems_gxx_mutex_init(mutex);
30007238: eaffffd1 b 30007184 <rtems_gxx_mutex_init> <== NOT EXECUTED
3000723c <rtems_gxx_recursive_mutex_lock>:
}
int rtems_gxx_recursive_mutex_lock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_lock(mutex);
3000723c: eaffffe1 b 300071c8 <rtems_gxx_mutex_lock> <== NOT EXECUTED
30007240 <rtems_gxx_recursive_mutex_trylock>:
}
int rtems_gxx_recursive_mutex_trylock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_trylock(mutex);
30007240: eaffffee b 30007200 <rtems_gxx_mutex_trylock> <== NOT EXECUTED
30007244 <rtems_gxx_recursive_mutex_unlock>:
}
int rtems_gxx_recursive_mutex_unlock(__gthread_recursive_mutex_t *mutex)
{
return rtems_gxx_mutex_unlock(mutex);
30007244: eafffff5 b 30007220 <rtems_gxx_mutex_unlock> <== NOT EXECUTED
30007158 <rtems_gxx_setspecific>:
#endif
return p;
}
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
30007158: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000715c: e1a04000 mov r4, r0 <== NOT EXECUTED
30007160: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_task_self()
);
#endif
/* register with RTEMS the buffer that will hold the key values */
status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor );
30007164: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 30007168: e1a01004 mov r1, r4 <== NOT EXECUTED 3000716c: e3a00000 mov r0, #0 <== NOT EXECUTED 30007170: eb000f19 bl 3000addc <rtems_task_variable_add> <== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
30007174: e3500000 cmp r0, #0 <== NOT EXECUTED
/* now let's set the proper value */
key->val = (void *)ptr;
30007178: 05845000 streq r5, [r4] <== NOT EXECUTED
return 0;
}
return -1;
3000717c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
}
30007180: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000b810 <rtems_heap_allocate_aligned_with_boundary>:
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
if (
3000b810: e59f3048 ldr r3, [pc, #72] ; 3000b860 <rtems_heap_allocate_aligned_with_boundary+0x50><== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b814: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (
3000b818: e5933000 ldr r3, [r3] <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b81c: e1a06000 mov r6, r0 <== NOT EXECUTED
if (
3000b820: e3530003 cmp r3, #3 <== NOT EXECUTED
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
3000b824: e1a05001 mov r5, r1 <== NOT EXECUTED 3000b828: e1a04002 mov r4, r2 <== NOT EXECUTED
if (
3000b82c: 0a000007 beq 3000b850 <rtems_heap_allocate_aligned_with_boundary+0x40><== NOT EXECUTED
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
3000b830: ebfffba7 bl 3000a6d4 <malloc_deferred_frees_process> <== NOT EXECUTED
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b834: e59f3028 ldr r3, [pc, #40] ; 3000b864 <rtems_heap_allocate_aligned_with_boundary+0x54><== NOT EXECUTED 3000b838: e1a01006 mov r1, r6 <== NOT EXECUTED 3000b83c: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000b840: e1a02005 mov r2, r5 <== NOT EXECUTED 3000b844: e1a03004 mov r3, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
3000b848: e8bd4070 pop {r4, r5, r6, lr} <== NOT EXECUTED
malloc_deferred_frees_process();
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
3000b84c: ea0014be b 30010b4c <_Protected_heap_Allocate_aligned_with_boundary><== NOT EXECUTED
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
3000b850: ebfffb8b bl 3000a684 <malloc_is_system_state_OK> <== NOT EXECUTED
3000b854: e3500000 cmp r0, #0 <== NOT EXECUTED
3000b858: 1afffff4 bne 3000b830 <rtems_heap_allocate_aligned_with_boundary+0x20><== NOT EXECUTED
3000b85c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a9fc <rtems_interrupt_disable>:
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a9fc: e10f0000 mrs r0, CPSR <== NOT EXECUTED 3000aa00: e3803080 orr r3, r0, #128 ; 0x80 <== NOT EXECUTED 3000aa04: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_level previous_level;
_ISR_Disable( previous_level );
return previous_level;
}
3000aa08: e12fff1e bx lr <== NOT EXECUTED
3000aa0c <rtems_interrupt_enable>:
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000aa0c: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED
void rtems_interrupt_enable(
rtems_interrupt_level previous_level
)
{
_ISR_Enable( previous_level );
}
3000aa10: e12fff1e bx lr <== NOT EXECUTED
3000aa14 <rtems_interrupt_flash>:
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
__asm__ volatile (
3000aa14: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000aa18: e129f000 msr CPSR_fc, r0 <== NOT EXECUTED 3000aa1c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
void rtems_interrupt_flash(
rtems_interrupt_level previous_level
)
{
_ISR_Flash( previous_level );
}
3000aa20: e12fff1e bx lr <== NOT EXECUTED
3000aa24 <rtems_interrupt_is_in_progress>:
#undef rtems_interrupt_is_in_progress
bool rtems_interrupt_is_in_progress( void )
{
return _ISR_Is_in_progress();
3000aa24: e59f300c ldr r3, [pc, #12] ; 3000aa38 <rtems_interrupt_is_in_progress+0x14><== NOT EXECUTED 3000aa28: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
3000aa2c: e2500000 subs r0, r0, #0 <== NOT EXECUTED 3000aa30: 13a00001 movne r0, #1 <== NOT EXECUTED 3000aa34: e12fff1e bx lr <== NOT EXECUTED
3000a3cc <rtems_interrupt_level_attribute>:
rtems_attribute rtems_interrupt_level_attribute(
uint32_t level
)
{
return RTEMS_INTERRUPT_LEVEL(level);
}
3000a3cc: e2000080 and r0, r0, #128 ; 0x80 <== NOT EXECUTED 3000a3d0: e12fff1e bx lr <== NOT EXECUTED
30010e1c <rtems_io_close>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e1c: e59fc044 ldr ip, [pc, #68] ; 30010e68 <rtems_io_close+0x4c>
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e20: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e24: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_close(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e28: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e2c: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30010e30: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e34: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].close_entry;
30010e38: e59fc02c ldr ip, [pc, #44] ; 30010e6c <rtems_io_close+0x50> 30010e3c: e0833083 add r3, r3, r3, lsl #1 30010e40: e59cc000 ldr ip, [ip] 30010e44: e08c3183 add r3, ip, r3, lsl #3 30010e48: e5933008 ldr r3, [r3, #8]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010e4c: e3530000 cmp r3, #0
30010e50: 0a000002 beq 30010e60 <rtems_io_close+0x44>
30010e54: e1a0e00f mov lr, pc
30010e58: e12fff13 bx r3
30010e5c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30010e60: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010e64: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30010e70 <rtems_io_control>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e70: e59fc044 ldr ip, [pc, #68] ; 30010ebc <rtems_io_control+0x4c>
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e74: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e78: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_control(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010e7c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e80: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30010e84: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010e88: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].control_entry;
30010e8c: e59fc02c ldr ip, [pc, #44] ; 30010ec0 <rtems_io_control+0x50> 30010e90: e0833083 add r3, r3, r3, lsl #1 30010e94: e59cc000 ldr ip, [ip] 30010e98: e08c3183 add r3, ip, r3, lsl #3 30010e9c: e5933014 ldr r3, [r3, #20]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010ea0: e3530000 cmp r3, #0
30010ea4: 0a000002 beq 30010eb4 <rtems_io_control+0x44>
30010ea8: e1a0e00f mov lr, pc
30010eac: e12fff13 bx r3
30010eb0: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30010eb4: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010eb8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30006128 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
30006128: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000612c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30006130: e1a05000 mov r5, r0 <== NOT EXECUTED
30006134: e1a06001 mov r6, r1 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
30006138: eb002fe4 bl 300120d0 <strlen> <== NOT EXECUTED 3000613c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30006140: e1a01000 mov r1, r0 <== NOT EXECUTED 30006144: e3a0c001 mov ip, #1 <== NOT EXECUTED 30006148: e3a02000 mov r2, #0 <== NOT EXECUTED 3000614c: e1a03004 mov r3, r4 <== NOT EXECUTED 30006150: e1a00005 mov r0, r5 <== NOT EXECUTED 30006154: e58dc000 str ip, [sp] <== NOT EXECUTED 30006158: eb00008f bl 3000639c <rtems_filesystem_evaluate_path> <== NOT EXECUTED
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
3000615c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
30006160: e1a07000 mov r7, r0 <== NOT EXECUTED
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
30006164: e1a00004 mov r0, r4 <== NOT EXECUTED
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path(
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
30006168: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED
node_type = (*loc.ops->node_type_h)( &loc );
3000616c: e1a0e00f mov lr, pc <== NOT EXECUTED 30006170: e593f010 ldr pc, [r3, #16] <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
30006174: e3570000 cmp r7, #0 <== NOT EXECUTED 30006178: 03500002 cmpeq r0, #2 <== NOT EXECUTED 3000617c: 03a07000 moveq r7, #0 <== NOT EXECUTED 30006180: 13a07001 movne r7, #1 <== NOT EXECUTED 30006184: 0a000004 beq 3000619c <rtems_io_lookup_name+0x74> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
30006188: e1a00004 mov r0, r4 <== NOT EXECUTED 3000618c: eb0000bc bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
30006190: e3a0000d mov r0, #13 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
30006194: e28dd018 add sp, sp, #24 <== NOT EXECUTED
30006198: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
3000619c: e5865000 str r5, [r6] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
300061a0: e1a00005 mov r0, r5 <== NOT EXECUTED 300061a4: eb002fc9 bl 300120d0 <strlen> <== NOT EXECUTED 300061a8: e5860004 str r0, [r6, #4] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
300061ac: e5983050 ldr r3, [r8, #80] ; 0x50 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
300061b0: e1a00004 mov r0, r4 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
300061b4: e5863008 str r3, [r6, #8] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
300061b8: e5983054 ldr r3, [r8, #84] ; 0x54 <== NOT EXECUTED 300061bc: e586300c str r3, [r6, #12] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
300061c0: eb0000af bl 30006484 <rtems_filesystem_freenode> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
300061c4: e1a00007 mov r0, r7 <== NOT EXECUTED 300061c8: eafffff1 b 30006194 <rtems_io_lookup_name+0x6c> <== NOT EXECUTED
30010ec4 <rtems_io_open>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010ec4: e59fc044 ldr ip, [pc, #68] ; 30010f10 <rtems_io_open+0x4c>
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010ec8: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010ecc: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_open(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010ed0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010ed4: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30010ed8: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010edc: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].open_entry;
30010ee0: e59fc02c ldr ip, [pc, #44] ; 30010f14 <rtems_io_open+0x50> 30010ee4: e0833083 add r3, r3, r3, lsl #1 30010ee8: e59cc000 ldr ip, [ip] 30010eec: e08c3183 add r3, ip, r3, lsl #3 30010ef0: e5933004 ldr r3, [r3, #4]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010ef4: e3530000 cmp r3, #0
30010ef8: 0a000002 beq 30010f08 <rtems_io_open+0x44>
30010efc: e1a0e00f mov lr, pc
30010f00: e12fff13 bx r3
30010f04: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30010f08: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010f0c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30010f18 <rtems_io_read>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f18: e59fc044 ldr ip, [pc, #68] ; 30010f64 <rtems_io_read+0x4c>
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010f1c: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f20: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_read(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010f24: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f28: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30010f2c: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f30: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].read_entry;
30010f34: e59fc02c ldr ip, [pc, #44] ; 30010f68 <rtems_io_read+0x50> 30010f38: e0833083 add r3, r3, r3, lsl #1 30010f3c: e59cc000 ldr ip, [ip] 30010f40: e08c3183 add r3, ip, r3, lsl #3 30010f44: e593300c ldr r3, [r3, #12]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010f48: e3530000 cmp r3, #0
30010f4c: 0a000002 beq 30010f5c <rtems_io_read+0x44>
30010f50: e1a0e00f mov lr, pc
30010f54: e12fff13 bx r3
30010f58: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30010f5c: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010f60: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000b7a8 <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000b7a8: e59fc150 ldr ip, [pc, #336] ; 3000b900 <rtems_io_register_driver+0x158>
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000b7ac: e59f3150 ldr r3, [pc, #336] ; 3000b904 <rtems_io_register_driver+0x15c>
if ( rtems_interrupt_is_in_progress() )
3000b7b0: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
3000b7b4: e92d4030 push {r4, r5, lr}
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000b7b8: e35c0000 cmp ip, #0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
3000b7bc: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
3000b7c0: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
3000b7c4: 13a00012 movne r0, #18
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
3000b7c8: 18bd8030 popne {r4, r5, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
3000b7cc: e3520000 cmp r2, #0
3000b7d0: 0a00003f beq 3000b8d4 <rtems_io_register_driver+0x12c>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
3000b7d4: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
3000b7d8: e5820000 str r0, [r2]
if ( driver_table == NULL )
3000b7dc: 0a00003c beq 3000b8d4 <rtems_io_register_driver+0x12c>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b7e0: e591c000 ldr ip, [r1] 3000b7e4: e35c0000 cmp ip, #0
3000b7e8: 0a000036 beq 3000b8c8 <rtems_io_register_driver+0x120>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
3000b7ec: e1500004 cmp r0, r4
3000b7f0: 9a000027 bls 3000b894 <rtems_io_register_driver+0xec>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b7f4: e59f010c ldr r0, [pc, #268] ; 3000b908 <rtems_io_register_driver+0x160> 3000b7f8: e590c000 ldr ip, [r0] 3000b7fc: e28cc001 add ip, ip, #1 3000b800: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
3000b804: e3540000 cmp r4, #0
3000b808: 1a000023 bne 3000b89c <rtems_io_register_driver+0xf4>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
3000b80c: e593c000 ldr ip, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
3000b810: e35c0000 cmp ip, #0
3000b814: 0a000030 beq 3000b8dc <rtems_io_register_driver+0x134>
3000b818: e59fe0ec ldr lr, [pc, #236] ; 3000b90c <rtems_io_register_driver+0x164> 3000b81c: e59e3000 ldr r3, [lr] 3000b820: ea000003 b 3000b834 <rtems_io_register_driver+0x8c> 3000b824: e2844001 add r4, r4, #1 3000b828: e15c0004 cmp ip, r4 3000b82c: e2833018 add r3, r3, #24
3000b830: 9a000005 bls 3000b84c <rtems_io_register_driver+0xa4>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b834: e5930000 ldr r0, [r3] 3000b838: e3500000 cmp r0, #0
3000b83c: 1afffff8 bne 3000b824 <rtems_io_register_driver+0x7c>
3000b840: e5930004 ldr r0, [r3, #4] 3000b844: e3500000 cmp r0, #0
3000b848: 1afffff5 bne 3000b824 <rtems_io_register_driver+0x7c>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
3000b84c: e15c0004 cmp ip, r4 3000b850: 1084c084 addne ip, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000b854: e5824000 str r4, [r2]
if ( m != n )
3000b858: 11a0c18c lslne ip, ip, #3
3000b85c: 0a00001f beq 3000b8e0 <rtems_io_register_driver+0x138>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
3000b860: e59e5000 ldr r5, [lr]
3000b864: e1a0e001 mov lr, r1
3000b868: e085c00c add ip, r5, ip
3000b86c: e8be000f ldm lr!, {r0, r1, r2, r3}
3000b870: e8ac000f stmia ip!, {r0, r1, r2, r3}
3000b874: e89e0003 ldm lr, {r0, r1}
3000b878: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
3000b87c: eb0007ae bl 3000d73c <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
3000b880: e3a01000 mov r1, #0 3000b884: e1a00004 mov r0, r4 3000b888: e1a02001 mov r2, r1
}
3000b88c: e8bd4030 pop {r4, r5, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
3000b890: ea001f4a b 300135c0 <rtems_io_initialize>
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
return RTEMS_INVALID_NUMBER;
3000b894: e3a0000a mov r0, #10 <== NOT EXECUTED
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
}
3000b898: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000b89c: e59fe068 ldr lr, [pc, #104] ; 3000b90c <rtems_io_register_driver+0x164><== NOT EXECUTED 3000b8a0: e084c084 add ip, r4, r4, lsl #1 <== NOT EXECUTED 3000b8a4: e59e3000 ldr r3, [lr] <== NOT EXECUTED 3000b8a8: e1a0c18c lsl ip, ip, #3 <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b8ac: e793000c ldr r0, [r3, ip] <== NOT EXECUTED
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
3000b8b0: e083300c add r3, r3, ip <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b8b4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000b8b8: 0a00000b beq 3000b8ec <rtems_io_register_driver+0x144> <== NOT EXECUTED
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
3000b8bc: eb00079e bl 3000d73c <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
3000b8c0: e3a0000c mov r0, #12 <== NOT EXECUTED
3000b8c4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b8c8: e591c004 ldr ip, [r1, #4] 3000b8cc: e35c0000 cmp ip, #0
3000b8d0: 1affffc5 bne 3000b7ec <rtems_io_register_driver+0x44>
if ( driver_table == NULL )
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
3000b8d4: e3a00009 mov r0, #9 <== NOT EXECUTED
3000b8d8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
3000b8dc: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
3000b8e0: eb000795 bl 3000d73c <_Thread_Enable_dispatch> <== NOT EXECUTED
*major = m;
if ( m != n )
return RTEMS_SUCCESSFUL;
return RTEMS_TOO_MANY;
3000b8e4: e3a00005 mov r0, #5 <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
return sc;
3000b8e8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
3000b8ec: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 3000b8f0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000b8f4: 1afffff0 bne 3000b8bc <rtems_io_register_driver+0x114> <== NOT EXECUTED
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
3000b8f8: e5824000 str r4, [r2] <== NOT EXECUTED 3000b8fc: eaffffd7 b 3000b860 <rtems_io_register_driver+0xb8> <== NOT EXECUTED
3000b910 <rtems_io_unregister_driver>:
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b910: e59f3060 ldr r3, [pc, #96] ; 3000b978 <rtems_io_unregister_driver+0x68>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
3000b914: e92d4010 push {r4, lr}
if ( rtems_interrupt_is_in_progress() )
3000b918: e5934000 ldr r4, [r3] 3000b91c: e3540000 cmp r4, #0
return RTEMS_CALLED_FROM_ISR;
3000b920: 13a00012 movne r0, #18
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
if ( rtems_interrupt_is_in_progress() )
3000b924: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
3000b928: e59f304c ldr r3, [pc, #76] ; 3000b97c <rtems_io_unregister_driver+0x6c> 3000b92c: e5933000 ldr r3, [r3] 3000b930: e1530000 cmp r3, r0
3000b934: 8a000001 bhi 3000b940 <rtems_io_unregister_driver+0x30>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
3000b938: e3a0000d mov r0, #13 <== NOT EXECUTED
}
3000b93c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b940: e59f3038 ldr r3, [pc, #56] ; 3000b980 <rtems_io_unregister_driver+0x70> 3000b944: e5932000 ldr r2, [r3] 3000b948: e2822001 add r2, r2, #1 3000b94c: e5832000 str r2, [r3]
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000b950: e59f302c ldr r3, [pc, #44] ; 3000b984 <rtems_io_unregister_driver+0x74>
&_IO_Driver_address_table[major],
3000b954: e0800080 add r0, r0, r0, lsl #1
if ( rtems_interrupt_is_in_progress() )
return RTEMS_CALLED_FROM_ISR;
if ( major < _IO_Number_of_drivers ) {
_Thread_Disable_dispatch();
memset(
3000b958: e5933000 ldr r3, [r3] 3000b95c: e1a01004 mov r1, r4 3000b960: e3a02018 mov r2, #24 3000b964: e0830180 add r0, r3, r0, lsl #3 3000b968: eb00299d bl 30015fe4 <memset>
&_IO_Driver_address_table[major],
0,
sizeof( rtems_driver_address_table )
);
_Thread_Enable_dispatch();
3000b96c: eb000772 bl 3000d73c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b970: e1a00004 mov r0, r4
3000b974: e8bd8010 pop {r4, pc}
30010f6c <rtems_io_write>:
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f6c: e59fc044 ldr ip, [pc, #68] ; 30010fb8 <rtems_io_write+0x4c>
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010f70: e1a03000 mov r3, r0
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f74: e59cc000 ldr ip, [ip]
rtems_status_code rtems_io_write(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *argument
)
{
30010f78: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f7c: e15c0000 cmp ip, r0
return RTEMS_INVALID_NUMBER;
30010f80: 93a0000a movls r0, #10
void *argument
)
{
rtems_device_driver_entry callout;
if ( major >= _IO_Number_of_drivers )
30010f84: 949df004 popls {pc} ; (ldrls pc, [sp], #4)
return RTEMS_INVALID_NUMBER;
callout = _IO_Driver_address_table[major].write_entry;
30010f88: e59fc02c ldr ip, [pc, #44] ; 30010fbc <rtems_io_write+0x50> 30010f8c: e0833083 add r3, r3, r3, lsl #1 30010f90: e59cc000 ldr ip, [ip] 30010f94: e08c3183 add r3, ip, r3, lsl #3 30010f98: e5933010 ldr r3, [r3, #16]
return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
30010f9c: e3530000 cmp r3, #0
30010fa0: 0a000002 beq 30010fb0 <rtems_io_write+0x44>
30010fa4: e1a0e00f mov lr, pc
30010fa8: e12fff13 bx r3
30010fac: e49df004 pop {pc} ; (ldr pc, [sp], #4)
30010fb0: e1a00003 mov r0, r3 <== NOT EXECUTED
}
30010fb4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000c958 <rtems_iterate_over_all_threads>:
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
3000c958: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
3000c95c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
3000c960: 08bd81f0 popeq {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
3000c964: e59f705c ldr r7, [pc, #92] ; 3000c9c8 <rtems_iterate_over_all_threads+0x70><== NOT EXECUTED
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
3000c968: e287800c add r8, r7, #12 <== NOT EXECUTED
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
3000c96c: e5b73004 ldr r3, [r7, #4]! <== NOT EXECUTED 3000c970: e3530000 cmp r3, #0 <== NOT EXECUTED 3000c974: 0a000010 beq 3000c9bc <rtems_iterate_over_all_threads+0x64><== NOT EXECUTED
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
3000c978: e5935004 ldr r5, [r3, #4] <== NOT EXECUTED
if ( !information )
3000c97c: e3550000 cmp r5, #0 <== NOT EXECUTED 3000c980: 0a00000d beq 3000c9bc <rtems_iterate_over_all_threads+0x64><== NOT EXECUTED
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c984: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED 3000c988: e3520000 cmp r2, #0 <== NOT EXECUTED 3000c98c: 0a00000a beq 3000c9bc <rtems_iterate_over_all_threads+0x64><== NOT EXECUTED 3000c990: e3a04001 mov r4, #1 <== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
3000c994: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3000c998: e7930104 ldr r0, [r3, r4, lsl #2] <== NOT EXECUTED
if ( !the_thread )
3000c99c: e3500000 cmp r0, #0 <== NOT EXECUTED 3000c9a0: 0a000002 beq 3000c9b0 <rtems_iterate_over_all_threads+0x58><== NOT EXECUTED
continue;
(*routine)(the_thread);
3000c9a4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000c9a8: e12fff16 bx r6 <== NOT EXECUTED 3000c9ac: e1d521b0 ldrh r2, [r5, #16] <== NOT EXECUTED
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
3000c9b0: e2844001 add r4, r4, #1 <== NOT EXECUTED 3000c9b4: e1520004 cmp r2, r4 <== NOT EXECUTED 3000c9b8: 2afffff5 bcs 3000c994 <rtems_iterate_over_all_threads+0x3c><== NOT EXECUTED
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
3000c9bc: e1570008 cmp r7, r8 <== NOT EXECUTED
3000c9c0: 1affffe9 bne 3000c96c <rtems_iterate_over_all_threads+0x14><== NOT EXECUTED
3000c9c4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
300065b4 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
300065b4: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300065b8: e59f30b8 ldr r3, [pc, #184] ; 30006678 <rtems_libio_init+0xc4>
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
300065bc: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
300065c0: e5934000 ldr r4, [r3] 300065c4: e3540000 cmp r4, #0
300065c8: 0a000017 beq 3000662c <rtems_libio_init+0x78>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
300065cc: e1a00004 mov r0, r4 300065d0: e3a01038 mov r1, #56 ; 0x38 300065d4: ebffff42 bl 300062e4 <calloc> 300065d8: e59f309c ldr r3, [pc, #156] ; 3000667c <rtems_libio_init+0xc8>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300065dc: e3500000 cmp r0, #0
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
300065e0: e1a02000 mov r2, r0 300065e4: e5830000 str r0, [r3]
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
300065e8: 0a000020 beq 30006670 <rtems_libio_init+0xbc>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300065ec: e59f308c ldr r3, [pc, #140] ; 30006680 <rtems_libio_init+0xcc>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300065f0: e3540001 cmp r4, #1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
300065f4: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
300065f8: 9a000009 bls 30006624 <rtems_libio_init+0x70>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
300065fc: e2803038 add r3, r0, #56 ; 0x38 30006600: e3a02001 mov r2, #1
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
30006604: e2822001 add r2, r2, #1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30006608: e1520004 cmp r2, r4
iop->data1 = iop + 1;
3000660c: e5033004 str r3, [r3, #-4] 30006610: e2833038 add r3, r3, #56 ; 0x38
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30006614: 1afffffa bne 30006604 <rtems_libio_init+0x50>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
30006618: e2422001 sub r2, r2, #1 3000661c: e0622182 rsb r2, r2, r2, lsl #3
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
30006620: e0802182 add r2, r0, r2, lsl #3
iop->data1 = iop + 1;
iop->data1 = NULL;
30006624: e3a03000 mov r3, #0 30006628: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
3000662c: e59fc050 ldr ip, [pc, #80] ; 30006684 <rtems_libio_init+0xd0> 30006630: e59f0050 ldr r0, [pc, #80] ; 30006688 <rtems_libio_init+0xd4> 30006634: e3a01001 mov r1, #1 30006638: e3a02054 mov r2, #84 ; 0x54 3000663c: e3a03000 mov r3, #0 30006640: e58dc000 str ip, [sp] 30006644: eb000ca8 bl 300098ec <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
30006648: e3500000 cmp r0, #0
3000664c: 1a000006 bne 3000666c <rtems_libio_init+0xb8>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
30006650: e59f3034 ldr r3, [pc, #52] ; 3000668c <rtems_libio_init+0xd8> 30006654: e5933000 ldr r3, [r3] 30006658: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
3000665c: 11a0e00f movne lr, pc 30006660: 112fff13 bxne r3
}
30006664: e28dd004 add sp, sp, #4
30006668: e8bd8010 pop {r4, pc}
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
3000666c: eb000edf bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
30006670: e280001a add r0, r0, #26 <== NOT EXECUTED 30006674: eb000edd bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
30007bd4 <rtems_libio_set_private_env>:
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
30007bd4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
30007bd8: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self();
30007bdc: eb000b9a bl 3000aa4c <rtems_task_self>
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
30007be0: e28d7018 add r7, sp, #24 30007be4: e3a0c000 mov ip, #0 30007be8: e1a0200c mov r2, ip
}
rtems_status_code rtems_libio_set_private_env(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
30007bec: e1a06000 mov r6, r0
rtems_filesystem_location_info_t root_loc;
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
30007bf0: e3a01001 mov r1, #1 30007bf4: e59f00fc ldr r0, [pc, #252] ; 30007cf8 <rtems_libio_set_private_env+0x124> 30007bf8: e1a03007 mov r3, r7 30007bfc: e58dc000 str ip, [sp] 30007c00: ebfffb32 bl 300068d0 <rtems_filesystem_evaluate_path>
if (rv != 0)
30007c04: e250c000 subs ip, r0, #0
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
30007c08: 13a0001a movne r0, #26
rtems_filesystem_location_info_t current_loc;
rtems_user_env_t *new_env = NULL;
int rv = 0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
30007c0c: 0a000001 beq 30007c18 <rtems_libio_set_private_env+0x44>
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
}
30007c10: e28dd02c add sp, sp, #44 ; 0x2c
30007c14: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
rv = rtems_filesystem_evaluate_path("/", 1, 0, &root_loc, 0);
if (rv != 0)
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
30007c18: e28d5004 add r5, sp, #4 30007c1c: e59f00d4 ldr r0, [pc, #212] ; 30007cf8 <rtems_libio_set_private_env+0x124> 30007c20: e3a01001 mov r1, #1 30007c24: e1a0200c mov r2, ip 30007c28: e1a03005 mov r3, r5 30007c2c: e58dc000 str ip, [sp] 30007c30: ebfffb26 bl 300068d0 <rtems_filesystem_evaluate_path>
if (rv != 0)
30007c34: e3500000 cmp r0, #0
30007c38: 1a00002a bne 30007ce8 <rtems_libio_set_private_env+0x114>
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
rtems_current_user_env == &rtems_global_user_env
30007c3c: e59f30b8 ldr r3, [pc, #184] ; 30007cfc <rtems_libio_set_private_env+0x128> 30007c40: e5934000 ldr r4, [r3]
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
30007c44: e59f30b4 ldr r3, [pc, #180] ; 30007d00 <rtems_libio_set_private_env+0x12c> 30007c48: e1540003 cmp r4, r3
30007c4c: 0a000002 beq 30007c5c <rtems_libio_set_private_env+0x88>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
30007c50: e5943000 ldr r3, [r4] 30007c54: e1530006 cmp r3, r6
30007c58: 0a00000d beq 30007c94 <rtems_libio_set_private_env+0xc0>
) {
new_env = malloc(sizeof(rtems_user_env_t));
30007c5c: e3a00048 mov r0, #72 ; 0x48 30007c60: ebfffd02 bl 30007070 <malloc>
if (new_env == NULL)
30007c64: e3500000 cmp r0, #0
if (
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
) {
new_env = malloc(sizeof(rtems_user_env_t));
30007c68: e1a04000 mov r4, r0 30007c6c: e1a0a000 mov sl, r0
if (new_env == NULL)
30007c70: 0a00001a beq 30007ce0 <rtems_libio_set_private_env+0x10c>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
30007c74: e59f8080 ldr r8, [pc, #128] ; 30007cfc <rtems_libio_set_private_env+0x128> 30007c78: e3a00000 mov r0, #0 30007c7c: e1a01008 mov r1, r8 30007c80: e59f207c ldr r2, [pc, #124] ; 30007d04 <rtems_libio_set_private_env+0x130> 30007c84: eb000b8f bl 3000aac8 <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
30007c88: e3500000 cmp r0, #0
30007c8c: 1a000011 bne 30007cd8 <rtems_libio_set_private_env+0x104>
goto error_3;
rtems_current_user_env = new_env;
30007c90: e5884000 str r4, [r8]
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
30007c94: e59f1064 ldr r1, [pc, #100] ; 30007d00 <rtems_libio_set_private_env+0x12c> 30007c98: e3a02048 mov r2, #72 ; 0x48 30007c9c: e1a00004 mov r0, r4 30007ca0: eb002993 bl 300122f4 <memcpy>
* Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc;
30007ca4: e8b7000f ldm r7!, {r0, r1, r2, r3}
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
rtems_current_user_env->task_id = task_id;
30007ca8: e1a0c004 mov ip, r4 30007cac: e48c6018 str r6, [ip], #24
* original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc; rtems_filesystem_current = current_loc;
30007cb0: e2844004 add r4, r4, #4
* Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc;
30007cb4: e5976000 ldr r6, [r7]
30007cb8: e8ac000f stmia ip!, {r0, r1, r2, r3}
rtems_filesystem_current = current_loc;
30007cbc: e8b5000f ldm r5!, {r0, r1, r2, r3}
30007cc0: e8a4000f stmia r4!, {r0, r1, r2, r3}
30007cc4: e5953000 ldr r3, [r5]
* Clone the pathlocs. In contrast to most other code we must _not_ free the * original locs because what we are trying to do here is forking off clones. * The reason is a pathloc can be allocated by the file system and needs to * be freed when deleting the environment. */ rtems_filesystem_root = root_loc;
30007cc8: e58c6000 str r6, [ip]
rtems_filesystem_current = current_loc;
30007ccc: e5843000 str r3, [r4]
return RTEMS_SUCCESSFUL;
30007cd0: e3a00000 mov r0, #0 30007cd4: eaffffcd b 30007c10 <rtems_libio_set_private_env+0x3c>
error_3:
free(new_env);
30007cd8: e1a00004 mov r0, r4 <== NOT EXECUTED 30007cdc: ebfffb3a bl 300069cc <free> <== NOT EXECUTED
error_2:
rtems_filesystem_freenode(¤t_loc);
30007ce0: e1a00005 mov r0, r5 30007ce4: ebfffb33 bl 300069b8 <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
30007ce8: e1a00007 mov r0, r7 30007cec: ebfffb31 bl 300069b8 <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
30007cf0: e3a0001a mov r0, #26 30007cf4: eaffffc5 b 30007c10 <rtems_libio_set_private_env+0x3c>
30007d08 <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
30007d08: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30007d0c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30007d10: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007d14: eb000b4c bl 3000aa4c <rtems_task_self> <== NOT EXECUTED
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
30007d18: e1560000 cmp r6, r0 <== NOT EXECUTED
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
30007d1c: e1a04000 mov r4, r0 <== NOT EXECUTED
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
return RTEMS_SUCCESSFUL;
30007d20: 03a06000 moveq r6, #0 <== NOT EXECUTED
/*
* If this was an attempt to share the task with self,
* if somebody wanted to do it... Lets tell them, its shared
*/
if( task_id == current_task_id )
30007d24: 0a00000c beq 30007d5c <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
30007d28: e59f5040 ldr r5, [pc, #64] ; 30007d70 <rtems_libio_share_private_env+0x68><== NOT EXECUTED 30007d2c: e1a00006 mov r0, r6 <== NOT EXECUTED 30007d30: e1a01005 mov r1, r5 <== NOT EXECUTED 30007d34: e1a0200d mov r2, sp <== NOT EXECUTED 30007d38: eb000b8e bl 3000ab78 <rtems_task_variable_get> <== NOT EXECUTED
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
30007d3c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 30007d40: 1a000005 bne 30007d5c <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
* If we have a current environment in place, we need to
* free it, since we will be sharing the variable with the
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
30007d44: e5950000 ldr r0, [r5] <== NOT EXECUTED 30007d48: e5903000 ldr r3, [r0] <== NOT EXECUTED 30007d4c: e1530004 cmp r3, r4 <== NOT EXECUTED 30007d50: 0a000004 beq 30007d68 <rtems_libio_share_private_env+0x60> <== NOT EXECUTED
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
30007d54: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30007d58: e5853000 str r3, [r5] <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
30007d5c: e1a00006 mov r0, r6 <== NOT EXECUTED
30007d60: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30007d64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* shared_user_env
*/
if (rtems_current_user_env->task_id==current_task_id) {
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
30007d68: ebffff8c bl 30007ba0 <free_user_env> <== NOT EXECUTED 30007d6c: eafffff8 b 30007d54 <rtems_libio_share_private_env+0x4c> <== NOT EXECUTED
3000e5ec <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000e5ec: e2002006 and r2, r0, #6 3000e5f0: e3520006 cmp r2, #6
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
3000e5f4: e1a03000 mov r3, r0
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000e5f8: 03a00002 moveq r0, #2
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
3000e5fc: 0a000002 beq 3000e60c <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000e600: e3130002 tst r3, #2
fcntl_flags |= O_RDONLY;
3000e604: 13a00000 movne r0, #0
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
3000e608: 0a000006 beq 3000e628 <rtems_libio_to_fcntl_flags+0x3c>
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
3000e60c: e3130001 tst r3, #1
fcntl_flags |= O_NONBLOCK;
3000e610: 13800901 orrne r0, r0, #16384 ; 0x4000
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
3000e614: e3130c02 tst r3, #512 ; 0x200
fcntl_flags |= O_APPEND;
3000e618: 13800008 orrne r0, r0, #8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
3000e61c: e3130b01 tst r3, #1024 ; 0x400
fcntl_flags |= O_CREAT;
3000e620: 13800c02 orrne r0, r0, #512 ; 0x200
}
return fcntl_flags;
}
3000e624: e12fff1e bx lr
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
3000e628: e3130004 tst r3, #4 <== NOT EXECUTED 3000e62c: 03a00000 moveq r0, #0 <== NOT EXECUTED 3000e630: 13a00001 movne r0, #1 <== NOT EXECUTED 3000e634: eafffff4 b 3000e60c <rtems_libio_to_fcntl_flags+0x20> <== NOT EXECUTED
3000aa64 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000aa64: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000aa68: e59f3040 ldr r3, [pc, #64] ; 3000aab0 <rtems_malloc_statistics_at_free+0x4c><== NOT EXECUTED
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
3000aa6c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000aa70: e1a01000 mov r1, r0 <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
3000aa74: e1a0200d mov r2, sp <== NOT EXECUTED 3000aa78: e5930000 ldr r0, [r3] <== NOT EXECUTED 3000aa7c: eb001868 bl 30010c24 <_Protected_heap_Get_block_size> <== NOT EXECUTED 3000aa80: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aa84: 0a000007 beq 3000aaa8 <rtems_malloc_statistics_at_free+0x44><== NOT EXECUTED
MSBUMP(lifetime_freed, size);
3000aa88: e59f3024 ldr r3, [pc, #36] ; 3000aab4 <rtems_malloc_statistics_at_free+0x50><== NOT EXECUTED
3000aa8c: e59d0000 ldr r0, [sp] <== NOT EXECUTED
3000aa90: e2832024 add r2, r3, #36 ; 0x24 <== NOT EXECUTED
3000aa94: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3000aa98: e0911000 adds r1, r1, r0 <== NOT EXECUTED
3000aa9c: e2a22000 adc r2, r2, #0 <== NOT EXECUTED
3000aaa0: e5831024 str r1, [r3, #36] ; 0x24 <== NOT EXECUTED
3000aaa4: e5832028 str r2, [r3, #40] ; 0x28 <== NOT EXECUTED
} }
3000aaa8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aaac: e8bd8000 pop {pc} <== NOT EXECUTED
30012d90 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30012d90: e92d4070 push {r4, r5, r6, lr}
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30012d94: e2504000 subs r4, r0, #0
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
30012d98: e1a05001 mov r5, r1 30012d9c: e1a06002 mov r6, r2
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
30012da0: 0a00001a beq 30012e10 <rtems_memalign+0x80>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012da4: e59f3074 ldr r3, [pc, #116] ; 30012e20 <rtems_memalign+0x90>
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
30012da8: e3a02000 mov r2, #0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012dac: e5933000 ldr r3, [r3]
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
30012db0: e5842000 str r2, [r4]
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012db4: e3530003 cmp r3, #3
30012db8: 0a000011 beq 30012e04 <rtems_memalign+0x74>
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
30012dbc: ebffd2e8 bl 30007964 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
30012dc0: e59f305c ldr r3, [pc, #92] ; 30012e24 <rtems_memalign+0x94> 30012dc4: e1a02005 mov r2, r5 30012dc8: e5930000 ldr r0, [r3] 30012dcc: e1a01006 mov r1, r6 30012dd0: e3a03000 mov r3, #0 30012dd4: ebffe78d bl 3000cc10 <_Protected_heap_Allocate_aligned_with_boundary>
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
30012dd8: e2505000 subs r5, r0, #0
30012ddc: 0a00000d beq 30012e18 <rtems_memalign+0x88>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
30012de0: e59f3040 ldr r3, [pc, #64] ; 30012e28 <rtems_memalign+0x98> 30012de4: e5933000 ldr r3, [r3] 30012de8: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
30012dec: 11a00004 movne r0, r4 30012df0: 11a0e00f movne lr, pc 30012df4: 1593f004 ldrne pc, [r3, #4]
*pointer = return_this;
30012df8: e5845000 str r5, [r4]
return 0;
30012dfc: e3a00000 mov r0, #0
30012e00: e8bd8070 pop {r4, r5, r6, pc}
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
30012e04: ebffd2c2 bl 30007914 <malloc_is_system_state_OK>
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
30012e08: e3500000 cmp r0, #0
30012e0c: 1affffea bne 30012dbc <rtems_memalign+0x2c>
!malloc_is_system_state_OK() )
return EINVAL;
30012e10: e3a00016 mov r0, #22 <== NOT EXECUTED
30012e14: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
30012e18: e3a0000c mov r0, #12 <== NOT EXECUTED
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
*pointer = return_this;
return 0;
}
30012e1c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30017a90 <rtems_message_queue_broadcast>:
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30017a90: e92d40f0 push {r4, r5, r6, r7, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30017a94: e2516000 subs r6, r1, #0
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
30017a98: e24dd00c sub sp, sp, #12 30017a9c: e1a04000 mov r4, r0 30017aa0: e1a05002 mov r5, r2 30017aa4: e1a07003 mov r7, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
30017aa8: 0a000016 beq 30017b08 <rtems_message_queue_broadcast+0x78>
return RTEMS_INVALID_ADDRESS;
if ( !count )
30017aac: e3530000 cmp r3, #0
30017ab0: 0a000014 beq 30017b08 <rtems_message_queue_broadcast+0x78>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30017ab4: e59f0054 ldr r0, [pc, #84] ; 30017b10 <rtems_message_queue_broadcast+0x80> 30017ab8: e1a01004 mov r1, r4 30017abc: e28d2008 add r2, sp, #8 30017ac0: eb0014d9 bl 3001ce2c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ac4: e59d3008 ldr r3, [sp, #8] 30017ac8: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30017acc: 13a00004 movne r0, #4
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ad0: 1a00000a bne 30017b00 <rtems_message_queue_broadcast+0x70>
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
30017ad4: e58d3000 str r3, [sp] 30017ad8: e1a01006 mov r1, r6 30017adc: e1a03004 mov r3, r4 30017ae0: e1a02005 mov r2, r5 30017ae4: e2800014 add r0, r0, #20 30017ae8: e58d7004 str r7, [sp, #4] 30017aec: eb000dbf bl 3001b1f0 <_CORE_message_queue_Broadcast> 30017af0: e1a04000 mov r4, r0
NULL,
#endif
count
);
_Thread_Enable_dispatch();
30017af4: eb00181b bl 3001db68 <_Thread_Enable_dispatch>
return
30017af8: e1a00004 mov r0, r4 30017afc: eb0000d5 bl 30017e58 <_Message_queue_Translate_core_message_queue_return_code>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017b00: e28dd00c add sp, sp, #12
30017b04: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30017b08: e3a00009 mov r0, #9 <== NOT EXECUTED 30017b0c: eafffffb b 30017b00 <rtems_message_queue_broadcast+0x70> <== NOT EXECUTED
3001204c <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3001204c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
30012050: e2507000 subs r7, r0, #0
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30012054: e24dd008 sub sp, sp, #8 30012058: e1a04001 mov r4, r1 3001205c: e1a06002 mov r6, r2 30012060: e59d5020 ldr r5, [sp, #32]
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30012064: 03a00003 moveq r0, #3
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
30012068: 0a000008 beq 30012090 <rtems_message_queue_create+0x44>
return RTEMS_INVALID_NAME;
if ( !id )
3001206c: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
30012070: 03a00009 moveq r0, #9
#endif
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30012074: 0a000005 beq 30012090 <rtems_message_queue_create+0x44>
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30012078: e3510000 cmp r1, #0
return RTEMS_INVALID_NUMBER;
3001207c: 03a0000a moveq r0, #10
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
30012080: 0a000002 beq 30012090 <rtems_message_queue_create+0x44>
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
30012084: e3520000 cmp r2, #0
return RTEMS_INVALID_SIZE;
30012088: 03a00008 moveq r0, #8
#endif
if ( count == 0 )
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
3001208c: 1a000001 bne 30012098 <rtems_message_queue_create+0x4c>
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30012090: e28dd008 add sp, sp, #8
30012094: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30012098: e59f2098 ldr r2, [pc, #152] ; 30012138 <rtems_message_queue_create+0xec> 3001209c: e5921000 ldr r1, [r2] 300120a0: e2811001 add r1, r1, #1 300120a4: e5821000 str r1, [r2]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
300120a8: e58d3000 str r3, [sp] 300120ac: eb00170f bl 30017cf0 <_Message_queue_Allocate>
if ( !the_message_queue ) {
300120b0: e2508000 subs r8, r0, #0 300120b4: e59d3000 ldr r3, [sp]
300120b8: 0a00001b beq 3001212c <rtems_message_queue_create+0xe0>
}
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
300120bc: e2132004 ands r2, r3, #4
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_message_queue->attribute_set = attribute_set;
300120c0: e5883010 str r3, [r8, #16]
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
300120c4: 13a03001 movne r3, #1 300120c8: 158d3004 strne r3, [sp, #4]
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
300120cc: 058d2004 streq r2, [sp, #4]
if ( ! _CORE_message_queue_Initialize(
300120d0: e2880014 add r0, r8, #20 300120d4: e28d1004 add r1, sp, #4 300120d8: e1a02004 mov r2, r4 300120dc: e1a03006 mov r3, r6 300120e0: eb000474 bl 300132b8 <_CORE_message_queue_Initialize> 300120e4: e3500000 cmp r0, #0
300120e8: 1a000005 bne 30012104 <rtems_message_queue_create+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
300120ec: e59f0048 ldr r0, [pc, #72] ; 3001213c <rtems_message_queue_create+0xf0><== NOT EXECUTED 300120f0: e1a01008 mov r1, r8 <== NOT EXECUTED 300120f4: eb00082a bl 300141a4 <_Objects_Free> <== NOT EXECUTED
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
300120f8: eb000bf7 bl 300150dc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
300120fc: e3a0000d mov r0, #13 <== NOT EXECUTED 30012100: eaffffe2 b 30012090 <rtems_message_queue_create+0x44> <== NOT EXECUTED
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012104: e59f2030 ldr r2, [pc, #48] ; 3001213c <rtems_message_queue_create+0xf0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30012108: e5983008 ldr r3, [r8, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001210c: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30012110: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30012114: e7828721 str r8, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30012118: e588700c str r7, [r8, #12]
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
3001211c: e5853000 str r3, [r5]
name,
0
);
#endif
_Thread_Enable_dispatch();
30012120: eb000bed bl 300150dc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30012124: e3a00000 mov r0, #0 30012128: eaffffd8 b 30012090 <rtems_message_queue_create+0x44>
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
3001212c: eb000bea bl 300150dc <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30012130: e3a00005 mov r0, #5 <== NOT EXECUTED 30012134: eaffffd5 b 30012090 <rtems_message_queue_create+0x44> <== NOT EXECUTED
30017cc4 <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30017cc4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30017cc8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_message_queue_get_number_pending(
rtems_id id,
uint32_t *count
)
{
30017ccc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30017cd0: e1a01000 mov r1, r0 <== NOT EXECUTED
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
return RTEMS_INVALID_ADDRESS;
30017cd4: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
30017cd8: 0a00000a beq 30017d08 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED 30017cdc: e59f002c ldr r0, [pc, #44] ; 30017d10 <rtems_message_queue_get_number_pending+0x4c><== NOT EXECUTED 30017ce0: e1a0200d mov r2, sp <== NOT EXECUTED 30017ce4: eb001450 bl 3001ce2c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017ce8: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30017cec: e3550000 cmp r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30017cf0: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
30017cf4: 1a000003 bne 30017d08 <rtems_message_queue_get_number_pending+0x44><== NOT EXECUTED
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
30017cf8: e590305c ldr r3, [r0, #92] ; 0x5c <== NOT EXECUTED 30017cfc: e5843000 str r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
30017d00: eb001798 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30017d04: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30017d08: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30017d0c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30012174 <rtems_message_queue_receive>:
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
30012174: e92d4070 push {r4, r5, r6, lr}
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
30012178: e2515000 subs r5, r1, #0
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
3001217c: e24dd00c sub sp, sp, #12 30012180: e1a01000 mov r1, r0 30012184: e1a04002 mov r4, r2 30012188: e1a06003 mov r6, r3
register Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
if ( !buffer )
3001218c: 0a000019 beq 300121f8 <rtems_message_queue_receive+0x84>
return RTEMS_INVALID_ADDRESS;
if ( !size )
30012190: e3520000 cmp r2, #0
30012194: 0a000017 beq 300121f8 <rtems_message_queue_receive+0x84>
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
_Objects_Get( &_Message_queue_Information, id, location );
30012198: e59f0060 ldr r0, [pc, #96] ; 30012200 <rtems_message_queue_receive+0x8c> 3001219c: e28d2008 add r2, sp, #8 300121a0: eb000856 bl 30014300 <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300121a4: e59d3008 ldr r3, [sp, #8] 300121a8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300121ac: 13a00004 movne r0, #4
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
300121b0: 1a00000e bne 300121f0 <rtems_message_queue_receive+0x7c>
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
_CORE_message_queue_Seize(
300121b4: e59d301c ldr r3, [sp, #28]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
300121b8: e2066001 and r6, r6, #1 300121bc: e5901008 ldr r1, [r0, #8] 300121c0: e1a02005 mov r2, r5 300121c4: e2800014 add r0, r0, #20 300121c8: e58d3004 str r3, [sp, #4] 300121cc: e2266001 eor r6, r6, #1 300121d0: e1a03004 mov r3, r4 300121d4: e58d6000 str r6, [sp] 300121d8: eb000467 bl 3001337c <_CORE_message_queue_Seize>
buffer,
size,
wait,
timeout
);
_Thread_Enable_dispatch();
300121dc: eb000bbe bl 300150dc <_Thread_Enable_dispatch>
return _Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
300121e0: e59f301c ldr r3, [pc, #28] ; 30012204 <rtems_message_queue_receive+0x90> 300121e4: e5933004 ldr r3, [r3, #4]
size,
wait,
timeout
);
_Thread_Enable_dispatch();
return _Message_queue_Translate_core_message_queue_return_code(
300121e8: e5930034 ldr r0, [r3, #52] ; 0x34 300121ec: eb000024 bl 30012284 <_Message_queue_Translate_core_message_queue_return_code>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300121f0: e28dd00c add sp, sp, #12
300121f4: e8bd8070 pop {r4, r5, r6, pc}
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
300121f8: e3a00009 mov r0, #9 <== NOT EXECUTED 300121fc: eafffffb b 300121f0 <rtems_message_queue_receive+0x7c> <== NOT EXECUTED
3000ba1c <rtems_object_api_maximum_class>:
int rtems_object_api_maximum_class(
int api
)
{
return _Objects_API_maximum_class(api);
3000ba1c: ea000632 b 3000d2ec <_Objects_API_maximum_class> <== NOT EXECUTED
3000ba20 <rtems_object_api_minimum_class>:
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
3000ba20: e2400001 sub r0, r0, #1 <== NOT EXECUTED
uint32_t api
)
{
if ( _Objects_Is_api_valid( api ) )
return 1;
return -1;
3000ba24: e3500003 cmp r0, #3 <== NOT EXECUTED
}
3000ba28: 33a00001 movcc r0, #1 <== NOT EXECUTED 3000ba2c: 23e00000 mvncs r0, #0 <== NOT EXECUTED 3000ba30: e12fff1e bx lr <== NOT EXECUTED
3000ba34 <rtems_object_get_api_class_name>:
)
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000ba34: e3500001 cmp r0, #1 <== NOT EXECUTED
const char *rtems_object_get_api_class_name(
int the_api,
int the_class
)
{
3000ba38: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
3000ba3c: 0a000004 beq 3000ba54 <rtems_object_get_api_class_name+0x20><== NOT EXECUTED
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000ba40: e3500002 cmp r0, #2 <== NOT EXECUTED
api_assoc = rtems_object_api_classic_assoc;
3000ba44: 059f0024 ldreq r0, [pc, #36] ; 3000ba70 <rtems_object_get_api_class_name+0x3c><== NOT EXECUTED
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
else if ( the_api == OBJECTS_CLASSIC_API )
3000ba48: 0a000002 beq 3000ba58 <rtems_object_get_api_class_name+0x24><== NOT EXECUTED
#ifdef RTEMS_POSIX_API
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
3000ba4c: e59f0020 ldr r0, [pc, #32] ; 3000ba74 <rtems_object_get_api_class_name+0x40><== NOT EXECUTED
3000ba50: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
const rtems_assoc_t *api_assoc;
const rtems_assoc_t *class_assoc;
if ( the_api == OBJECTS_INTERNAL_API )
api_assoc = rtems_object_api_internal_assoc;
3000ba54: e59f001c ldr r0, [pc, #28] ; 3000ba78 <rtems_object_get_api_class_name+0x44><== NOT EXECUTED
else if ( the_api == OBJECTS_POSIX_API )
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
3000ba58: eb0013e6 bl 300109f8 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( class_assoc )
3000ba5c: e3500000 cmp r0, #0 <== NOT EXECUTED
return class_assoc->name;
3000ba60: 15900000 ldrne r0, [r0] <== NOT EXECUTED
api_assoc = rtems_object_api_posix_assoc;
#endif
else
return "BAD API";
class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class );
if ( class_assoc )
3000ba64: 149df004 popne {pc} ; (ldrne pc, [sp], #4) <== NOT EXECUTED
return class_assoc->name;
return "BAD CLASS";
3000ba68: e59f000c ldr r0, [pc, #12] ; 3000ba7c <rtems_object_get_api_class_name+0x48><== NOT EXECUTED
}
3000ba6c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000ba80 <rtems_object_get_api_name>:
};
const char *rtems_object_get_api_name(
int api
)
{
3000ba80: e1a01000 mov r1, r0 <== NOT EXECUTED
3000ba84: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *api_assoc;
api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api );
3000ba88: e59f0010 ldr r0, [pc, #16] ; 3000baa0 <rtems_object_get_api_name+0x20><== NOT EXECUTED 3000ba8c: eb0013d9 bl 300109f8 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if ( api_assoc )
3000ba90: e3500000 cmp r0, #0 <== NOT EXECUTED
return api_assoc->name;
3000ba94: 15900000 ldrne r0, [r0] <== NOT EXECUTED
return "BAD CLASS";
3000ba98: 059f0004 ldreq r0, [pc, #4] ; 3000baa4 <rtems_object_get_api_name+0x24><== NOT EXECUTED
}
3000ba9c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
3000bae0 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
int the_api,
int the_class,
rtems_object_api_class_information *info
)
{
3000bae0: e92d4010 push {r4, lr} <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000bae4: e2524000 subs r4, r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000bae8: 03a00009 moveq r0, #9 <== NOT EXECUTED
int i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
3000baec: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
3000baf0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3000baf4: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3000baf8: eb0006d9 bl 3000d664 <_Objects_Get_information> <== NOT EXECUTED
if ( !obj_info )
3000bafc: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bb00: 0a000018 beq 3000bb68 <rtems_object_get_class_information+0x88><== NOT EXECUTED
* Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum;
3000bb04: e1d011b0 ldrh r1, [r0, #16] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000bb08: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bb0c: e590200c ldr r2, [r0, #12] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bb10: e5d03012 ldrb r3, [r0, #18] <== NOT EXECUTED
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb14: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
3000bb18: e584c000 str ip, [r4] <== NOT EXECUTED
info->maximum_id = obj_info->maximum_id;
3000bb1c: e5842004 str r2, [r4, #4] <== NOT EXECUTED
info->auto_extend = obj_info->auto_extend;
3000bb20: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
info->maximum = obj_info->maximum;
3000bb24: e5841008 str r1, [r4, #8] <== NOT EXECUTED
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb28: 01a0c001 moveq ip, r1 <== NOT EXECUTED 3000bb2c: 0a00000a beq 3000bb5c <rtems_object_get_class_information+0x7c><== NOT EXECUTED 3000bb30: e3a02001 mov r2, #1 <== NOT EXECUTED 3000bb34: e590001c ldr r0, [r0, #28] <== NOT EXECUTED 3000bb38: e1a03002 mov r3, r2 <== NOT EXECUTED 3000bb3c: e3a0c000 mov ip, #0 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bb40: e7902102 ldr r2, [r0, r2, lsl #2] <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb44: e2833001 add r3, r3, #1 <== NOT EXECUTED
if ( !obj_info->local_table[i] )
3000bb48: e3520000 cmp r2, #0 <== NOT EXECUTED
unallocated++;
3000bb4c: 028cc001 addeq ip, ip, #1 <== NOT EXECUTED
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
3000bb50: e1510003 cmp r1, r3 <== NOT EXECUTED 3000bb54: e1a02003 mov r2, r3 <== NOT EXECUTED 3000bb58: 2afffff8 bcs 3000bb40 <rtems_object_get_class_information+0x60><== NOT EXECUTED
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
3000bb5c: e584c010 str ip, [r4, #16] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bb60: e3a00000 mov r0, #0 <== NOT EXECUTED
3000bb64: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if ( !info )
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
if ( !obj_info )
return RTEMS_INVALID_NUMBER;
3000bb68: e3a0000a mov r0, #10 <== NOT EXECUTED
unallocated++;
info->unallocated = unallocated;
return RTEMS_SUCCESSFUL;
}
3000bb6c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000ae28 <rtems_object_get_classic_name>:
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
3000ae28: e92d4010 push {r4, lr} <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000ae2c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_object_get_classic_name(
rtems_id id,
rtems_name *name
)
{
3000ae30: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
return RTEMS_INVALID_ADDRESS;
3000ae34: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Objects_Name_or_id_lookup_errors status;
Objects_Name name_u;
if ( !name )
3000ae38: 0a000005 beq 3000ae54 <rtems_object_get_classic_name+0x2c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
status = _Objects_Id_to_name( id, &name_u );
3000ae3c: e1a0100d mov r1, sp <== NOT EXECUTED 3000ae40: eb000705 bl 3000ca5c <_Objects_Id_to_name> <== NOT EXECUTED
*name = name_u.name_u32;
3000ae44: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000ae48: e5843000 str r3, [r4] <== NOT EXECUTED
return _Status_Object_name_errors_to_status[ status ];
3000ae4c: e59f3008 ldr r3, [pc, #8] ; 3000ae5c <rtems_object_get_classic_name+0x34><== NOT EXECUTED 3000ae50: e7930100 ldr r0, [r3, r0, lsl #2] <== NOT EXECUTED
}
3000ae54: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000ae58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000b03c <rtems_object_get_name>:
Objects_Id id,
size_t length,
char *name
)
{
return _Objects_Get_name_as_string( id, length, name );
3000b03c: ea000793 b 3000ce90 <_Objects_Get_name_as_string> <== NOT EXECUTED
3000bb74 <rtems_object_id_api_maximum>:
#undef rtems_object_id_api_maximum
int rtems_object_id_api_maximum(void)
{
return OBJECTS_APIS_LAST;
}
3000bb74: e3a00003 mov r0, #3 <== NOT EXECUTED 3000bb78: e12fff1e bx lr <== NOT EXECUTED
3000bb7c <rtems_object_id_api_minimum>:
#undef rtems_object_id_api_minimum
int rtems_object_id_api_minimum(void)
{
return OBJECTS_INTERNAL_API;
}
3000bb7c: e3a00001 mov r0, #1 <== NOT EXECUTED 3000bb80: e12fff1e bx lr <== NOT EXECUTED
3000bb84 <rtems_object_id_get_api>:
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
3000bb84: e1a00c20 lsr r0, r0, #24 <== NOT EXECUTED
int rtems_object_id_get_api(
rtems_id id
)
{
return _Objects_Get_API( id );
}
3000bb88: e2000007 and r0, r0, #7 <== NOT EXECUTED 3000bb8c: e12fff1e bx lr <== NOT EXECUTED
3000bb90 <rtems_object_id_get_class>:
int rtems_object_id_get_class(
rtems_id id
)
{
return _Objects_Get_class( id );
}
3000bb90: e1a00da0 lsr r0, r0, #27 <== NOT EXECUTED 3000bb94: e12fff1e bx lr <== NOT EXECUTED
3000bb98 <rtems_object_id_get_index>:
#undef rtems_object_id_get_index
int rtems_object_id_get_index(
rtems_id id
)
{
return _Objects_Get_index( id );
3000bb98: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
}
3000bb9c: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 3000bba0: e12fff1e bx lr <== NOT EXECUTED
3000bba4 <rtems_object_id_get_node>:
* be a single processor system.
*/
#if defined(RTEMS_USE_16_BIT_OBJECT)
return 1;
#else
return (id >> OBJECTS_NODE_START_BIT) & OBJECTS_NODE_VALID_BITS;
3000bba4: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED
int rtems_object_id_get_node(
rtems_id id
)
{
return _Objects_Get_node( id );
}
3000bba8: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 3000bbac: e12fff1e bx lr <== NOT EXECUTED
3000bbb0 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000bbb0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000bbb4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
3000bbb8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
3000bbbc: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
3000bbc0: 0a000010 beq 3000bc08 <rtems_object_set_name+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
3000bbc4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000bbc8: 059f3058 ldreq r3, [pc, #88] ; 3000bc28 <rtems_object_set_name+0x78><== NOT EXECUTED 3000bbcc: 11a04000 movne r4, r0 <== NOT EXECUTED 3000bbd0: 05933004 ldreq r3, [r3, #4] <== NOT EXECUTED 3000bbd4: 05934008 ldreq r4, [r3, #8] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
3000bbd8: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bbdc: eb00069b bl 3000d650 <_Objects_Get_information_id> <== NOT EXECUTED
if ( !information )
3000bbe0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3000bbe4: 0a000006 beq 3000bc04 <rtems_object_set_name+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000bbe8: e1a01004 mov r1, r4 <== NOT EXECUTED 3000bbec: e1a0200d mov r2, sp <== NOT EXECUTED 3000bbf0: eb000711 bl 3000d83c <_Objects_Get> <== NOT EXECUTED
switch ( location ) {
3000bbf4: e59d4000 ldr r4, [sp] <== NOT EXECUTED
information = _Objects_Get_information_id( tmpId );
if ( !information )
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
3000bbf8: e1a01000 mov r1, r0 <== NOT EXECUTED
switch ( location ) {
3000bbfc: e3540000 cmp r4, #0 <== NOT EXECUTED 3000bc00: 0a000002 beq 3000bc10 <rtems_object_set_name+0x60> <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000bc04: e3a00004 mov r0, #4 <== NOT EXECUTED
}
3000bc08: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000bc0c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_object = _Objects_Get( information, tmpId, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
3000bc10: e1a02005 mov r2, r5 <== NOT EXECUTED 3000bc14: e1a00006 mov r0, r6 <== NOT EXECUTED 3000bc18: eb00077e bl 3000da18 <_Objects_Set_name> <== NOT EXECUTED
_Thread_Enable_dispatch();
3000bc1c: eb000a75 bl 3000e5f8 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000bc20: e1a00004 mov r0, r4 <== NOT EXECUTED 3000bc24: eafffff7 b 3000bc08 <rtems_object_set_name+0x58> <== NOT EXECUTED
3000b120 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
3000b120: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
3000b124: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3000b128: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
3000b12c: e28d300c add r3, sp, #12 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000b130: e1a02003 mov r2, r3 <== NOT EXECUTED 3000b134: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3000b138: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
3000b13c: e58d3000 str r3, [sp] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
3000b140: ebffff7f bl 3000af44 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
rtems_error(0, "fatal error, exiting");
3000b144: e59f1010 ldr r1, [pc, #16] ; 3000b15c <rtems_panic+0x3c> <== NOT EXECUTED 3000b148: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b14c: ebffffd6 bl 3000b0ac <rtems_error> <== NOT EXECUTED
_exit(errno);
3000b150: eb002dbb bl 30016844 <__errno> <== NOT EXECUTED 3000b154: e5900000 ldr r0, [r0] <== NOT EXECUTED 3000b158: eb0002af bl 3000bc1c <_exit> <== NOT EXECUTED
30017ee4 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30017ee4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30017ee8: e2506000 subs r6, r0, #0
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
30017eec: e24dd008 sub sp, sp, #8 30017ef0: e1a04001 mov r4, r1 30017ef4: e59d502c ldr r5, [sp, #44] ; 0x2c
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30017ef8: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
30017efc: 0a000031 beq 30017fc8 <rtems_partition_create+0xe4>
return RTEMS_INVALID_NAME;
if ( !starting_address )
30017f00: e3510000 cmp r1, #0
30017f04: 0a000033 beq 30017fd8 <rtems_partition_create+0xf4>
return RTEMS_INVALID_ADDRESS;
if ( !id )
30017f08: e3550000 cmp r5, #0
30017f0c: 0a000031 beq 30017fd8 <rtems_partition_create+0xf4>
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
30017f10: e3520000 cmp r2, #0 30017f14: 13530000 cmpne r3, #0
30017f18: 0a00002c beq 30017fd0 <rtems_partition_create+0xec>
30017f1c: e1520003 cmp r2, r3
30017f20: 3a00002a bcc 30017fd0 <rtems_partition_create+0xec>
30017f24: e3130007 tst r3, #7
30017f28: 1a000028 bne 30017fd0 <rtems_partition_create+0xec>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
30017f2c: e2118007 ands r8, r1, #7
30017f30: 1a000028 bne 30017fd8 <rtems_partition_create+0xf4>
30017f34: e59f10b0 ldr r1, [pc, #176] ; 30017fec <rtems_partition_create+0x108> 30017f38: e5910000 ldr r0, [r1] 30017f3c: e2800001 add r0, r0, #1 30017f40: e5810000 str r0, [r1]
* This function allocates a partition control block from
* the inactive chain of free partition control blocks.
*/
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void )
{
return (Partition_Control *) _Objects_Allocate( &_Partition_Information );
30017f44: e59fa0a4 ldr sl, [pc, #164] ; 30017ff0 <rtems_partition_create+0x10c> 30017f48: e58d2004 str r2, [sp, #4] 30017f4c: e1a0000a mov r0, sl 30017f50: e58d3000 str r3, [sp] 30017f54: eb001273 bl 3001c928 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
30017f58: e2507000 subs r7, r0, #0 30017f5c: e59d2004 ldr r2, [sp, #4] 30017f60: e59d3000 ldr r3, [sp]
30017f64: 0a00001d beq 30017fe0 <rtems_partition_create+0xfc>
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
30017f68: e59d1028 ldr r1, [sp, #40] ; 0x28
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
30017f6c: e5872014 str r2, [r7, #20]
the_partition->buffer_size = buffer_size;
30017f70: e5873018 str r3, [r7, #24]
the_partition->attribute_set = attribute_set;
30017f74: e587101c str r1, [r7, #28]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
30017f78: e5874010 str r4, [r7, #16]
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
_Chain_Initialize( &the_partition->Memory, starting_address,
30017f7c: e1a01003 mov r1, r3
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
30017f80: e5878020 str r8, [r7, #32]
_Chain_Initialize( &the_partition->Memory, starting_address,
30017f84: e1a00002 mov r0, r2 30017f88: e58d3000 str r3, [sp] 30017f8c: eb006063 bl 30030120 <__aeabi_uidiv> 30017f90: e2879024 add r9, r7, #36 ; 0x24 30017f94: e1a02000 mov r2, r0 30017f98: e1a01004 mov r1, r4 30017f9c: e1a00009 mov r0, r9 30017fa0: e59d3000 ldr r3, [sp] 30017fa4: eb000c78 bl 3001b18c <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30017fa8: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017fac: e59a201c ldr r2, [sl, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017fb0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017fb4: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017fb8: e587600c str r6, [r7, #12]
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
30017fbc: e5853000 str r3, [r5]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
30017fc0: eb0016e8 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017fc4: e1a00008 mov r0, r8
}
30017fc8: e28dd008 add sp, sp, #8
30017fcc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
30017fd0: e3a00008 mov r0, #8 <== NOT EXECUTED 30017fd4: eafffffb b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
if ( !_Addresses_Is_aligned( starting_address ) )
return RTEMS_INVALID_ADDRESS;
30017fd8: e3a00009 mov r0, #9 <== NOT EXECUTED 30017fdc: eafffff9 b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
30017fe0: eb0016e0 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
30017fe4: e3a00005 mov r0, #5 <== NOT EXECUTED 30017fe8: eafffff6 b 30017fc8 <rtems_partition_create+0xe4> <== NOT EXECUTED
30017ff4 <rtems_partition_delete>:
*/
rtems_status_code rtems_partition_delete(
rtems_id id
)
{
30017ff4: e92d4030 push {r4, r5, lr}
30017ff8: e24dd004 sub sp, sp, #4
30017ffc: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
30018000: e1a0200d mov r2, sp 30018004: e59f0054 ldr r0, [pc, #84] ; 30018060 <rtems_partition_delete+0x6c> 30018008: eb001387 bl 3001ce2c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
3001800c: e59d3000 ldr r3, [sp] 30018010: e1a04000 mov r4, r0 30018014: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30018018: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
3001801c: 1a000004 bne 30018034 <rtems_partition_delete+0x40>
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
30018020: e5945020 ldr r5, [r4, #32] 30018024: e3550000 cmp r5, #0
30018028: 0a000003 beq 3001803c <rtems_partition_delete+0x48>
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3001802c: eb0016cd bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30018030: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018034: e28dd004 add sp, sp, #4
30018038: e8bd8030 pop {r4, r5, pc}
the_partition = _Partition_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_partition->number_of_used_blocks == 0 ) {
_Objects_Close( &_Partition_Information, &the_partition->Object );
3001803c: e1a01004 mov r1, r4 30018040: e59f0018 ldr r0, [pc, #24] ; 30018060 <rtems_partition_delete+0x6c> 30018044: eb00125c bl 3001c9bc <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Partition_Free (
Partition_Control *the_partition
)
{
_Objects_Free( &_Partition_Information, &the_partition->Object );
30018048: e59f0010 ldr r0, [pc, #16] ; 30018060 <rtems_partition_delete+0x6c> 3001804c: e1a01004 mov r1, r4 30018050: eb00130e bl 3001cc90 <_Objects_Free>
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30018054: eb0016c3 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018058: e1a00005 mov r0, r5 3001805c: eafffff4 b 30018034 <rtems_partition_delete+0x40>
30018110 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
30018110: e92d4070 push {r4, r5, r6, lr}
30018114: e1a03000 mov r3, r0
30018118: e24dd004 sub sp, sp, #4
3001811c: e1a04001 mov r4, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
_Objects_Get( &_Partition_Information, id, location );
30018120: e59f008c ldr r0, [pc, #140] ; 300181b4 <rtems_partition_return_buffer+0xa4> 30018124: e1a01003 mov r1, r3 30018128: e1a0200d mov r2, sp 3001812c: eb00133e bl 3001ce2c <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018130: e59d3000 ldr r3, [sp] 30018134: e1a05000 mov r5, r0 30018138: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001813c: 13a00004 movne r0, #4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
30018140: 1a000016 bne 300181a0 <rtems_partition_return_buffer+0x90>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
30018144: e5950010 ldr r0, [r5, #16] 30018148: e5953014 ldr r3, [r5, #20] 3001814c: e0803003 add r3, r0, r3
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
30018150: e1540003 cmp r4, r3 30018154: 83a03000 movhi r3, #0 30018158: 93a03001 movls r3, #1 3001815c: e1540000 cmp r4, r0 30018160: 33a03000 movcc r3, #0
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30018164: e3530000 cmp r3, #0
30018168: 0a00000e beq 300181a8 <rtems_partition_return_buffer+0x98>
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
3001816c: e0600004 rsb r0, r0, r4 30018170: e5951018 ldr r1, [r5, #24] 30018174: eb00602f bl 30030238 <__umodsi3>
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
30018178: e2506000 subs r6, r0, #0
3001817c: 1a000009 bne 300181a8 <rtems_partition_return_buffer+0x98>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
30018180: e2850024 add r0, r5, #36 ; 0x24 30018184: e1a01004 mov r1, r4 30018188: eb000bdf bl 3001b10c <_Chain_Append>
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
3001818c: e5953020 ldr r3, [r5, #32] 30018190: e2433001 sub r3, r3, #1 30018194: e5853020 str r3, [r5, #32]
_Thread_Enable_dispatch();
30018198: eb001672 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001819c: e1a00006 mov r0, r6
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300181a0: e28dd004 add sp, sp, #4
300181a4: e8bd8070 pop {r4, r5, r6, pc}
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
300181a8: eb00166e bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
300181ac: e3a00009 mov r0, #9 <== NOT EXECUTED 300181b0: eafffffa b 300181a0 <rtems_partition_return_buffer+0x90> <== NOT EXECUTED
300174d4 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
300174d4: e92d40f0 push {r4, r5, r6, r7, lr}
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
300174d8: e2504000 subs r4, r0, #0
void *internal_start,
void *external_start,
uint32_t length,
rtems_id *id
)
{
300174dc: e24dd00c sub sp, sp, #12 300174e0: e59d5020 ldr r5, [sp, #32]
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300174e4: 03a00003 moveq r0, #3
rtems_id *id
)
{
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name ) )
300174e8: 0a000005 beq 30017504 <rtems_port_create+0x30>
return RTEMS_INVALID_NAME;
if ( !id )
300174ec: e3550000 cmp r5, #0
300174f0: 0a000002 beq 30017500 <rtems_port_create+0x2c>
* id - port id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_port_create(
300174f4: e1826001 orr r6, r2, r1
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
300174f8: e2166007 ands r6, r6, #7
300174fc: 0a000002 beq 3001750c <rtems_port_create+0x38>
!_Addresses_Is_aligned( external_start ) )
return RTEMS_INVALID_ADDRESS;
30017500: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
30017504: e28dd00c add sp, sp, #12
30017508: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3001750c: e59f0074 ldr r0, [pc, #116] ; 30017588 <rtems_port_create+0xb4> 30017510: e590c000 ldr ip, [r0] 30017514: e28cc001 add ip, ip, #1 30017518: e580c000 str ip, [r0]
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
_Objects_Allocate( &_Dual_ported_memory_Information );
3001751c: e59f7068 ldr r7, [pc, #104] ; 3001758c <rtems_port_create+0xb8> 30017520: e58d1008 str r1, [sp, #8] 30017524: e1a00007 mov r0, r7 30017528: e58d2004 str r2, [sp, #4] 3001752c: e58d3000 str r3, [sp] 30017530: eb0014fc bl 3001c928 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
30017534: e3500000 cmp r0, #0 30017538: e59d1008 ldr r1, [sp, #8] 3001753c: e59d2004 ldr r2, [sp, #4] 30017540: e59d3000 ldr r3, [sp]
30017544: 0a00000c beq 3001757c <rtems_port_create+0xa8>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30017548: e590c008 ldr ip, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3001754c: e597e01c ldr lr, [r7, #28]
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
30017550: e2433001 sub r3, r3, #1
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30017554: e1a0780c lsl r7, ip, #16
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
30017558: e5801010 str r1, [r0, #16]
the_port->external_base = external_start;
3001755c: e5802014 str r2, [r0, #20]
the_port->length = length - 1;
30017560: e5803018 str r3, [r0, #24]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30017564: e78e0727 str r0, [lr, r7, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30017568: e580400c str r4, [r0, #12]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
3001756c: e585c000 str ip, [r5]
_Thread_Enable_dispatch();
30017570: eb00197c bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30017574: e1a00006 mov r0, r6 30017578: eaffffe1 b 30017504 <rtems_port_create+0x30>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
3001757c: eb001979 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30017580: e3a00005 mov r0, #5 30017584: eaffffde b 30017504 <rtems_port_create+0x30>
30005b48 <rtems_print_buffer>:
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
30005b48: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int i, mod, max;
if ( !length ) return;
30005b4c: e3510000 cmp r1, #0 <== NOT EXECUTED
void rtems_print_buffer(
const unsigned char *buffer,
int length
)
{
30005b50: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 30005b54: e1a0b000 mov fp, r0 <== NOT EXECUTED
int i, mod, max;
if ( !length ) return;
30005b58: 0a000037 beq 30005c3c <rtems_print_buffer+0xf4> <== NOT EXECUTED
mod = length % 16;
30005b5c: e1a03fc1 asr r3, r1, #31 <== NOT EXECUTED 30005b60: e1a03e23 lsr r3, r3, #28 <== NOT EXECUTED 30005b64: e081a003 add sl, r1, r3 <== NOT EXECUTED 30005b68: e20aa00f and sl, sl, #15 <== NOT EXECUTED 30005b6c: e063a00a rsb sl, r3, sl <== NOT EXECUTED
max = length - mod;
30005b70: e06a9001 rsb r9, sl, r1 <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
30005b74: e3590000 cmp r9, #0 <== NOT EXECUTED 30005b78: da00002d ble 30005c34 <rtems_print_buffer+0xec> <== NOT EXECUTED 30005b7c: e59f71f4 ldr r7, [pc, #500] ; 30005d78 <rtems_print_buffer+0x230><== NOT EXECUTED 30005b80: e3a08000 mov r8, #0 <== NOT EXECUTED 30005b84: e1a0400d mov r4, sp <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005b88: e3a03000 mov r3, #0 <== NOT EXECUTED
static inline void Dump_Line(
const unsigned char *buffer,
int length
);
void rtems_print_buffer(
30005b8c: e08b6008 add r6, fp, r8 <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005b90: e5cd3000 strb r3, [sp] <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005b94: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005b98: e7d63005 ldrb r3, [r6, r5] <== NOT EXECUTED 30005b9c: e1a0000d mov r0, sp <== NOT EXECUTED 30005ba0: e59f11d4 ldr r1, [pc, #468] ; 30005d7c <rtems_print_buffer+0x234><== NOT EXECUTED 30005ba4: e1a0200d mov r2, sp <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005ba8: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005bac: eb003072 bl 30011d7c <sprintf> <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005bb0: e3550010 cmp r5, #16 <== NOT EXECUTED 30005bb4: 1afffff7 bne 30005b98 <rtems_print_buffer+0x50> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005bb8: e1a0000d mov r0, sp <== NOT EXECUTED 30005bbc: eb0031a5 bl 30012258 <strlen> <== NOT EXECUTED 30005bc0: e59f11b8 ldr r1, [pc, #440] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005bc4: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005bc8: e3a02002 mov r2, #2 <== NOT EXECUTED 30005bcc: eb002fd9 bl 30011b38 <memcpy> <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005bd0: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005bd4: e7d63005 ldrb r3, [r6, r5] <== NOT EXECUTED 30005bd8: e5972000 ldr r2, [r7] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005bdc: e1a0000d mov r0, sp <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005be0: e0822003 add r2, r2, r3 <== NOT EXECUTED 30005be4: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005be8: e59f1194 ldr r1, [pc, #404] ; 30005d84 <rtems_print_buffer+0x23c><== NOT EXECUTED 30005bec: e3120097 tst r2, #151 ; 0x97 <== NOT EXECUTED 30005bf0: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 30005bf4: e1a0200d mov r2, sp <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005bf8: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
30005bfc: eb00305e bl 30011d7c <sprintf> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005c00: e3550010 cmp r5, #16 <== NOT EXECUTED 30005c04: 1afffff2 bne 30005bd4 <rtems_print_buffer+0x8c> <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30005c08: e1a0000d mov r0, sp <== NOT EXECUTED 30005c0c: eb003191 bl 30012258 <strlen> <== NOT EXECUTED 30005c10: e59f1170 ldr r1, [pc, #368] ; 30005d88 <rtems_print_buffer+0x240><== NOT EXECUTED 30005c14: e3a02003 mov r2, #3 <== NOT EXECUTED 30005c18: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005c1c: eb002fc5 bl 30011b38 <memcpy> <== NOT EXECUTED
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30005c20: e2888010 add r8, r8, #16 <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
printk( line_buffer );
30005c24: e1a0000d mov r0, sp <== NOT EXECUTED 30005c28: eb000643 bl 3000753c <printk> <== NOT EXECUTED
mod = length % 16;
max = length - mod;
for ( i=0 ; i<max ; i+=16 )
30005c2c: e1590008 cmp r9, r8 <== NOT EXECUTED 30005c30: caffffd4 bgt 30005b88 <rtems_print_buffer+0x40> <== NOT EXECUTED
Dump_Line( &buffer[ i ], 16 );
if ( mod )
30005c34: e35a0000 cmp sl, #0 <== NOT EXECUTED 30005c38: 1a000001 bne 30005c44 <rtems_print_buffer+0xfc> <== NOT EXECUTED
Dump_Line( &buffer[ max ], mod );
}
30005c3c: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
30005c40: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005c44: e3a05000 mov r5, #0 <== NOT EXECUTED
for ( i=0 ; i<max ; i+=16 )
Dump_Line( &buffer[ i ], 16 );
if ( mod )
Dump_Line( &buffer[ max ], mod );
30005c48: e08b9009 add r9, fp, r9 <== NOT EXECUTED
{
int i;
char line_buffer[120];
line_buffer[0] = '\0';
30005c4c: e5cd5000 strb r5, [sp] <== NOT EXECUTED 30005c50: d1a0400d movle r4, sp <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005c54: da00000b ble 30005c88 <rtems_print_buffer+0x140> <== NOT EXECUTED 30005c58: e1a0400d mov r4, sp <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005c5c: e7d93005 ldrb r3, [r9, r5] <== NOT EXECUTED 30005c60: e1a0000d mov r0, sp <== NOT EXECUTED 30005c64: e59f1110 ldr r1, [pc, #272] ; 30005d7c <rtems_print_buffer+0x234><== NOT EXECUTED 30005c68: e1a0200d mov r2, sp <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005c6c: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
30005c70: eb003041 bl 30011d7c <sprintf> <== NOT EXECUTED
int i;
char line_buffer[120];
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
30005c74: e15a0005 cmp sl, r5 <== NOT EXECUTED 30005c78: cafffff7 bgt 30005c5c <rtems_print_buffer+0x114> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30005c7c: e35a000f cmp sl, #15 <== NOT EXECUTED 30005c80: d1a0500a movle r5, sl <== NOT EXECUTED 30005c84: ca000034 bgt 30005d5c <rtems_print_buffer+0x214> <== NOT EXECUTED
strcat( line_buffer, " " );
30005c88: e1a0000d mov r0, sp <== NOT EXECUTED 30005c8c: eb003171 bl 30012258 <strlen> <== NOT EXECUTED
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30005c90: e2855001 add r5, r5, #1 <== NOT EXECUTED
strcat( line_buffer, " " );
30005c94: e59f10f0 ldr r1, [pc, #240] ; 30005d8c <rtems_print_buffer+0x244><== NOT EXECUTED 30005c98: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005c9c: e3a02004 mov r2, #4 <== NOT EXECUTED 30005ca0: eb002fa4 bl 30011b38 <memcpy> <== NOT EXECUTED
line_buffer[0] = '\0';
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
30005ca4: e355000f cmp r5, #15 <== NOT EXECUTED 30005ca8: dafffff6 ble 30005c88 <rtems_print_buffer+0x140> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005cac: e1a0000d mov r0, sp <== NOT EXECUTED 30005cb0: eb003168 bl 30012258 <strlen> <== NOT EXECUTED 30005cb4: e59f10c4 ldr r1, [pc, #196] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005cb8: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005cbc: e3a02002 mov r2, #2 <== NOT EXECUTED 30005cc0: eb002f9c bl 30011b38 <memcpy> <== NOT EXECUTED
for( i=0 ; i<length ; i++ )
30005cc4: e35a0000 cmp sl, #0 <== NOT EXECUTED 30005cc8: d3a0a000 movle sl, #0 <== NOT EXECUTED 30005ccc: da000010 ble 30005d14 <rtems_print_buffer+0x1cc> <== NOT EXECUTED 30005cd0: e59f70a0 ldr r7, [pc, #160] ; 30005d78 <rtems_print_buffer+0x230><== NOT EXECUTED 30005cd4: e3a05000 mov r5, #0 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005cd8: e7d93005 ldrb r3, [r9, r5] <== NOT EXECUTED 30005cdc: e5972000 ldr r2, [r7] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005ce0: e1a0000d mov r0, sp <== NOT EXECUTED
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
30005ce4: e0822003 add r2, r2, r3 <== NOT EXECUTED 30005ce8: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
30005cec: e59f1090 ldr r1, [pc, #144] ; 30005d84 <rtems_print_buffer+0x23c><== NOT EXECUTED 30005cf0: e3120097 tst r2, #151 ; 0x97 <== NOT EXECUTED 30005cf4: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 30005cf8: e1a0200d mov r2, sp <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005cfc: e2855001 add r5, r5, #1 <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
30005d00: eb00301d bl 30011d7c <sprintf> <== NOT EXECUTED
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
30005d04: e15a0005 cmp sl, r5 <== NOT EXECUTED 30005d08: cafffff2 bgt 30005cd8 <rtems_print_buffer+0x190> <== NOT EXECUTED
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
30005d0c: e35a000f cmp sl, #15 <== NOT EXECUTED 30005d10: ca000008 bgt 30005d38 <rtems_print_buffer+0x1f0> <== NOT EXECUTED
strcat( line_buffer, " " );
30005d14: e1a0000d mov r0, sp <== NOT EXECUTED 30005d18: eb00314e bl 30012258 <strlen> <== NOT EXECUTED
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
30005d1c: e28aa001 add sl, sl, #1 <== NOT EXECUTED
strcat( line_buffer, " " );
30005d20: e59f1068 ldr r1, [pc, #104] ; 30005d90 <rtems_print_buffer+0x248><== NOT EXECUTED 30005d24: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d28: e3a02002 mov r2, #2 <== NOT EXECUTED 30005d2c: eb002f81 bl 30011b38 <memcpy> <== NOT EXECUTED
strcat( line_buffer, "|" );
for( i=0 ; i<length ; i++ )
sprintf( line_buffer, "%s%c", line_buffer,
isprint( buffer[ i ] ) ? buffer[ i ] : '.' );
for( ; i<16 ; i++ )
30005d30: e35a000f cmp sl, #15 <== NOT EXECUTED 30005d34: dafffff6 ble 30005d14 <rtems_print_buffer+0x1cc> <== NOT EXECUTED
strcat( line_buffer, " " );
strcat( line_buffer, "|\n" );
30005d38: e1a0000d mov r0, sp <== NOT EXECUTED 30005d3c: eb003145 bl 30012258 <strlen> <== NOT EXECUTED 30005d40: e59f1040 ldr r1, [pc, #64] ; 30005d88 <rtems_print_buffer+0x240><== NOT EXECUTED 30005d44: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d48: e3a02003 mov r2, #3 <== NOT EXECUTED 30005d4c: eb002f79 bl 30011b38 <memcpy> <== NOT EXECUTED
printk( line_buffer );
30005d50: e1a0000d mov r0, sp <== NOT EXECUTED 30005d54: eb0005f8 bl 3000753c <printk> <== NOT EXECUTED 30005d58: eaffffb7 b 30005c3c <rtems_print_buffer+0xf4> <== NOT EXECUTED
sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] );
for( ; i<16 ; i++ )
strcat( line_buffer, " " );
strcat( line_buffer, "|" );
30005d5c: e1a0000d mov r0, sp <== NOT EXECUTED 30005d60: eb00313c bl 30012258 <strlen> <== NOT EXECUTED 30005d64: e59f1014 ldr r1, [pc, #20] ; 30005d80 <rtems_print_buffer+0x238><== NOT EXECUTED 30005d68: e0840000 add r0, r4, r0 <== NOT EXECUTED 30005d6c: e3a02002 mov r2, #2 <== NOT EXECUTED 30005d70: eb002f70 bl 30011b38 <memcpy> <== NOT EXECUTED 30005d74: eaffffd5 b 30005cd0 <rtems_print_buffer+0x188> <== NOT EXECUTED
300181b8 <rtems_rate_monotonic_cancel>:
*/
rtems_status_code rtems_rate_monotonic_cancel(
rtems_id id
)
{
300181b8: e92d4030 push {r4, r5, lr}
300181bc: e24dd004 sub sp, sp, #4
300181c0: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
300181c4: e1a0200d mov r2, sp 300181c8: e59f0050 ldr r0, [pc, #80] ; 30018220 <rtems_rate_monotonic_cancel+0x68> 300181cc: eb001316 bl 3001ce2c <_Objects_Get>
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300181d0: e59d4000 ldr r4, [sp] 300181d4: e1a05000 mov r5, r0 300181d8: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300181dc: 13a00004 movne r0, #4
{
Rate_monotonic_Control *the_period;
Objects_Locations location;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
300181e0: 1a000006 bne 30018200 <rtems_rate_monotonic_cancel+0x48>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
300181e4: e59f3038 ldr r3, [pc, #56] ; 30018224 <rtems_rate_monotonic_cancel+0x6c> 300181e8: e5952040 ldr r2, [r5, #64] ; 0x40 300181ec: e5933004 ldr r3, [r3, #4] 300181f0: e1520003 cmp r2, r3
300181f4: 0a000003 beq 30018208 <rtems_rate_monotonic_cancel+0x50>
_Thread_Enable_dispatch();
300181f8: eb00165a bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
300181fc: e3a00017 mov r0, #23 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30018200: e28dd004 add sp, sp, #4
30018204: e8bd8030 pop {r4, r5, pc}
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
(void) _Watchdog_Remove( &the_period->Timer );
30018208: e2850010 add r0, r5, #16 3001820c: eb001b0b bl 3001ee40 <_Watchdog_Remove>
the_period->state = RATE_MONOTONIC_INACTIVE;
30018210: e5854038 str r4, [r5, #56] ; 0x38
_Thread_Enable_dispatch();
30018214: eb001653 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30018218: e1a00004 mov r0, r4 3001821c: eafffff7 b 30018200 <rtems_rate_monotonic_cancel+0x48>
3000a944 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a944: e92d4070 push {r4, r5, r6, lr}
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a948: e2504000 subs r4, r0, #0
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
rtems_id *id
)
{
3000a94c: e1a05001 mov r5, r1
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a950: 03a00003 moveq r0, #3
rtems_id *id
)
{
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
3000a954: 08bd8070 popeq {r4, r5, r6, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a958: e3510000 cmp r1, #0
3000a95c: 0a00002c beq 3000aa14 <rtems_rate_monotonic_create+0xd0>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000a960: e59f30b4 ldr r3, [pc, #180] ; 3000aa1c <rtems_rate_monotonic_create+0xd8> 3000a964: e5932000 ldr r2, [r3] 3000a968: e2822001 add r2, r2, #1 3000a96c: e5832000 str r2, [r3]
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
_Objects_Allocate( &_Rate_monotonic_Information );
3000a970: e59f60a8 ldr r6, [pc, #168] ; 3000aa20 <rtems_rate_monotonic_create+0xdc> 3000a974: e1a00006 mov r0, r6 3000a978: eb000808 bl 3000c9a0 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
3000a97c: e3500000 cmp r0, #0
3000a980: 0a000020 beq 3000aa08 <rtems_rate_monotonic_create+0xc4>
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a984: e59f3098 ldr r3, [pc, #152] ; 3000aa24 <rtems_rate_monotonic_create+0xe0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a988: e5902008 ldr r2, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a98c: e596101c ldr r1, [r6, #28] 3000a990: e593e004 ldr lr, [r3, #4]
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a994: e3a06000 mov r6, #0
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a998: e3e03102 mvn r3, #-2147483648 ; 0x80000000
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a99c: e1a0c802 lsl ip, r2, #16
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
3000a9a0: e580e040 str lr, [r0, #64] ; 0x40
the_period->state = RATE_MONOTONIC_INACTIVE;
3000a9a4: e5806038 str r6, [r0, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a9a8: e5806018 str r6, [r0, #24]
the_watchdog->routine = routine;
3000a9ac: e580602c str r6, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000a9b0: e5806030 str r6, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a9b4: e5806034 str r6, [r0, #52] ; 0x34
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
3000a9b8: e5806054 str r6, [r0, #84] ; 0x54 3000a9bc: e5806058 str r6, [r0, #88] ; 0x58 3000a9c0: e5806064 str r6, [r0, #100] ; 0x64 3000a9c4: e5806068 str r6, [r0, #104] ; 0x68 3000a9c8: e580606c str r6, [r0, #108] ; 0x6c 3000a9cc: e5806070 str r6, [r0, #112] ; 0x70 3000a9d0: e580607c str r6, [r0, #124] ; 0x7c 3000a9d4: e5806080 str r6, [r0, #128] ; 0x80 3000a9d8: e5806084 str r6, [r0, #132] ; 0x84 3000a9dc: e5806088 str r6, [r0, #136] ; 0x88 3000a9e0: e580305c str r3, [r0, #92] ; 0x5c 3000a9e4: e5803060 str r3, [r0, #96] ; 0x60 3000a9e8: e5803074 str r3, [r0, #116] ; 0x74 3000a9ec: e5803078 str r3, [r0, #120] ; 0x78
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a9f0: e781072c str r0, [r1, ip, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a9f4: e580400c str r4, [r0, #12]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
3000a9f8: e5852000 str r2, [r5]
_Thread_Enable_dispatch();
3000a9fc: eb000ca8 bl 3000dca4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000aa00: e1a00006 mov r0, r6
3000aa04: e8bd8070 pop {r4, r5, r6, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
3000aa08: eb000ca5 bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000aa0c: e3a00005 mov r0, #5 <== NOT EXECUTED
3000aa10: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000aa14: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_period->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000aa18: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30010b0c <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30010b0c: e92d4bf0 push {r4, r5, r6, r7, r8, r9, fp, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
30010b10: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_statistics(
rtems_id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
30010b14: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30010b18: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
30010b1c: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
rtems_rate_monotonic_period_statistics *dst;
Rate_monotonic_Statistics *src;
if ( !statistics )
30010b20: 0a000024 beq 30010bb8 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED 30010b24: e59f0094 ldr r0, [pc, #148] ; 30010bc0 <rtems_rate_monotonic_get_statistics+0xb4><== NOT EXECUTED 30010b28: e1a0200d mov r2, sp <== NOT EXECUTED 30010b2c: ebfff10d bl 3000cf68 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010b30: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30010b34: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30010b38: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !statistics )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010b3c: 1a00001d bne 30010bb8 <rtems_rate_monotonic_get_statistics+0xac><== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30010b40: e590e054 ldr lr, [r0, #84] ; 0x54 <== NOT EXECUTED
dst->missed_count = src->missed_count;
30010b44: e5901058 ldr r1, [r0, #88] ; 0x58 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
30010b48: e2803074 add r3, r0, #116 ; 0x74 <== NOT EXECUTED
30010b4c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
30010b50: e280905c add r9, r0, #92 ; 0x5c <== NOT EXECUTED
30010b54: e8990300 ldm r9, {r8, r9} <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
30010b58: e2807064 add r7, r0, #100 ; 0x64 <== NOT EXECUTED
30010b5c: e89700c0 ldm r7, {r6, r7} <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
30010b60: e280c06c add ip, r0, #108 ; 0x6c <== NOT EXECUTED
30010b64: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
30010b68: e5842020 str r2, [r4, #32] <== NOT EXECUTED 30010b6c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
30010b70: e280307c add r3, r0, #124 ; 0x7c <== NOT EXECUTED
30010b74: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010b78: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
30010b7c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
30010b80: e2803084 add r3, r0, #132 ; 0x84 <== NOT EXECUTED
30010b84: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
switch ( location ) {
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
30010b88: e584e000 str lr, [r4] <== NOT EXECUTED
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
_Timestamp_To_timespec( &src->min_wall_time, &dst->min_wall_time );
_Timestamp_To_timespec( &src->max_wall_time, &dst->max_wall_time );
_Timestamp_To_timespec( &src->total_wall_time, &dst->total_wall_time );
30010b8c: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED 30010b90: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED
case OBJECTS_LOCAL:
dst = statistics;
src = &the_period->Statistics;
dst->count = src->count;
dst->missed_count = src->missed_count;
30010b94: e5841004 str r1, [r4, #4] <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec( &src->min_cpu_time, &dst->min_cpu_time );
30010b98: e5848008 str r8, [r4, #8] <== NOT EXECUTED 30010b9c: e584900c str r9, [r4, #12] <== NOT EXECUTED
_Timestamp_To_timespec( &src->max_cpu_time, &dst->max_cpu_time );
30010ba0: e5846010 str r6, [r4, #16] <== NOT EXECUTED 30010ba4: e5847014 str r7, [r4, #20] <== NOT EXECUTED
_Timestamp_To_timespec( &src->total_cpu_time, &dst->total_cpu_time );
30010ba8: e584b018 str fp, [r4, #24] <== NOT EXECUTED 30010bac: e584c01c str ip, [r4, #28] <== NOT EXECUTED
dst->min_wall_time = src->min_wall_time;
dst->max_wall_time = src->max_wall_time;
dst->total_wall_time = src->total_wall_time;
#endif
_Thread_Enable_dispatch();
30010bb0: ebfff43b bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30010bb4: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30010bb8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30010bbc: e8bd8bf0 pop {r4, r5, r6, r7, r8, r9, fp, pc} <== NOT EXECUTED
30010bc4 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30010bc4: e92d4010 push {r4, lr} <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
30010bc8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_rate_monotonic_get_status(
rtems_id id,
rtems_rate_monotonic_period_status *status
)
{
30010bcc: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 30010bd0: e1a01000 mov r1, r0 <== NOT EXECUTED
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
return RTEMS_INVALID_ADDRESS;
30010bd4: 03a00009 moveq r0, #9 <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Period_time_t since_last_period;
Rate_monotonic_Control *the_period;
bool valid_status;
if ( !status )
30010bd8: 0a000013 beq 30010c2c <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED 30010bdc: e28d2010 add r2, sp, #16 <== NOT EXECUTED 30010be0: e59f008c ldr r0, [pc, #140] ; 30010c74 <rtems_rate_monotonic_get_status+0xb0><== NOT EXECUTED 30010be4: ebfff0df bl 3000cf68 <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010be8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 30010bec: e1a03000 mov r3, r0 <== NOT EXECUTED 30010bf0: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30010bf4: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !status )
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
30010bf8: 1a00000b bne 30010c2c <rtems_rate_monotonic_get_status+0x68><== NOT EXECUTED
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
30010bfc: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
status->state = the_period->state;
30010c00: e5933038 ldr r3, [r3, #56] ; 0x38 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
30010c04: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
30010c08: e3530000 cmp r3, #0 <== NOT EXECUTED
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = the_period->owner->Object.id;
30010c0c: e884000c stm r4, {r2, r3} <== NOT EXECUTED
status->state = the_period->state;
/*
* If the period is inactive, there is no information.
*/
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
30010c10: 1a000007 bne 30010c34 <rtems_rate_monotonic_get_status+0x70><== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timespec_Set_to_zero( &status->since_last_period );
30010c14: e5843008 str r3, [r4, #8] <== NOT EXECUTED 30010c18: e584300c str r3, [r4, #12] <== NOT EXECUTED
_Timespec_Set_to_zero( &status->executed_since_last_period );
30010c1c: e5843010 str r3, [r4, #16] <== NOT EXECUTED 30010c20: e5843014 str r3, [r4, #20] <== NOT EXECUTED
status->since_last_period = since_last_period;
status->executed_since_last_period = executed;
#endif
}
_Thread_Enable_dispatch();
30010c24: ebfff41e bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30010c28: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30010c2c: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30010c30: e8bd8010 pop {r4, pc} <== NOT EXECUTED
} else {
/*
* Grab the current status.
*/
valid_status =
30010c34: e1a0100d mov r1, sp <== NOT EXECUTED 30010c38: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30010c3c: ebffe785 bl 3000aa58 <_Rate_monotonic_Get_status> <== NOT EXECUTED
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
30010c40: e3500000 cmp r0, #0 <== NOT EXECUTED 30010c44: 0a000007 beq 30010c68 <rtems_rate_monotonic_get_status+0xa4><== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_To_timespec(
30010c48: e89d000c ldm sp, {r2, r3} <== NOT EXECUTED
30010c4c: e5842008 str r2, [r4, #8] <== NOT EXECUTED
30010c50: e584300c str r3, [r4, #12] <== NOT EXECUTED
&since_last_period, &status->since_last_period
);
_Timestamp_To_timespec(
30010c54: e28d3008 add r3, sp, #8 <== NOT EXECUTED
30010c58: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
30010c5c: e5842010 str r2, [r4, #16] <== NOT EXECUTED
30010c60: e5843014 str r3, [r4, #20] <== NOT EXECUTED
30010c64: eaffffee b 30010c24 <rtems_rate_monotonic_get_status+0x60> <== NOT EXECUTED
valid_status =
_Rate_monotonic_Get_status(
the_period, &since_last_period, &executed
);
if (!valid_status) {
_Thread_Enable_dispatch();
30010c68: ebfff40d bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
30010c6c: e3a0000b mov r0, #11 <== NOT EXECUTED 30010c70: eaffffed b 30010c2c <rtems_rate_monotonic_get_status+0x68> <== NOT EXECUTED
3000ac84 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
3000ac84: e92d41f0 push {r4, r5, r6, r7, r8, lr}
3000ac88: e1a04000 mov r4, r0
3000ac8c: e24dd008 sub sp, sp, #8
3000ac90: e1a05001 mov r5, r1
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
_Objects_Get( &_Rate_monotonic_Information, id, location );
3000ac94: e59f017c ldr r0, [pc, #380] ; 3000ae18 <rtems_rate_monotonic_period+0x194> 3000ac98: e1a01004 mov r1, r4 3000ac9c: e28d2004 add r2, sp, #4 3000aca0: eb0008b0 bl 3000cf68 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000aca4: e59d3004 ldr r3, [sp, #4] 3000aca8: e1a06000 mov r6, r0 3000acac: e3530000 cmp r3, #0
3000acb0: 1a000008 bne 3000acd8 <rtems_rate_monotonic_period+0x54>
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
3000acb4: e59f7160 ldr r7, [pc, #352] ; 3000ae1c <rtems_rate_monotonic_period+0x198>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
3000acb8: e5902040 ldr r2, [r0, #64] ; 0x40 3000acbc: e5973004 ldr r3, [r7, #4] 3000acc0: e1520003 cmp r2, r3
3000acc4: 0a000005 beq 3000ace0 <rtems_rate_monotonic_period+0x5c>
_Thread_Enable_dispatch();
3000acc8: eb000bf5 bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_OWNER_OF_RESOURCE;
3000accc: e3a00017 mov r0, #23 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000acd0: e28dd008 add sp, sp, #8
3000acd4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000acd8: e3a00004 mov r0, #4 <== NOT EXECUTED 3000acdc: eafffffb b 3000acd0 <rtems_rate_monotonic_period+0x4c> <== NOT EXECUTED
if ( !_Thread_Is_executing( the_period->owner ) ) {
_Thread_Enable_dispatch();
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
3000ace0: e3550000 cmp r5, #0
3000ace4: 1a000008 bne 3000ad0c <rtems_rate_monotonic_period+0x88>
switch ( the_period->state ) {
3000ace8: e5903038 ldr r3, [r0, #56] ; 0x38 3000acec: e3530004 cmp r3, #4 3000acf0: 959f2128 ldrls r2, [pc, #296] ; 3000ae20 <rtems_rate_monotonic_period+0x19c> 3000acf4: 81a00005 movhi r0, r5 3000acf8: 97920103 ldrls r0, [r2, r3, lsl #2]
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000acfc: e58d0000 str r0, [sp] 3000ad00: eb000be7 bl 3000dca4 <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
3000ad04: e59d0000 ldr r0, [sp] 3000ad08: eafffff0 b 3000acd0 <rtems_rate_monotonic_period+0x4c>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000ad0c: e10f8000 mrs r8, CPSR 3000ad10: e3883080 orr r3, r8, #128 ; 0x80 3000ad14: e129f003 msr CPSR_fc, r3
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
3000ad18: e5903038 ldr r3, [r0, #56] ; 0x38 3000ad1c: e3530000 cmp r3, #0
3000ad20: 0a00000e beq 3000ad60 <rtems_rate_monotonic_period+0xdc>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
3000ad24: e3530002 cmp r3, #2
3000ad28: 0a00001f beq 3000adac <rtems_rate_monotonic_period+0x128>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
3000ad2c: e3530004 cmp r3, #4 <== NOT EXECUTED 3000ad30: 1affffe8 bne 3000acd8 <rtems_rate_monotonic_period+0x54> <== NOT EXECUTED
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
3000ad34: ebffff97 bl 3000ab98 <_Rate_monotonic_Update_statistics> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000ad38: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
3000ad3c: e3a03002 mov r3, #2 <== NOT EXECUTED
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad40: e59f00dc ldr r0, [pc, #220] ; 3000ae24 <rtems_rate_monotonic_period+0x1a0><== NOT EXECUTED 3000ad44: e2861010 add r1, r6, #16 <== NOT EXECUTED 3000ad48: e5863038 str r3, [r6, #56] ; 0x38 <== NOT EXECUTED
the_period->next_length = length;
3000ad4c: e586503c str r5, [r6, #60] ; 0x3c <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ad50: e586501c str r5, [r6, #28] <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad54: eb000f99 bl 3000ebc0 <_Watchdog_Insert> <== NOT EXECUTED
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_TIMEOUT;
3000ad58: e3a00006 mov r0, #6 <== NOT EXECUTED 3000ad5c: eaffffe6 b 3000acfc <rtems_rate_monotonic_period+0x78> <== NOT EXECUTED
3000ad60: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
3000ad64: ebffff6b bl 3000ab18 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
3000ad68: e3a03002 mov r3, #2 3000ad6c: e5863038 str r3, [r6, #56] ; 0x38
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ad70: e59f30b0 ldr r3, [pc, #176] ; 3000ae28 <rtems_rate_monotonic_period+0x1a4>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ad74: e3a07000 mov r7, #0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad78: e59f00a4 ldr r0, [pc, #164] ; 3000ae24 <rtems_rate_monotonic_period+0x1a0> 3000ad7c: e2861010 add r1, r6, #16
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000ad80: e586302c str r3, [r6, #44] ; 0x2c
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000ad84: e5867018 str r7, [r6, #24]
the_watchdog->routine = routine; the_watchdog->id = id;
3000ad88: e5864030 str r4, [r6, #48] ; 0x30
the_watchdog->user_data = user_data;
3000ad8c: e5867034 str r7, [r6, #52] ; 0x34
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
3000ad90: e586503c str r5, [r6, #60] ; 0x3c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000ad94: e586501c str r5, [r6, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000ad98: eb000f88 bl 3000ebc0 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
3000ad9c: e58d7000 str r7, [sp] 3000ada0: eb000bbf bl 3000dca4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ada4: e59d0000 ldr r0, [sp] 3000ada8: eaffffc8 b 3000acd0 <rtems_rate_monotonic_period+0x4c>
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
3000adac: ebffff79 bl 3000ab98 <_Rate_monotonic_Update_statistics>
/*
* This tells the _Rate_monotonic_Timeout that this task is
* in the process of blocking on the period and that we
* may be changing the length of the next period.
*/
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
3000adb0: e3a03001 mov r3, #1 3000adb4: e5863038 str r3, [r6, #56] ; 0x38
the_period->next_length = length;
3000adb8: e586503c str r5, [r6, #60] ; 0x3c 3000adbc: e129f008 msr CPSR_fc, r8
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000adc0: e5973004 ldr r3, [r7, #4] 3000adc4: e5962008 ldr r2, [r6, #8]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000adc8: e1a00003 mov r0, r3
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
3000adcc: e5832020 str r2, [r3, #32]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000add0: e3a01901 mov r1, #16384 ; 0x4000 3000add4: eb000dca bl 3000e504 <_Thread_Set_state>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000add8: e10f2000 mrs r2, CPSR 3000addc: e3823080 orr r3, r2, #128 ; 0x80 3000ade0: e129f003 msr CPSR_fc, r3
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
the_period->state = RATE_MONOTONIC_ACTIVE;
3000ade4: e3a01002 mov r1, #2
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
local_state = the_period->state;
3000ade8: e5963038 ldr r3, [r6, #56] ; 0x38
the_period->state = RATE_MONOTONIC_ACTIVE;
3000adec: e5861038 str r1, [r6, #56] ; 0x38
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000adf0: e129f002 msr CPSR_fc, r2
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
3000adf4: e3530003 cmp r3, #3
3000adf8: 0a000002 beq 3000ae08 <rtems_rate_monotonic_period+0x184>
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
3000adfc: eb000ba8 bl 3000dca4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ae00: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ae04: eaffffb1 b 3000acd0 <rtems_rate_monotonic_period+0x4c> <== NOT EXECUTED
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
3000ae08: e5970004 ldr r0, [r7, #4] <== NOT EXECUTED 3000ae0c: e3a01901 mov r1, #16384 ; 0x4000 <== NOT EXECUTED 3000ae10: eb000ac6 bl 3000d930 <_Thread_Clear_state> <== NOT EXECUTED 3000ae14: eafffff8 b 3000adfc <rtems_rate_monotonic_period+0x178> <== NOT EXECUTED
3000b068 <rtems_rate_monotonic_report_statistics>:
}
}
void rtems_rate_monotonic_report_statistics( void )
{
rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
3000b068: e59f1004 ldr r1, [pc, #4] ; 3000b074 <rtems_rate_monotonic_report_statistics+0xc><== NOT EXECUTED 3000b06c: e3a00000 mov r0, #0 <== NOT EXECUTED 3000b070: eaffff6d b 3000ae2c <rtems_rate_monotonic_report_statistics_with_plugin><== NOT EXECUTED
3000ae2c <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000ae2c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
3000ae30: e2515000 subs r5, r1, #0 <== NOT EXECUTED
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
3000ae34: e24dd078 sub sp, sp, #120 ; 0x78 <== NOT EXECUTED 3000ae38: e1a08000 mov r8, r0 <== NOT EXECUTED
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
3000ae3c: 0a000047 beq 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED
return;
(*print)( context, "Period information by period\n" );
3000ae40: e59f11f4 ldr r1, [pc, #500] ; 3000b03c <rtems_rate_monotonic_report_statistics_with_plugin+0x210><== NOT EXECUTED 3000ae44: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae48: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
3000ae4c: e59f11ec ldr r1, [pc, #492] ; 3000b040 <rtems_rate_monotonic_report_statistics_with_plugin+0x214><== NOT EXECUTED 3000ae50: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae54: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae58: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context, "--- Wall times are in seconds ---\n" );
3000ae5c: e59f11e0 ldr r1, [pc, #480] ; 3000b044 <rtems_rate_monotonic_report_statistics_with_plugin+0x218><== NOT EXECUTED 3000ae60: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae64: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae68: e12fff15 bx r5 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000ae6c: e59f61d4 ldr r6, [pc, #468] ; 3000b048 <rtems_rate_monotonic_report_statistics_with_plugin+0x21c><== NOT EXECUTED
Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED "
3000ae70: e59f11d4 ldr r1, [pc, #468] ; 3000b04c <rtems_rate_monotonic_report_statistics_with_plugin+0x220><== NOT EXECUTED 3000ae74: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae78: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae7c: e12fff15 bx r5 <== NOT EXECUTED
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
3000ae80: e1a00008 mov r0, r8 <== NOT EXECUTED 3000ae84: e59f11c4 ldr r1, [pc, #452] ; 3000b050 <rtems_rate_monotonic_report_statistics_with_plugin+0x224><== NOT EXECUTED 3000ae88: e1a0e00f mov lr, pc <== NOT EXECUTED 3000ae8c: e12fff15 bx r5 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000ae90: e5964008 ldr r4, [r6, #8] <== NOT EXECUTED 3000ae94: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 3000ae98: e1540003 cmp r4, r3 <== NOT EXECUTED 3000ae9c: 8a00002f bhi 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED 3000aea0: e28d7018 add r7, sp, #24 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
3000aea4: e2870018 add r0, r7, #24 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
3000aea8: e2871030 add r1, r7, #48 ; 0x30 <== NOT EXECUTED
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
(*print)( context,
3000aeac: e59fa1a0 ldr sl, [pc, #416] ; 3000b054 <rtems_rate_monotonic_report_statistics_with_plugin+0x228><== NOT EXECUTED
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000aeb0: e28d9070 add r9, sp, #112 ; 0x70 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
3000aeb4: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000aeb8: e28db068 add fp, sp, #104 ; 0x68 <== NOT EXECUTED
{
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
3000aebc: e58d1014 str r1, [sp, #20] <== NOT EXECUTED 3000aec0: ea000003 b 3000aed4 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8><== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000aec4: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000aec8: e2844001 add r4, r4, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000aecc: e1530004 cmp r3, r4 <== NOT EXECUTED 3000aed0: 3a000022 bcc 3000af60 <rtems_rate_monotonic_report_statistics_with_plugin+0x134><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
3000aed4: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aed8: e1a01007 mov r1, r7 <== NOT EXECUTED 3000aedc: eb00170a bl 30010b0c <rtems_rate_monotonic_get_statistics> <== NOT EXECUTED
if ( status != RTEMS_SUCCESSFUL )
3000aee0: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aee4: 1afffff6 bne 3000aec4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98><== NOT EXECUTED
#if defined(RTEMS_DEBUG)
status = rtems_rate_monotonic_get_status( id, &the_status );
if ( status != RTEMS_SUCCESSFUL )
continue;
#else
(void) rtems_rate_monotonic_get_status( id, &the_status );
3000aee8: e28d1050 add r1, sp, #80 ; 0x50 <== NOT EXECUTED 3000aeec: e1a00004 mov r0, r4 <== NOT EXECUTED 3000aef0: eb001733 bl 30010bc4 <rtems_rate_monotonic_get_status> <== NOT EXECUTED
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
3000aef4: e1a02009 mov r2, r9 <== NOT EXECUTED 3000aef8: e3a01005 mov r1, #5 <== NOT EXECUTED 3000aefc: e59d0050 ldr r0, [sp, #80] ; 0x50 <== NOT EXECUTED 3000af00: eb0000bd bl 3000b1fc <rtems_object_get_name> <== NOT EXECUTED
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
3000af04: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3000af08: e59f1148 ldr r1, [pc, #328] ; 3000b058 <rtems_rate_monotonic_report_statistics_with_plugin+0x22c><== NOT EXECUTED 3000af0c: e58d3000 str r3, [sp] <== NOT EXECUTED 3000af10: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3000af14: e1a02004 mov r2, r4 <== NOT EXECUTED 3000af18: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3000af1c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000af20: e1a03009 mov r3, r9 <== NOT EXECUTED 3000af24: e1a0e00f mov lr, pc <== NOT EXECUTED 3000af28: e12fff15 bx r5 <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af2c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000af30: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af34: e3530000 cmp r3, #0 <== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000af38: e1a0200b mov r2, fp <== NOT EXECUTED
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
3000af3c: e59f1118 ldr r1, [pc, #280] ; 3000b05c <rtems_rate_monotonic_report_statistics_with_plugin+0x230><== NOT EXECUTED
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
3000af40: 1a000008 bne 3000af68 <rtems_rate_monotonic_report_statistics_with_plugin+0x13c><== NOT EXECUTED
(*print)( context, "\n" );
3000af44: e1a00008 mov r0, r8 <== NOT EXECUTED 3000af48: e1a0e00f mov lr, pc <== NOT EXECUTED 3000af4c: e12fff15 bx r5 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000af50: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000af54: e2844001 add r4, r4, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to report on each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000af58: e1530004 cmp r3, r4 <== NOT EXECUTED 3000af5c: 2affffdc bcs 3000aed4 <rtems_rate_monotonic_report_statistics_with_plugin+0xa8><== NOT EXECUTED
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
3000af60: e28dd078 add sp, sp, #120 ; 0x78 <== NOT EXECUTED
3000af64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
struct timespec cpu_average;
struct timespec *min_cpu = &the_stats.min_cpu_time;
struct timespec *max_cpu = &the_stats.max_cpu_time;
struct timespec *total_cpu = &the_stats.total_cpu_time;
_Timespec_Divide_by_integer( total_cpu, the_stats.count, &cpu_average );
3000af68: e1a01003 mov r1, r3 <== NOT EXECUTED 3000af6c: eb000e15 bl 3000e7c8 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000af70: e59d102c ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED 3000af74: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 3000af78: e0c0e19a smull lr, r0, sl, r1 <== NOT EXECUTED 3000af7c: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3000af80: e1a01fc1 asr r1, r1, #31 <== NOT EXECUTED 3000af84: e0611340 rsb r1, r1, r0, asr #6 <== NOT EXECUTED 3000af88: e58d3000 str r3, [sp] <== NOT EXECUTED 3000af8c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3000af90: e0c3c29a smull ip, r3, sl, r2 <== NOT EXECUTED 3000af94: e1a01fc2 asr r1, r2, #31 <== NOT EXECUTED 3000af98: e59d2068 ldr r2, [sp, #104] ; 0x68 <== NOT EXECUTED 3000af9c: e0613343 rsb r3, r1, r3, asr #6 <== NOT EXECUTED 3000afa0: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3000afa4: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 3000afa8: e0c1029a smull r0, r1, sl, r2 <== NOT EXECUTED 3000afac: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000afb0: e0622341 rsb r2, r2, r1, asr #6 <== NOT EXECUTED 3000afb4: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000afb8: e59f10a0 ldr r1, [pc, #160] ; 3000b060 <rtems_rate_monotonic_report_statistics_with_plugin+0x234><== NOT EXECUTED 3000afbc: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED 3000afc0: e1a00008 mov r0, r8 <== NOT EXECUTED 3000afc4: e1a0e00f mov lr, pc <== NOT EXECUTED 3000afc8: e12fff15 bx r5 <== NOT EXECUTED
struct timespec wall_average;
struct timespec *min_wall = &the_stats.min_wall_time;
struct timespec *max_wall = &the_stats.max_wall_time;
struct timespec *total_wall = &the_stats.total_wall_time;
_Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average);
3000afcc: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3000afd0: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000afd4: e1a0200b mov r2, fp <== NOT EXECUTED 3000afd8: eb000dfa bl 3000e7c8 <_Timespec_Divide_by_integer> <== NOT EXECUTED
(*print)( context,
3000afdc: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED 3000afe0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 3000afe4: e58d2000 str r2, [sp] <== NOT EXECUTED 3000afe8: e59d2044 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED 3000afec: e0c0139a smull r1, r0, sl, r3 <== NOT EXECUTED 3000aff0: e0c1c29a smull ip, r1, sl, r2 <== NOT EXECUTED 3000aff4: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000aff8: e0622341 rsb r2, r2, r1, asr #6 <== NOT EXECUTED 3000affc: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3000b000: e59d2068 ldr r2, [sp, #104] ; 0x68 <== NOT EXECUTED 3000b004: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED 3000b008: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3000b00c: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 3000b010: e0633340 rsb r3, r3, r0, asr #6 <== NOT EXECUTED 3000b014: e0cce29a smull lr, ip, sl, r2 <== NOT EXECUTED 3000b018: e1a02fc2 asr r2, r2, #31 <== NOT EXECUTED 3000b01c: e062234c rsb r2, r2, ip, asr #6 <== NOT EXECUTED 3000b020: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3000b024: e59f1038 ldr r1, [pc, #56] ; 3000b064 <rtems_rate_monotonic_report_statistics_with_plugin+0x238><== NOT EXECUTED 3000b028: e1a00008 mov r0, r8 <== NOT EXECUTED 3000b02c: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 3000b030: e1a0e00f mov lr, pc <== NOT EXECUTED 3000b034: e12fff15 bx r5 <== NOT EXECUTED 3000b038: eaffffa1 b 3000aec4 <rtems_rate_monotonic_report_statistics_with_plugin+0x98><== NOT EXECUTED
3000b078 <rtems_rate_monotonic_reset_all_statistics>:
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000b078: e59f3040 ldr r3, [pc, #64] ; 3000b0c0 <rtems_rate_monotonic_reset_all_statistics+0x48><== NOT EXECUTED
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
3000b07c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3000b080: e5932000 ldr r2, [r3] <== NOT EXECUTED
3000b084: e2822001 add r2, r2, #1 <== NOT EXECUTED
3000b088: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000b08c: e59f5030 ldr r5, [pc, #48] ; 3000b0c4 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NOT EXECUTED 3000b090: e5954008 ldr r4, [r5, #8] <== NOT EXECUTED 3000b094: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3000b098: e1540003 cmp r4, r3 <== NOT EXECUTED 3000b09c: 8a000005 bhi 3000b0b8 <rtems_rate_monotonic_reset_all_statistics+0x40><== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
(void) rtems_rate_monotonic_reset_statistics( id );
3000b0a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b0a4: eb000007 bl 3000b0c8 <rtems_rate_monotonic_reset_statistics><== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000b0a8: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
3000b0ac: e2844001 add r4, r4, #1 <== NOT EXECUTED
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
3000b0b0: e1530004 cmp r3, r4 <== NOT EXECUTED 3000b0b4: 2afffff9 bcs 3000b0a0 <rtems_rate_monotonic_reset_all_statistics+0x28><== NOT EXECUTED
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
}
3000b0b8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
3000b0bc: ea000af8 b 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
3000b0c8 <rtems_rate_monotonic_reset_statistics>:
*/
rtems_status_code rtems_rate_monotonic_reset_statistics(
rtems_id id
)
{
3000b0c8: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b0cc: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3000b0d0: e1a01000 mov r1, r0 <== NOT EXECUTED
3000b0d4: e1a0200d mov r2, sp <== NOT EXECUTED
3000b0d8: e59f005c ldr r0, [pc, #92] ; 3000b13c <rtems_rate_monotonic_reset_statistics+0x74><== NOT EXECUTED
3000b0dc: eb0007a1 bl 3000cf68 <_Objects_Get> <== NOT EXECUTED
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000b0e0: e59d4000 ldr r4, [sp] <== NOT EXECUTED 3000b0e4: e3540000 cmp r4, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000b0e8: 13a00004 movne r0, #4 <== NOT EXECUTED
{
Objects_Locations location;
Rate_monotonic_Control *the_period;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
3000b0ec: 1a000010 bne 3000b134 <rtems_rate_monotonic_reset_statistics+0x6c><== NOT EXECUTED
case OBJECTS_LOCAL:
_Rate_monotonic_Reset_statistics( the_period );
3000b0f0: e3e03102 mvn r3, #-2147483648 ; 0x80000000 <== NOT EXECUTED 3000b0f4: e5804054 str r4, [r0, #84] ; 0x54 <== NOT EXECUTED 3000b0f8: e5804058 str r4, [r0, #88] ; 0x58 <== NOT EXECUTED 3000b0fc: e5804064 str r4, [r0, #100] ; 0x64 <== NOT EXECUTED 3000b100: e5804068 str r4, [r0, #104] ; 0x68 <== NOT EXECUTED 3000b104: e580406c str r4, [r0, #108] ; 0x6c <== NOT EXECUTED 3000b108: e5804070 str r4, [r0, #112] ; 0x70 <== NOT EXECUTED 3000b10c: e580407c str r4, [r0, #124] ; 0x7c <== NOT EXECUTED 3000b110: e5804080 str r4, [r0, #128] ; 0x80 <== NOT EXECUTED 3000b114: e5804084 str r4, [r0, #132] ; 0x84 <== NOT EXECUTED 3000b118: e5804088 str r4, [r0, #136] ; 0x88 <== NOT EXECUTED 3000b11c: e580305c str r3, [r0, #92] ; 0x5c <== NOT EXECUTED 3000b120: e5803060 str r3, [r0, #96] ; 0x60 <== NOT EXECUTED 3000b124: e5803074 str r3, [r0, #116] ; 0x74 <== NOT EXECUTED 3000b128: e5803078 str r3, [r0, #120] ; 0x78 <== NOT EXECUTED
_Thread_Enable_dispatch();
3000b12c: eb000adc bl 3000dca4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000b130: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000b134: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000b138: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3001899c <rtems_region_create>:
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
3001899c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
300189a0: e2509000 subs r9, r0, #0
uintptr_t length,
uintptr_t page_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
300189a4: e24dd004 sub sp, sp, #4 300189a8: e1a05001 mov r5, r1 300189ac: e1a07002 mov r7, r2 300189b0: e1a06003 mov r6, r3 300189b4: e59db02c ldr fp, [sp, #44] ; 0x2c
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
300189b8: 03a05003 moveq r5, #3
)
{
rtems_status_code return_status;
Region_Control *the_region;
if ( !rtems_is_name_valid( name ) )
300189bc: 0a00001a beq 30018a2c <rtems_region_create+0x90>
return RTEMS_INVALID_NAME;
if ( !starting_address )
300189c0: e3550000 cmp r5, #0
300189c4: 0a000035 beq 30018aa0 <rtems_region_create+0x104>
return RTEMS_INVALID_ADDRESS;
if ( !id )
300189c8: e35b0000 cmp fp, #0
300189cc: 0a000033 beq 30018aa0 <rtems_region_create+0x104>
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
300189d0: e59f80d0 ldr r8, [pc, #208] ; 30018aa8 <rtems_region_create+0x10c>
* This function allocates a region control block from
* the inactive chain of free region control blocks.
*/
RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void )
{
return (Region_Control *) _Objects_Allocate( &_Region_Information );
300189d4: e59fa0d0 ldr sl, [pc, #208] ; 30018aac <rtems_region_create+0x110> 300189d8: e5980000 ldr r0, [r8] 300189dc: eb0009a1 bl 3001b068 <_API_Mutex_Lock> 300189e0: e1a0000a mov r0, sl 300189e4: eb000fcf bl 3001c928 <_Objects_Allocate>
the_region = _Region_Allocate();
if ( !the_region )
300189e8: e2504000 subs r4, r0, #0
return_status = RTEMS_TOO_MANY;
300189ec: 03a05005 moveq r5, #5
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Allocate();
if ( !the_region )
300189f0: 0a00000b beq 30018a24 <rtems_region_create+0x88>
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
300189f4: e2840068 add r0, r4, #104 ; 0x68 300189f8: e1a01005 mov r1, r5 300189fc: e1a02007 mov r2, r7 30018a00: e1a03006 mov r3, r6 30018a04: eb000ea5 bl 3001c4a0 <_Heap_Initialize>
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30018a08: e3500000 cmp r0, #0
if ( !the_region )
return_status = RTEMS_TOO_MANY;
else {
the_region->maximum_segment_size = _Heap_Initialize(
30018a0c: e584005c str r0, [r4, #92] ; 0x5c
&the_region->Memory, starting_address, length, page_size
);
if ( !the_region->maximum_segment_size ) {
30018a10: 1a000008 bne 30018a38 <rtems_region_create+0x9c>
*/
RTEMS_INLINE_ROUTINE void _Region_Free (
Region_Control *the_region
)
{
_Objects_Free( &_Region_Information, &the_region->Object );
30018a14: e1a0000a mov r0, sl <== NOT EXECUTED 30018a18: e1a01004 mov r1, r4 <== NOT EXECUTED 30018a1c: eb00109b bl 3001cc90 <_Objects_Free> <== NOT EXECUTED
_Region_Free( the_region );
return_status = RTEMS_INVALID_SIZE;
30018a20: e3a05008 mov r5, #8 <== NOT EXECUTED
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
}
}
_RTEMS_Unlock_allocator();
30018a24: e5980000 ldr r0, [r8] 30018a28: eb0009aa bl 3001b0d8 <_API_Mutex_Unlock>
return return_status; }
30018a2c: e1a00005 mov r0, r5
30018a30: e28dd004 add sp, sp, #4
30018a34: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
30018a38: e59d3028 ldr r3, [sp, #40] ; 0x28
the_region->starting_address = starting_address;
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
30018a3c: e3a0c000 mov ip, #0
_Thread_queue_Initialize(
30018a40: e3130004 tst r3, #4
return_status = RTEMS_INVALID_SIZE;
}
else {
the_region->starting_address = starting_address;
30018a44: e5845050 str r5, [r4, #80] ; 0x50
the_region->length = length;
the_region->page_size = page_size;
the_region->attribute_set = attribute_set;
30018a48: e5843060 str r3, [r4, #96] ; 0x60
the_region->number_of_used_blocks = 0;
30018a4c: e584c064 str ip, [r4, #100] ; 0x64
}
else {
the_region->starting_address = starting_address;
the_region->length = length;
30018a50: e5847054 str r7, [r4, #84] ; 0x54
the_region->page_size = page_size;
30018a54: e5846058 str r6, [r4, #88] ; 0x58
the_region->attribute_set = attribute_set;
the_region->number_of_used_blocks = 0;
_Thread_queue_Initialize(
30018a58: e2840010 add r0, r4, #16 30018a5c: 03a01000 moveq r1, #0 30018a60: 13a01001 movne r1, #1 30018a64: e3a02040 mov r2, #64 ; 0x40 30018a68: e3a03006 mov r3, #6 30018a6c: e58dc000 str ip, [sp] 30018a70: eb001606 bl 3001e290 <_Thread_queue_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
30018a74: e5943008 ldr r3, [r4, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30018a78: e59a201c ldr r2, [sl, #28]
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
return_status = RTEMS_SUCCESSFUL;
30018a7c: e59dc000 ldr ip, [sp]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
30018a80: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
30018a84: e7824721 str r4, [r2, r1, lsr #14]
}
}
_RTEMS_Unlock_allocator();
30018a88: e5980000 ldr r0, [r8]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
30018a8c: e584900c str r9, [r4, #12]
&_Region_Information,
&the_region->Object,
(Objects_Name) name
);
*id = the_region->Object.id;
30018a90: e58b3000 str r3, [fp]
return_status = RTEMS_SUCCESSFUL;
30018a94: e1a0500c mov r5, ip
}
}
_RTEMS_Unlock_allocator();
30018a98: eb00098e bl 3001b0d8 <_API_Mutex_Unlock> 30018a9c: eaffffe2 b 30018a2c <rtems_region_create+0x90>
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30018aa0: e3a05009 mov r5, #9 <== NOT EXECUTED 30018aa4: eaffffe0 b 30018a2c <rtems_region_create+0x90> <== NOT EXECUTED
30018b34 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30018b34: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30018b38: e2518000 subs r8, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_extend(
rtems_id id,
void *starting_address,
uintptr_t length
)
{
30018b3c: e1a05000 mov r5, r0 <== NOT EXECUTED 30018b40: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 30018b44: e1a07002 mov r7, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
return RTEMS_INVALID_ADDRESS;
30018b48: 03a05009 moveq r5, #9 <== NOT EXECUTED
bool extend_ok;
Objects_Locations location;
rtems_status_code return_status;
Region_Control *the_region;
if ( !starting_address )
30018b4c: 0a00000d beq 30018b88 <rtems_region_extend+0x54> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
30018b50: e59f407c ldr r4, [pc, #124] ; 30018bd4 <rtems_region_extend+0xa0><== NOT EXECUTED 30018b54: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018b58: eb000942 bl 3001b068 <_API_Mutex_Lock> <== NOT EXECUTED
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
_Objects_Get_no_protection( &_Region_Information, id, location );
30018b5c: e1a01005 mov r1, r5 <== NOT EXECUTED 30018b60: e59f0070 ldr r0, [pc, #112] ; 30018bd8 <rtems_region_extend+0xa4><== NOT EXECUTED 30018b64: e1a0200d mov r2, sp <== NOT EXECUTED 30018b68: eb00109f bl 3001cdec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018b6c: e59d5000 ldr r5, [sp] <== NOT EXECUTED 30018b70: e1a06000 mov r6, r0 <== NOT EXECUTED 30018b74: e3550000 cmp r5, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018b78: 13a05004 movne r5, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
30018b7c: 0a000004 beq 30018b94 <rtems_region_extend+0x60> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018b80: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018b84: eb000953 bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018b88: e1a00005 mov r0, r5 <== NOT EXECUTED
30018b8c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30018b90: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
extend_ok = _Heap_Extend(
30018b94: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018b98: e1a01008 mov r1, r8 <== NOT EXECUTED 30018b9c: e1a02007 mov r2, r7 <== NOT EXECUTED 30018ba0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30018ba4: eb000c7d bl 3001bda0 <_Heap_Extend> <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30018ba8: e3500000 cmp r0, #0 <== NOT EXECUTED
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
} else {
return_status = RTEMS_INVALID_ADDRESS;
30018bac: 03a05009 moveq r5, #9 <== NOT EXECUTED
starting_address,
length,
&amount_extended
);
if ( extend_ok ) {
30018bb0: 0afffff2 beq 30018b80 <rtems_region_extend+0x4c> <== NOT EXECUTED
the_region->length += amount_extended;
30018bb4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30018bb8: e5962054 ldr r2, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bbc: e596105c ldr r1, [r6, #92] ; 0x5c <== NOT EXECUTED
length,
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
30018bc0: e0822003 add r2, r2, r3 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bc4: e0813003 add r3, r1, r3 <== NOT EXECUTED
length,
&amount_extended
);
if ( extend_ok ) {
the_region->length += amount_extended;
30018bc8: e5862054 str r2, [r6, #84] ; 0x54 <== NOT EXECUTED
the_region->maximum_segment_size += amount_extended;
30018bcc: e586305c str r3, [r6, #92] ; 0x5c <== NOT EXECUTED 30018bd0: eaffffea b 30018b80 <rtems_region_extend+0x4c> <== NOT EXECUTED
30018bdc <rtems_region_get_free_information>:
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018bdc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018be0: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_free_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018be4: e1a06000 mov r6, r0 <== NOT EXECUTED 30018be8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30018bec: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018bf0: 0a00000c beq 30018c28 <rtems_region_get_free_information+0x4c><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018bf4: e59f4054 ldr r4, [pc, #84] ; 30018c50 <rtems_region_get_free_information+0x74><== NOT EXECUTED 30018bf8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018bfc: eb000919 bl 3001b068 <_API_Mutex_Lock> <== NOT EXECUTED 30018c00: e1a01006 mov r1, r6 <== NOT EXECUTED 30018c04: e59f0048 ldr r0, [pc, #72] ; 30018c54 <rtems_region_get_free_information+0x78><== NOT EXECUTED 30018c08: e1a0200d mov r2, sp <== NOT EXECUTED 30018c0c: eb001076 bl 3001cdec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c10: e59d6000 ldr r6, [sp] <== NOT EXECUTED 30018c14: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018c18: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c1c: 0a000004 beq 30018c34 <rtems_region_get_free_information+0x58><== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018c20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018c24: eb00092b bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018c28: e1a00006 mov r0, r6 <== NOT EXECUTED
30018c2c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018c30: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->Used.number = 0;
30018c34: e585600c str r6, [r5, #12] <== NOT EXECUTED
the_info->Used.total = 0;
30018c38: e5856014 str r6, [r5, #20] <== NOT EXECUTED
the_info->Used.largest = 0;
30018c3c: e5856010 str r6, [r5, #16] <== NOT EXECUTED
_Heap_Get_free_information( &the_region->Memory, &the_info->Free );
30018c40: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018c44: e1a01005 mov r1, r5 <== NOT EXECUTED 30018c48: eb000d73 bl 3001c21c <_Heap_Get_free_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30018c4c: eafffff3 b 30018c20 <rtems_region_get_free_information+0x44><== NOT EXECUTED
30018c58 <rtems_region_get_information>:
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018c58: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018c5c: e2515000 subs r5, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_information(
rtems_id id,
Heap_Information_block *the_info
)
{
30018c60: e1a06000 mov r6, r0 <== NOT EXECUTED 30018c64: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
30018c68: 03a06009 moveq r6, #9 <== NOT EXECUTED
{
Objects_Locations location;
rtems_status_code return_status;
register Region_Control *the_region;
if ( !the_info )
30018c6c: 0a00000c beq 30018ca4 <rtems_region_get_information+0x4c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018c70: e59f4048 ldr r4, [pc, #72] ; 30018cc0 <rtems_region_get_information+0x68><== NOT EXECUTED 30018c74: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018c78: eb0008fa bl 3001b068 <_API_Mutex_Lock> <== NOT EXECUTED 30018c7c: e1a01006 mov r1, r6 <== NOT EXECUTED 30018c80: e59f003c ldr r0, [pc, #60] ; 30018cc4 <rtems_region_get_information+0x6c><== NOT EXECUTED 30018c84: e1a0200d mov r2, sp <== NOT EXECUTED 30018c88: eb001057 bl 3001cdec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c8c: e59d6000 ldr r6, [sp] <== NOT EXECUTED 30018c90: e3560000 cmp r6, #0 <== NOT EXECUTED
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018c94: 13a06004 movne r6, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018c98: 0a000004 beq 30018cb0 <rtems_region_get_information+0x58> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018c9c: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018ca0: eb00090c bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018ca4: e1a00006 mov r0, r6 <== NOT EXECUTED
30018ca8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018cac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_Heap_Get_information( &the_region->Memory, the_info );
30018cb0: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018cb4: e1a01005 mov r1, r5 <== NOT EXECUTED 30018cb8: eb000d71 bl 3001c284 <_Heap_Get_information> <== NOT EXECUTED
return_status = RTEMS_SUCCESSFUL;
break;
30018cbc: eafffff6 b 30018c9c <rtems_region_get_information+0x44> <== NOT EXECUTED
30018e0c <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30018e0c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30018e10: e2516000 subs r6, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_region_get_segment_size(
rtems_id id,
void *segment,
uintptr_t *size
)
{
30018e14: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 30018e18: e1a07000 mov r7, r0 <== NOT EXECUTED 30018e1c: e1a05002 mov r5, r2 <== NOT EXECUTED
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
register Region_Control *the_region;
if ( !segment )
30018e20: 0a00001b beq 30018e94 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !size )
30018e24: e3520000 cmp r2, #0 <== NOT EXECUTED 30018e28: 0a000019 beq 30018e94 <rtems_region_get_segment_size+0x88> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018e2c: e59f4068 ldr r4, [pc, #104] ; 30018e9c <rtems_region_get_segment_size+0x90><== NOT EXECUTED 30018e30: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018e34: eb00088b bl 3001b068 <_API_Mutex_Lock> <== NOT EXECUTED 30018e38: e59f0060 ldr r0, [pc, #96] ; 30018ea0 <rtems_region_get_segment_size+0x94><== NOT EXECUTED 30018e3c: e1a01007 mov r1, r7 <== NOT EXECUTED 30018e40: e1a0200d mov r2, sp <== NOT EXECUTED 30018e44: eb000fe8 bl 3001cdec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018e48: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30018e4c: e3530000 cmp r3, #0 <== NOT EXECUTED 30018e50: 0a000007 beq 30018e74 <rtems_region_get_segment_size+0x68> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30018e54: e3530001 cmp r3, #1 <== NOT EXECUTED 30018e58: 03a05004 moveq r5, #4 <== NOT EXECUTED 30018e5c: 13a05000 movne r5, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018e60: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018e64: eb00089b bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018e68: e1a00005 mov r0, r5 <== NOT EXECUTED
30018e6c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30018e70: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
30018e74: e1a02005 mov r2, r5 <== NOT EXECUTED 30018e78: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018e7c: e1a01006 mov r1, r6 <== NOT EXECUTED 30018e80: eb000e6f bl 3001c844 <_Heap_Size_of_alloc_area> <== NOT EXECUTED
void *segment,
uintptr_t *size
)
{
Objects_Locations location;
rtems_status_code return_status = RTEMS_SUCCESSFUL;
30018e84: e3500000 cmp r0, #0 <== NOT EXECUTED 30018e88: 03a05009 moveq r5, #9 <== NOT EXECUTED 30018e8c: 13a05000 movne r5, #0 <== NOT EXECUTED 30018e90: eafffff2 b 30018e60 <rtems_region_get_segment_size+0x54> <== NOT EXECUTED
if ( !segment )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
30018e94: e3a05009 mov r5, #9 <== NOT EXECUTED 30018e98: eafffff2 b 30018e68 <rtems_region_get_segment_size+0x5c> <== NOT EXECUTED
30018ed4 <rtems_region_resize_segment>:
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30018ed4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
30018ed8: e2535000 subs r5, r3, #0 <== NOT EXECUTED
rtems_id id,
void *segment,
uintptr_t size,
uintptr_t *old_size
)
{
30018edc: e1a08000 mov r8, r0 <== NOT EXECUTED 30018ee0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 30018ee4: e1a07001 mov r7, r1 <== NOT EXECUTED 30018ee8: e1a06002 mov r6, r2 <== NOT EXECUTED
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
return RTEMS_INVALID_ADDRESS;
30018eec: 03a00009 moveq r0, #9 <== NOT EXECUTED
uintptr_t osize;
rtems_status_code return_status;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
30018ef0: 0a00000d beq 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
30018ef4: e59f408c ldr r4, [pc, #140] ; 30018f88 <rtems_region_resize_segment+0xb4><== NOT EXECUTED 30018ef8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018efc: eb000859 bl 3001b068 <_API_Mutex_Lock> <== NOT EXECUTED 30018f00: e1a01008 mov r1, r8 <== NOT EXECUTED 30018f04: e59f0080 ldr r0, [pc, #128] ; 30018f8c <rtems_region_resize_segment+0xb8><== NOT EXECUTED 30018f08: e28d2008 add r2, sp, #8 <== NOT EXECUTED 30018f0c: eb000fb6 bl 3001cdec <_Objects_Get_no_protection> <== NOT EXECUTED
the_region = _Region_Get( id, &location );
switch ( location ) {
30018f10: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30018f14: e1a08000 mov r8, r0 <== NOT EXECUTED 30018f18: e3530000 cmp r3, #0 <== NOT EXECUTED 30018f1c: 0a000004 beq 30018f34 <rtems_region_resize_segment+0x60> <== NOT EXECUTED
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018f20: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018f24: eb00086b bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status;
30018f28: e3a00004 mov r0, #4 <== NOT EXECUTED
}
30018f2c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
30018f30: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
30018f34: e28d300c add r3, sp, #12 <== NOT EXECUTED 30018f38: e58d3000 str r3, [sp] <== NOT EXECUTED 30018f3c: e1a02006 mov r2, r6 <== NOT EXECUTED 30018f40: e28d3004 add r3, sp, #4 <== NOT EXECUTED 30018f44: e2800068 add r0, r0, #104 ; 0x68 <== NOT EXECUTED 30018f48: e1a01007 mov r1, r7 <== NOT EXECUTED 30018f4c: eb000dee bl 3001c70c <_Heap_Resize_block> <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30018f50: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30018f54: e2506000 subs r6, r0, #0 <== NOT EXECUTED
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
30018f58: e5853000 str r3, [r5] <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
30018f5c: 1a000003 bne 30018f70 <rtems_region_resize_segment+0x9c> <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
30018f60: e1a00008 mov r0, r8 <== NOT EXECUTED 30018f64: eb001f33 bl 30020c38 <_Region_Process_queue> <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
30018f68: e1a00006 mov r0, r6 <== NOT EXECUTED 30018f6c: eaffffee b 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
30018f70: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018f74: eb000857 bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
if (status == HEAP_RESIZE_SUCCESSFUL)
return RTEMS_SUCCESSFUL;
if (status == HEAP_RESIZE_UNSATISFIED)
return RTEMS_UNSATISFIED;
30018f78: e3560001 cmp r6, #1 <== NOT EXECUTED 30018f7c: 13a00009 movne r0, #9 <== NOT EXECUTED 30018f80: 03a0000d moveq r0, #13 <== NOT EXECUTED 30018f84: eaffffe8 b 30018f2c <rtems_region_resize_segment+0x58> <== NOT EXECUTED
30018f90 <rtems_region_return_segment>:
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018f90: e92d40f0 push {r4, r5, r6, r7, lr}
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018f94: e59f4078 ldr r4, [pc, #120] ; 30019014 <rtems_region_return_segment+0x84>
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018f98: e24dd004 sub sp, sp, #4 30018f9c: e1a06000 mov r6, r0
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018fa0: e5940000 ldr r0, [r4]
rtems_status_code rtems_region_return_segment(
rtems_id id,
void *segment
)
{
30018fa4: e1a05001 mov r5, r1
uint32_t size;
#endif
int status;
register Region_Control *the_region;
_RTEMS_Lock_allocator();
30018fa8: eb00082e bl 3001b068 <_API_Mutex_Lock> 30018fac: e1a01006 mov r1, r6 30018fb0: e59f0060 ldr r0, [pc, #96] ; 30019018 <rtems_region_return_segment+0x88> 30018fb4: e1a0200d mov r2, sp 30018fb8: eb000f8b bl 3001cdec <_Objects_Get_no_protection>
the_region = _Region_Get( id, &location );
switch ( location ) {
30018fbc: e59d6000 ldr r6, [sp] 30018fc0: e1a07000 mov r7, r0 30018fc4: e3560000 cmp r6, #0
break;
#endif
case OBJECTS_ERROR:
default:
return_status = RTEMS_INVALID_ID;
30018fc8: 13a06004 movne r6, #4
register Region_Control *the_region;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
30018fcc: 1a000005 bne 30018fe8 <rtems_region_return_segment+0x58>
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
Region_Control *the_region,
void *the_segment
)
{
return _Heap_Free( &the_region->Memory, the_segment );
30018fd0: e2800068 add r0, r0, #104 ; 0x68 30018fd4: e1a01005 mov r1, r5 30018fd8: eb000c1d bl 3001c054 <_Heap_Free>
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30018fdc: e3500000 cmp r0, #0
return_status = RTEMS_INVALID_ADDRESS;
30018fe0: 03a06009 moveq r6, #9
#endif
status = _Region_Free_segment( the_region, segment );
_Region_Debug_Walk( the_region, 4 );
if ( !status )
30018fe4: 1a000004 bne 30018ffc <rtems_region_return_segment+0x6c>
default:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
30018fe8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30018fec: eb000839 bl 3001b0d8 <_API_Mutex_Unlock> <== NOT EXECUTED
return return_status; }
30018ff0: e1a00006 mov r0, r6
30018ff4: e28dd004 add sp, sp, #4
30018ff8: e8bd80f0 pop {r4, r5, r6, r7, pc}
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30018ffc: e5973064 ldr r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
30019000: e1a00007 mov r0, r7
_Region_Debug_Walk( the_region, 4 );
if ( !status )
return_status = RTEMS_INVALID_ADDRESS;
else {
the_region->number_of_used_blocks -= 1;
30019004: e2433001 sub r3, r3, #1 30019008: e5873064 str r3, [r7, #100] ; 0x64
_Region_Process_queue(the_region); /* unlocks allocator */
3001900c: eb001f09 bl 30020c38 <_Region_Process_queue>
return RTEMS_SUCCESSFUL;
30019010: eafffff6 b 30018ff0 <rtems_region_return_segment+0x60>
300098ec <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
300098ec: e92d41f0 push {r4, r5, r6, r7, r8, lr}
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
300098f0: e2505000 subs r5, r0, #0
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
300098f4: e24dd020 sub sp, sp, #32 300098f8: e1a04001 mov r4, r1 300098fc: e59d6038 ldr r6, [sp, #56] ; 0x38
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
30009900: 03a00003 moveq r0, #3
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attr;
CORE_semaphore_Attributes the_semaphore_attr;
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
30009904: 0a000008 beq 3000992c <rtems_semaphore_create+0x40>
return RTEMS_INVALID_NAME;
if ( !id )
30009908: e3560000 cmp r6, #0
return RTEMS_INVALID_ADDRESS;
3000990c: 03a00009 moveq r0, #9
CORE_mutex_Status mutex_status;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
30009910: 0a000005 beq 3000992c <rtems_semaphore_create+0x40>
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
30009914: e21210c0 ands r1, r2, #192 ; 0xc0
30009918: 0a000037 beq 300099fc <rtems_semaphore_create+0x110>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
3000991c: e2028030 and r8, r2, #48 ; 0x30
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009920: e3580010 cmp r8, #16
30009924: 0a000002 beq 30009934 <rtems_semaphore_create+0x48>
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
30009928: e3a0000b mov r0, #11 <== NOT EXECUTED
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000992c: e28dd020 add sp, sp, #32
30009930: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) &&
30009934: e3120004 tst r2, #4
30009938: 0afffffa beq 30009928 <rtems_semaphore_create+0x3c>
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
3000993c: e35100c0 cmp r1, #192 ; 0xc0
30009940: 0afffff8 beq 30009928 <rtems_semaphore_create+0x3c>
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
30009944: e3540001 cmp r4, #1
return RTEMS_INVALID_NUMBER;
30009948: 83a0000a movhi r0, #10
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
3000994c: 8afffff6 bhi 3000992c <rtems_semaphore_create+0x40>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
30009950: e59f1150 ldr r1, [pc, #336] ; 30009aa8 <rtems_semaphore_create+0x1bc> 30009954: e5910000 ldr r0, [r1] 30009958: e2800001 add r0, r0, #1 3000995c: e5810000 str r0, [r1]
* This function allocates a semaphore control block from
* the inactive chain of free semaphore control blocks.
*/
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void )
{
return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information );
30009960: e59f0144 ldr r0, [pc, #324] ; 30009aac <rtems_semaphore_create+0x1c0> 30009964: e58d2004 str r2, [sp, #4] 30009968: e58d3000 str r3, [sp] 3000996c: eb000544 bl 3000ae84 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
30009970: e2507000 subs r7, r0, #0 30009974: e59d2004 ldr r2, [sp, #4] 30009978: e59d3000 ldr r3, [sp]
3000997c: 0a00002f beq 30009a40 <rtems_semaphore_create+0x154>
the_semaphore->attribute_set = attribute_set;
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
30009980: e3580000 cmp r8, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_semaphore->attribute_set = attribute_set;
30009984: e5872010 str r2, [r7, #16]
/*
* Initialize it as a counting semaphore.
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
30009988: 0a00001e beq 30009a08 <rtems_semaphore_create+0x11c>
} else {
/*
* It is either simple binary semaphore or a more powerful mutex
* style binary semaphore. This is the mutex style.
*/
if ( _Attributes_Is_priority( attribute_set ) )
3000998c: e2121004 ands r1, r2, #4
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
30009990: 13a01001 movne r1, #1 30009994: 158d1010 strne r1, [sp, #16]
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
30009998: 058d1010 streq r1, [sp, #16]
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
3000999c: e3580010 cmp r8, #16
300099a0: 0a000029 beq 30009a4c <rtems_semaphore_create+0x160>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
the_mutex_attr.only_owner_release = true;
}
}
} else /* must be simple binary semaphore */ {
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
300099a4: e3a03001 mov r3, #1 300099a8: e58d3008 str r3, [sp, #8]
the_mutex_attr.only_owner_release = false;
300099ac: e3a03000 mov r3, #0 300099b0: e5cd300c strb r3, [sp, #12]
}
mutex_status = _CORE_mutex_Initialize(
300099b4: e3540001 cmp r4, #1 300099b8: 13a02000 movne r2, #0 300099bc: 03a02001 moveq r2, #1 300099c0: e2870014 add r0, r7, #20 300099c4: e28d1008 add r1, sp, #8 300099c8: eb0002e2 bl 3000a558 <_CORE_mutex_Initialize>
&the_semaphore->Core_control.mutex,
&the_mutex_attr,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
300099cc: e3500005 cmp r0, #5
300099d0: 0a00002e beq 30009a90 <rtems_semaphore_create+0x1a4>
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099d4: e59f20d0 ldr r2, [pc, #208] ; 30009aac <rtems_semaphore_create+0x1c0>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
300099d8: e5973008 ldr r3, [r7, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099dc: e592201c ldr r2, [r2, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
300099e0: e1a01803 lsl r1, r3, #16
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
300099e4: e7827721 str r7, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
300099e8: e587500c str r5, [r7, #12]
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
300099ec: e5863000 str r3, [r6]
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
300099f0: eb0009a3 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300099f4: e3a00000 mov r0, #0 300099f8: eaffffcb b 3000992c <rtems_semaphore_create+0x40>
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
300099fc: e2128030 ands r8, r2, #48 ; 0x30
30009a00: 1affffcf bne 30009944 <rtems_semaphore_create+0x58>
30009a04: eaffffd1 b 30009950 <rtems_semaphore_create+0x64>
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
30009a08: e3120004 tst r2, #4
*/
if ( _Attributes_Is_counting_semaphore( attribute_set ) ) {
/*
* This effectively disables limit checking.
*/
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
30009a0c: e3e03000 mvn r3, #0 30009a10: e58d3018 str r3, [sp, #24]
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
30009a14: 13a03001 movne r3, #1 30009a18: 158d301c strne r3, [sp, #28]
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
30009a1c: e2870014 add r0, r7, #20
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a20: e3a03000 mov r3, #0
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
30009a24: e28d1018 add r1, sp, #24 30009a28: e1a02004 mov r2, r4
the_semaphore_attr.maximum_count = 0xFFFFFFFF;
if ( _Attributes_Is_priority( attribute_set ) )
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
else
the_semaphore_attr.discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
30009a2c: 058d801c streq r8, [sp, #28]
/*
* The following are just to make Purify happy.
*/
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a30: e58d3008 str r3, [sp, #8]
the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM;
30009a34: e58d3014 str r3, [sp, #20]
_CORE_semaphore_Initialize(
30009a38: eb000390 bl 3000a880 <_CORE_semaphore_Initialize> 30009a3c: eaffffe4 b 300099d4 <rtems_semaphore_create+0xe8>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
30009a40: eb00098f bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
30009a44: e3a00005 mov r0, #5 30009a48: eaffffb7 b 3000992c <rtems_semaphore_create+0x40>
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009a4c: e59d0010 ldr r0, [sp, #16]
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a50: e3a01000 mov r1, #0
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009a54: e3500001 cmp r0, #1
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attr.priority_ceiling = priority_ceiling;
30009a58: e58d3014 str r3, [sp, #20]
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
30009a5c: e58d1008 str r1, [sp, #8]
the_mutex_attr.only_owner_release = false;
30009a60: e5cd100c strb r1, [sp, #12]
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
30009a64: 1affffd2 bne 300099b4 <rtems_semaphore_create+0xc8>
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
30009a68: e3120040 tst r2, #64 ; 0x40
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
30009a6c: 13a03002 movne r3, #2 30009a70: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
30009a74: 15cd000c strbne r0, [sp, #12]
the_mutex_attr.priority_ceiling = priority_ceiling;
the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attr.only_owner_release = false;
if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) {
if ( _Attributes_Is_inherit_priority( attribute_set ) ) {
30009a78: 1affffcd bne 300099b4 <rtems_semaphore_create+0xc8>
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
the_mutex_attr.only_owner_release = true;
} else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
30009a7c: e3120080 tst r2, #128 ; 0x80
the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
30009a80: 13a03003 movne r3, #3 30009a84: 158d3010 strne r3, [sp, #16]
the_mutex_attr.only_owner_release = true;
30009a88: 15cd000c strbne r0, [sp, #12] 30009a8c: eaffffc8 b 300099b4 <rtems_semaphore_create+0xc8>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
30009a90: e59f0014 ldr r0, [pc, #20] ; 30009aac <rtems_semaphore_create+0x1c0> 30009a94: e1a01007 mov r1, r7 30009a98: eb0005d3 bl 3000b1ec <_Objects_Free>
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
30009a9c: eb000978 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_INVALID_PRIORITY;
30009aa0: e3a00013 mov r0, #19 30009aa4: eaffffa0 b 3000992c <rtems_semaphore_create+0x40>
30009ab0 <rtems_semaphore_delete>:
#endif
rtems_status_code rtems_semaphore_delete(
rtems_id id
)
{
30009ab0: e92d4010 push {r4, lr}
30009ab4: e24dd004 sub sp, sp, #4
30009ab8: e1a01000 mov r1, r0
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
_Objects_Get( &_Semaphore_Information, id, location );
30009abc: e1a0200d mov r2, sp 30009ac0: e59f0088 ldr r0, [pc, #136] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009ac4: eb00061f bl 3000b348 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009ac8: e59d3000 ldr r3, [sp] 30009acc: e1a04000 mov r4, r0 30009ad0: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009ad4: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
30009ad8: 1a000009 bne 30009b04 <rtems_semaphore_delete+0x54>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
30009adc: e5941010 ldr r1, [r4, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30009ae0: e2111030 ands r1, r1, #48 ; 0x30
30009ae4: 0a000015 beq 30009b40 <rtems_semaphore_delete+0x90>
if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
30009ae8: e5943064 ldr r3, [r4, #100] ; 0x64 30009aec: e3530000 cmp r3, #0
30009af0: 1a000005 bne 30009b0c <rtems_semaphore_delete+0x5c>
30009af4: e3510020 cmp r1, #32
30009af8: 0a000003 beq 30009b0c <rtems_semaphore_delete+0x5c>
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
30009afc: eb000960 bl 3000c084 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
30009b00: e3a0000c mov r0, #12 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30009b04: e28dd004 add sp, sp, #4
30009b08: e8bd8010 pop {r4, pc}
!_Attributes_Is_simple_binary_semaphore(
the_semaphore->attribute_set ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
_CORE_mutex_Flush(
30009b0c: e2840014 add r0, r4, #20 30009b10: e3a01000 mov r1, #0 30009b14: e3a02003 mov r2, #3 30009b18: eb00028d bl 3000a554 <_CORE_mutex_Flush>
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_WAS_DELETED
);
}
_Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
30009b1c: e1a01004 mov r1, r4 30009b20: e59f0028 ldr r0, [pc, #40] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009b24: eb0004fb bl 3000af18 <_Objects_Close>
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
30009b28: e59f0020 ldr r0, [pc, #32] ; 30009b50 <rtems_semaphore_delete+0xa0> 30009b2c: e1a01004 mov r1, r4 30009b30: eb0005ad bl 3000b1ec <_Objects_Free>
0, /* Not used */
0 /* Not used */
);
}
#endif
_Thread_Enable_dispatch();
30009b34: eb000952 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009b38: e3a00000 mov r0, #0 30009b3c: eafffff0 b 30009b04 <rtems_semaphore_delete+0x54>
&the_semaphore->Core_control.mutex,
SEMAPHORE_MP_OBJECT_WAS_DELETED,
CORE_MUTEX_WAS_DELETED
);
} else {
_CORE_semaphore_Flush(
30009b40: e2840014 add r0, r4, #20 30009b44: e3a02002 mov r2, #2 30009b48: eb00034b bl 3000a87c <_CORE_semaphore_Flush> 30009b4c: eafffff2 b 30009b1c <rtems_semaphore_delete+0x6c>
3001308c <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
3001308c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30013090: e24dd004 sub sp, sp, #4
30013094: e1a01000 mov r1, r0
30013098: e1a0200d mov r2, sp
3001309c: e59f004c ldr r0, [pc, #76] ; 300130f0 <rtems_semaphore_flush+0x64>
300130a0: ebffe650 bl 3000c9e8 <_Objects_Get>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
300130a4: e59d3000 ldr r3, [sp] 300130a8: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
300130ac: 13a00004 movne r0, #4
{
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
300130b0: 1a000007 bne 300130d4 <rtems_semaphore_flush+0x48>
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
300130b4: e5901010 ldr r1, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
300130b8: e2111030 ands r1, r1, #48 ; 0x30
300130bc: 1a000006 bne 300130dc <rtems_semaphore_flush+0x50>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
300130c0: e2800014 add r0, r0, #20 <== NOT EXECUTED 300130c4: e3a02001 mov r2, #1 <== NOT EXECUTED 300130c8: ebffe393 bl 3000bf1c <_CORE_semaphore_Flush> <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
300130cc: ebffe99a bl 3000d73c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
300130d0: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
300130d4: e28dd004 add sp, sp, #4
300130d8: e8bd8000 pop {pc}
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
300130dc: e2800014 add r0, r0, #20 300130e0: e1a01003 mov r1, r3 300130e4: e3a02001 mov r2, #1 300130e8: ebffe2c1 bl 3000bbf4 <_CORE_mutex_Flush> 300130ec: eafffff6 b 300130cc <rtems_semaphore_flush+0x40>
30009b54 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
rtems_id id,
rtems_option option_set,
rtems_interval timeout
)
{
30009b54: e92d40f0 push {r4, r5, r6, r7, lr}
30009b58: e1a04000 mov r4, r0
30009b5c: e24dd00c sub sp, sp, #12
Objects_Locations *location,
ISR_Level *level
)
{
return (Semaphore_Control *)
_Objects_Get_isr_disable( &_Semaphore_Information, id, location, level );
30009b60: e28d3004 add r3, sp, #4 30009b64: e1a05001 mov r5, r1 30009b68: e1a06002 mov r6, r2 30009b6c: e59f00f4 ldr r0, [pc, #244] ; 30009c68 <rtems_semaphore_obtain+0x114> 30009b70: e1a01004 mov r1, r4 30009b74: e28d2008 add r2, sp, #8 30009b78: eb0005d6 bl 3000b2d8 <_Objects_Get_isr_disable>
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
30009b7c: e59d3008 ldr r3, [sp, #8] 30009b80: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009b84: 13a00004 movne r0, #4
register Semaphore_Control *the_semaphore;
Objects_Locations location;
ISR_Level level;
the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level );
switch ( location ) {
30009b88: 1a00000e bne 30009bc8 <rtems_semaphore_obtain+0x74>
30009b8c: e5903010 ldr r3, [r0, #16]
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
30009b90: e2133030 ands r3, r3, #48 ; 0x30
30009b94: 0a00000d beq 30009bd0 <rtems_semaphore_obtain+0x7c>
_CORE_mutex_Seize(
30009b98: e59d3004 ldr r3, [sp, #4]
*/
RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait (
rtems_option option_set
)
{
return (option_set & RTEMS_NO_WAIT) ? true : false;
30009b9c: e2052001 and r2, r5, #1 30009ba0: e58d3000 str r3, [sp] 30009ba4: e2800014 add r0, r0, #20 30009ba8: e1a03006 mov r3, r6 30009bac: e2222001 eor r2, r2, #1 30009bb0: e1a01004 mov r1, r4 30009bb4: eb0002b0 bl 3000a67c <_CORE_mutex_Seize>
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
_Thread_Executing->Wait.return_code );
30009bb8: e59f30ac ldr r3, [pc, #172] ; 30009c6c <rtems_semaphore_obtain+0x118> 30009bbc: e5933004 ldr r3, [r3, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
level
);
return _Semaphore_Translate_core_mutex_return_code(
30009bc0: e5930034 ldr r0, [r3, #52] ; 0x34 30009bc4: eb00004c bl 30009cfc <_Semaphore_Translate_core_mutex_return_code>
break;
}
return RTEMS_INVALID_ID;
}
30009bc8: e28dd00c add sp, sp, #12
30009bcc: e8bd80f0 pop {r4, r5, r6, r7, pc}
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009bd0: e59f7094 ldr r7, [pc, #148] ; 30009c6c <rtems_semaphore_obtain+0x118>
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
30009bd4: e590105c ldr r1, [r0, #92] ; 0x5c
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
30009bd8: e5972004 ldr r2, [r7, #4]
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
30009bdc: e3510000 cmp r1, #0
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
30009be0: e5823034 str r3, [r2, #52] ; 0x34
if ( the_semaphore->count != 0 ) {
30009be4: 1a000009 bne 30009c10 <rtems_semaphore_obtain+0xbc>
the_semaphore->count -= 1;
_ISR_Enable( *level_p );
return;
}
if ( !wait ) {
30009be8: e3150001 tst r5, #1
30009bec: 0a00000c beq 30009c24 <rtems_semaphore_obtain+0xd0>
30009bf0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30009bf4: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
_ISR_Enable( *level_p );
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
30009bf8: e3a03001 mov r3, #1 <== NOT EXECUTED 30009bfc: e5823034 str r3, [r2, #52] ; 0x34 <== NOT EXECUTED
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
_Thread_Executing->Wait.return_code );
30009c00: e5973004 ldr r3, [r7, #4]
id,
((_Options_Is_no_wait( option_set )) ? false : true),
timeout,
&level
);
return _Semaphore_Translate_core_semaphore_return_code(
30009c04: e5930034 ldr r0, [r3, #52] ; 0x34 30009c08: eb00003f bl 30009d0c <_Semaphore_Translate_core_semaphore_return_code> 30009c0c: eaffffed b 30009bc8 <rtems_semaphore_obtain+0x74>
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( the_semaphore->count != 0 ) {
the_semaphore->count -= 1;
30009c10: e2411001 sub r1, r1, #1 30009c14: e580105c str r1, [r0, #92] ; 0x5c 30009c18: e59d3004 ldr r3, [sp, #4] 30009c1c: e129f003 msr CPSR_fc, r3 30009c20: eafffff6 b 30009c00 <rtems_semaphore_obtain+0xac> 30009c24: e59f3044 ldr r3, [pc, #68] ; 30009c70 <rtems_semaphore_obtain+0x11c> 30009c28: e5931000 ldr r1, [r3] 30009c2c: e2811001 add r1, r1, #1 30009c30: e5831000 str r1, [r3]
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
30009c34: e3a01001 mov r1, #1
return;
}
_Thread_Disable_dispatch();
_Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
executing->Wait.queue = &the_semaphore->Wait_queue;
30009c38: e2803014 add r3, r0, #20 30009c3c: e5801044 str r1, [r0, #68] ; 0x44 30009c40: e5823044 str r3, [r2, #68] ; 0x44
executing->Wait.id = id;
30009c44: e5824020 str r4, [r2, #32] 30009c48: e59d2004 ldr r2, [sp, #4] 30009c4c: e129f002 msr CPSR_fc, r2
_ISR_Enable( *level_p );
_Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
30009c50: e59f201c ldr r2, [pc, #28] ; 30009c74 <rtems_semaphore_obtain+0x120> 30009c54: e1a00003 mov r0, r3 30009c58: e1a01006 mov r1, r6 30009c5c: eb000a24 bl 3000c4f4 <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
30009c60: eb000907 bl 3000c084 <_Thread_Enable_dispatch> 30009c64: eaffffe5 b 30009c00 <rtems_semaphore_obtain+0xac>
300194ec <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
300194ec: e92d4010 push {r4, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
300194f0: e2514000 subs r4, r1, #0
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
300194f4: e24dd004 sub sp, sp, #4
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
300194f8: 03a0000a moveq r0, #10
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
300194fc: 1a000001 bne 30019508 <rtems_signal_send+0x1c>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
30019500: e28dd004 add sp, sp, #4
30019504: e8bd8010 pop {r4, pc}
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
30019508: e1a0100d mov r1, sp 3001950c: eb00119e bl 3001db8c <_Thread_Get>
switch ( location ) {
30019510: e59d3000 ldr r3, [sp] 30019514: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019518: 13a00004 movne r0, #4
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3001951c: 1afffff7 bne 30019500 <rtems_signal_send+0x14>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
30019520: e59030f4 ldr r3, [r0, #244] ; 0xf4
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
30019524: e593200c ldr r2, [r3, #12] 30019528: e3520000 cmp r2, #0
3001952c: 0a00001c beq 300195a4 <rtems_signal_send+0xb8>
if ( asr->is_enabled ) {
30019530: e5d32008 ldrb r2, [r3, #8] 30019534: e3520000 cmp r2, #0
30019538: 0a00000f beq 3001957c <rtems_signal_send+0x90>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001953c: e10f2000 mrs r2, CPSR 30019540: e3821080 orr r1, r2, #128 ; 0x80 30019544: e129f001 msr CPSR_fc, r1
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
30019548: e5931014 ldr r1, [r3, #20] 3001954c: e1814004 orr r4, r1, r4 30019550: e5834014 str r4, [r3, #20]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019554: e129f002 msr CPSR_fc, r2
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
30019558: e59f3050 ldr r3, [pc, #80] ; 300195b0 <rtems_signal_send+0xc4> 3001955c: e5932000 ldr r2, [r3] 30019560: e3520000 cmp r2, #0
30019564: 0a00000b beq 30019598 <rtems_signal_send+0xac>
30019568: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3001956c: e1500002 cmp r0, r2 <== NOT EXECUTED
_Thread_Dispatch_necessary = true;
30019570: 03a02001 moveq r2, #1 <== NOT EXECUTED 30019574: 05c32010 strbeq r2, [r3, #16] <== NOT EXECUTED 30019578: ea000006 b 30019598 <rtems_signal_send+0xac> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001957c: e10f2000 mrs r2, CPSR <== NOT EXECUTED 30019580: e3821080 orr r1, r2, #128 ; 0x80 <== NOT EXECUTED 30019584: e129f001 msr CPSR_fc, r1 <== NOT EXECUTED 30019588: e5931018 ldr r1, [r3, #24] <== NOT EXECUTED 3001958c: e1814004 orr r4, r1, r4 <== NOT EXECUTED 30019590: e5834018 str r4, [r3, #24] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30019594: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
30019598: eb001172 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001959c: e3a00000 mov r0, #0 300195a0: eaffffd6 b 30019500 <rtems_signal_send+0x14>
}
_Thread_Enable_dispatch();
300195a4: eb00116f bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
300195a8: e3a0000b mov r0, #11 <== NOT EXECUTED 300195ac: eaffffd3 b 30019500 <rtems_signal_send+0x14> <== NOT EXECUTED
30005e24 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30005e24: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30005e28: e59f4074 ldr r4, [pc, #116] ; 30005ea4 <rtems_stack_checker_is_blown+0x80>
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
30005e2c: e28db00c add fp, sp, #12
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
30005e30: e5943004 ldr r3, [r4, #4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005e34: e59300b8 ldr r0, [r3, #184] ; 0xb8 30005e38: e15b0000 cmp fp, r0
return false;
30005e3c: 33a05000 movcc r5, #0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005e40: 3a000004 bcc 30005e58 <rtems_stack_checker_is_blown+0x34>
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30005e44: e59350b4 ldr r5, [r3, #180] ; 0xb4 30005e48: e0805005 add r5, r0, r5
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
30005e4c: e15b0005 cmp fp, r5 30005e50: 83a05000 movhi r5, #0 30005e54: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30005e58: e59f3048 ldr r3, [pc, #72] ; 30005ea8 <rtems_stack_checker_is_blown+0x84> 30005e5c: e5933008 ldr r3, [r3, #8] 30005e60: e3530000 cmp r3, #0
*/
bool rtems_stack_checker_is_blown( void )
{
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
bool sp_ok;
bool pattern_ok = true;
30005e64: 03a01001 moveq r1, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
30005e68: 0a000005 beq 30005e84 <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
30005e6c: e59f1038 ldr r1, [pc, #56] ; 30005eac <rtems_stack_checker_is_blown+0x88> 30005e70: e2800008 add r0, r0, #8 30005e74: e3a02010 mov r2, #16 30005e78: eb002ffd bl 30011e74 <memcmp> 30005e7c: e2701001 rsbs r1, r0, #1 30005e80: 33a01000 movcc r1, #0
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
30005e84: e3550000 cmp r5, #0
30005e88: 0a000003 beq 30005e9c <rtems_stack_checker_is_blown+0x78>
30005e8c: e3510000 cmp r1, #0
30005e90: 0a000001 beq 30005e9c <rtems_stack_checker_is_blown+0x78>
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
30005e94: e3a00000 mov r0, #0
30005e98: e8bd8830 pop {r4, r5, fp, pc}
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
30005e9c: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 30005ea0: ebffff98 bl 30005d08 <Stack_check_report_blown_task> <== NOT EXECUTED
30005f10 <rtems_stack_checker_report_usage>:
}
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
30005f10: e59f1004 ldr r1, [pc, #4] ; 30005f1c <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED 30005f14: e3a00000 mov r0, #0 <== NOT EXECUTED 30005f18: eaffffe4 b 30005eb0 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
30005eb0 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30005eb0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if ( !print )
30005eb4: e2515000 subs r5, r1, #0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
30005eb8: e1a06000 mov r6, r0 <== NOT EXECUTED
if ( !print )
30005ebc: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return;
print_context = context;
30005ec0: e59f4038 ldr r4, [pc, #56] ; 30005f00 <rtems_stack_checker_report_usage_with_plugin+0x50><== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
30005ec4: e59f1038 ldr r1, [pc, #56] ; 30005f04 <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
)
{
if ( !print )
return;
print_context = context;
30005ec8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
print_handler = print;
30005ecc: e5845000 str r5, [r4] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
30005ed0: e1a0e00f mov lr, pc <== NOT EXECUTED 30005ed4: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
30005ed8: e59f1028 ldr r1, [pc, #40] ; 30005f08 <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED 30005edc: e1a00006 mov r0, r6 <== NOT EXECUTED 30005ee0: e1a0e00f mov lr, pc <== NOT EXECUTED 30005ee4: e12fff15 bx r5 <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
30005ee8: e59f001c ldr r0, [pc, #28] ; 30005f0c <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED 30005eec: eb0014cd bl 3000b228 <rtems_iterate_over_all_threads> <== NOT EXECUTED
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
#endif
print_context = NULL;
30005ef0: e3a03000 mov r3, #0 <== NOT EXECUTED 30005ef4: e5843004 str r3, [r4, #4] <== NOT EXECUTED
print_handler = NULL;
30005ef8: e5843000 str r3, [r4] <== NOT EXECUTED
30005efc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
30005dbc <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005dbc: e92d4810 push {r4, fp, lr} <== NOT EXECUTED
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
30005dc0: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005dc4: e28db008 add fp, sp, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005dc8: e15b0003 cmp fp, r3 <== NOT EXECUTED
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
30005dcc: e1a04000 mov r4, r0 <== NOT EXECUTED
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
30005dd0: e2830008 add r0, r3, #8 <== NOT EXECUTED
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
30005dd4: 3a000003 bcc 30005de8 <rtems_stack_checker_switch_extension+0x2c><== NOT EXECUTED
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
30005dd8: e59420b4 ldr r2, [r4, #180] ; 0xb4 <== NOT EXECUTED 30005ddc: e0833002 add r3, r3, r2 <== NOT EXECUTED 30005de0: e15b0003 cmp fp, r3 <== NOT EXECUTED 30005de4: 9a000006 bls 30005e04 <rtems_stack_checker_switch_extension+0x48><== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
30005de8: e59f1030 ldr r1, [pc, #48] ; 30005e20 <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED 30005dec: e3a02010 mov r2, #16 <== NOT EXECUTED 30005df0: eb00301f bl 30011e74 <memcmp> <== NOT EXECUTED 30005df4: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED 30005df8: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
30005dfc: e1a00004 mov r0, r4 <== NOT EXECUTED 30005e00: ebffffc0 bl 30005d08 <Stack_check_report_blown_task> <== NOT EXECUTED
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
30005e04: e59f1014 ldr r1, [pc, #20] ; 30005e20 <rtems_stack_checker_switch_extension+0x64><== NOT EXECUTED 30005e08: e3a02010 mov r2, #16 <== NOT EXECUTED 30005e0c: eb003018 bl 30011e74 <memcmp> <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
30005e10: e3500000 cmp r0, #0 <== NOT EXECUTED
30005e14: 08bd8810 popeq {r4, fp, pc} <== NOT EXECUTED
30005e18: e3a01000 mov r1, #0 <== NOT EXECUTED
30005e1c: eafffff6 b 30005dfc <rtems_stack_checker_switch_extension+0x40><== NOT EXECUTED
3000af34 <rtems_status_text>:
const char *rtems_status_text(
rtems_status_code status
)
{
3000af34: e1a01000 mov r1, r0 <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
3000af38: e59f0000 ldr r0, [pc, #0] ; 3000af40 <rtems_status_text+0xc><== NOT EXECUTED 3000af3c: ea0022ca b 30013a6c <rtems_assoc_name_by_local> <== NOT EXECUTED
3001053c <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
3001053c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
30010540: e2514000 subs r4, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
30010544: e1a07000 mov r7, r0 30010548: e24dd004 sub sp, sp, #4 3001054c: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
30010550: 03a00009 moveq r0, #9
)
{
double result;
char *end;
if ( !n )
30010554: 0a000017 beq 300105b8 <rtems_string_to_double+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010558: eb00090e bl 30012998 <__errno> 3001055c: e3a03000 mov r3, #0 30010560: e5803000 str r3, [r0]
*n = 0;
30010564: e3a02000 mov r2, #0
30010568: e3a03000 mov r3, #0
3001056c: e884000c stm r4, {r2, r3}
result = strtod( s, &end );
30010570: e1a00007 mov r0, r7 30010574: e1a0100d mov r1, sp 30010578: eb00147d bl 30015774 <strtod>
if ( endptr )
3001057c: e3580000 cmp r8, #0
*endptr = end;
30010580: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtod( s, &end );
if ( endptr )
30010584: 059d3000 ldreq r3, [sp]
*endptr = end;
30010588: 15883000 strne r3, [r8]
if ( end == s )
3001058c: e1570003 cmp r7, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
30010590: e1a05000 mov r5, r0 30010594: e1a06001 mov r6, r1
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010598: 03a0000b moveq r0, #11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
3001059c: 0a000005 beq 300105b8 <rtems_string_to_double+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
300105a0: eb0008fc bl 30012998 <__errno> 300105a4: e5903000 ldr r3, [r0] 300105a8: e3530022 cmp r3, #34 ; 0x22
300105ac: 0a000003 beq 300105c0 <rtems_string_to_double+0x84>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
300105b0: e8840060 stm r4, {r5, r6}
return RTEMS_SUCCESSFUL;
300105b4: e3a00000 mov r0, #0
}
300105b8: e28dd004 add sp, sp, #4
300105bc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
300105c0: e1a00005 mov r0, r5 300105c4: e1a01006 mov r1, r6 300105c8: e3a02000 mov r2, #0 300105cc: e3a03000 mov r3, #0 300105d0: ebffdc3e bl 300076d0 <__cmpdf2> 300105d4: e3500000 cmp r0, #0
300105d8: 0a00000d beq 30010614 <rtems_string_to_double+0xd8>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
300105dc: e1a00005 mov r0, r5 300105e0: e1a01006 mov r1, r6 300105e4: e3e02000 mvn r2, #0 300105e8: e59f302c ldr r3, [pc, #44] ; 3001061c <rtems_string_to_double+0xe0> 300105ec: ebffdc33 bl 300076c0 <__gedf2> 300105f0: e3500000 cmp r0, #0
300105f4: ca000006 bgt 30010614 <rtems_string_to_double+0xd8>
300105f8: e1a00005 mov r0, r5 <== NOT EXECUTED 300105fc: e1a01006 mov r1, r6 <== NOT EXECUTED 30010600: e3e02000 mvn r2, #0 <== NOT EXECUTED 30010604: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED 30010608: ebffdc2e bl 300076c8 <__ledf2> <== NOT EXECUTED 3001060c: e3500000 cmp r0, #0 <== NOT EXECUTED 30010610: aaffffe6 bge 300105b0 <rtems_string_to_double+0x74> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30010614: e3a0000a mov r0, #10 30010618: eaffffe6 b 300105b8 <rtems_string_to_double+0x7c>
30010620 <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
30010620: e92d40f0 push {r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
30010624: e2515000 subs r5, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
30010628: e1a04000 mov r4, r0 3001062c: e24dd004 sub sp, sp, #4 30010630: e1a06002 mov r6, r2
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
30010634: 03a00009 moveq r0, #9
)
{
float result;
char *end;
if ( !n )
30010638: 0a000015 beq 30010694 <rtems_string_to_float+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
3001063c: eb0008d5 bl 30012998 <__errno> 30010640: e3a03000 mov r3, #0 30010644: e5803000 str r3, [r0]
*n = 0;
30010648: e3a03000 mov r3, #0 3001064c: e5853000 str r3, [r5]
result = strtof( s, &end );
30010650: e1a00004 mov r0, r4 30010654: e1a0100d mov r1, sp 30010658: eb00144c bl 30015790 <strtof>
if ( endptr )
3001065c: e3560000 cmp r6, #0
*endptr = end;
30010660: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtof( s, &end );
if ( endptr )
30010664: 059d3000 ldreq r3, [sp]
*endptr = end;
30010668: 15863000 strne r3, [r6]
if ( end == s )
3001066c: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
30010670: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
30010674: 03a0000b moveq r0, #11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
30010678: 0a000005 beq 30010694 <rtems_string_to_float+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3001067c: eb0008c5 bl 30012998 <__errno> 30010680: e5903000 ldr r3, [r0] 30010684: e3530022 cmp r3, #34 ; 0x22
30010688: 0a000003 beq 3001069c <rtems_string_to_float+0x7c>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
3001068c: e5857000 str r7, [r5]
return RTEMS_SUCCESSFUL;
30010690: e3a00000 mov r0, #0
}
30010694: e28dd004 add sp, sp, #4
30010698: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
3001069c: e1a00007 mov r0, r7 300106a0: e3a01000 mov r1, #0 300106a4: ebffdc54 bl 300077fc <__cmpsf2> 300106a8: e3500000 cmp r0, #0
300106ac: 0a000009 beq 300106d8 <rtems_string_to_float+0xb8>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
300106b0: e1a00007 mov r0, r7 300106b4: e59f1024 ldr r1, [pc, #36] ; 300106e0 <rtems_string_to_float+0xc0> 300106b8: ebffdc4b bl 300077ec <__gesf2> 300106bc: e3500000 cmp r0, #0
300106c0: ca000004 bgt 300106d8 <rtems_string_to_float+0xb8>
300106c4: e1a00007 mov r0, r7 <== NOT EXECUTED 300106c8: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED 300106cc: ebffdc48 bl 300077f4 <__lesf2> <== NOT EXECUTED 300106d0: e3500000 cmp r0, #0 <== NOT EXECUTED 300106d4: aaffffec bge 3001068c <rtems_string_to_float+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
300106d8: e3a0000a mov r0, #10 300106dc: eaffffec b 30010694 <rtems_string_to_float+0x74>
300106e4 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
300106e4: e92d40f0 push {r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
300106e8: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
300106ec: e1a04000 mov r4, r0 300106f0: e24dd004 sub sp, sp, #4 300106f4: e1a05002 mov r5, r2 300106f8: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
300106fc: 03a00009 moveq r0, #9
)
{
long result;
char *end;
if ( !n )
30010700: 0a000015 beq 3001075c <rtems_string_to_int+0x78>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010704: eb0008a3 bl 30012998 <__errno> 30010708: e3a03000 mov r3, #0 3001070c: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
30010710: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
30010714: e5863000 str r3, [r6]
result = strtol( s, &end, base );
30010718: e1a00004 mov r0, r4 3001071c: e1a0100d mov r1, sp 30010720: eb00149c bl 30015998 <strtol>
if ( endptr )
30010724: e3550000 cmp r5, #0
*endptr = end;
30010728: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtol( s, &end, base );
if ( endptr )
3001072c: 059d3000 ldreq r3, [sp]
*endptr = end;
30010730: 15853000 strne r3, [r5]
if ( end == s )
30010734: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
30010738: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
3001073c: 03a0000b moveq r0, #11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
30010740: 0a000005 beq 3001075c <rtems_string_to_int+0x78>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010744: eb000893 bl 30012998 <__errno> 30010748: e5903000 ldr r3, [r0] 3001074c: e3530022 cmp r3, #34 ; 0x22
30010750: 0a000003 beq 30010764 <rtems_string_to_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010754: e5867000 str r7, [r6]
return RTEMS_SUCCESSFUL;
30010758: e3a00000 mov r0, #0
}
3001075c: e28dd004 add sp, sp, #4
30010760: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010764: e3770106 cmn r7, #-2147483647 ; 0x80000001 30010768: 13570000 cmpne r7, #0
3001076c: 0a000001 beq 30010778 <rtems_string_to_int+0x94>
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
30010770: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED 30010774: 1afffff6 bne 30010754 <rtems_string_to_int+0x70> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
30010778: e3a0000a mov r0, #10 3001077c: eafffff6 b 3001075c <rtems_string_to_int+0x78>
300108f4 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
300108f4: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
300108f8: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
300108fc: e1a04000 mov r4, r0 30010900: e24dd004 sub sp, sp, #4 30010904: e1a05002 mov r5, r2 30010908: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
3001090c: 03a00009 moveq r0, #9
)
{
unsigned long result;
char *end;
if ( !n )
30010910: 0a000017 beq 30010974 <rtems_string_to_unsigned_char+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
30010914: eb00081f bl 30012998 <__errno> 30010918: e3a03000 mov r3, #0 3001091c: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
30010920: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
30010924: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
30010928: e1a00004 mov r0, r4 3001092c: e1a0100d mov r1, sp 30010930: eb001547 bl 30015e54 <strtoul>
if ( endptr )
30010934: e3550000 cmp r5, #0
*endptr = end;
30010938: 159d3000 ldrne r3, [sp]
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
if ( endptr )
3001093c: 059d3000 ldreq r3, [sp]
*endptr = end;
30010940: 15853000 strne r3, [r5]
if ( end == s )
30010944: e1540003 cmp r4, r3
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
30010948: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
3001094c: 03a0000b moveq r0, #11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
30010950: 0a000007 beq 30010974 <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010954: eb00080f bl 30012998 <__errno> 30010958: e5903000 ldr r3, [r0] 3001095c: e3530022 cmp r3, #34 ; 0x22
30010960: 0a000005 beq 3001097c <rtems_string_to_unsigned_char+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010964: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010968: 95c67000 strbls r7, [r6]
return RTEMS_SUCCESSFUL;
3001096c: 93a00000 movls r0, #0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010970: 8a000009 bhi 3001099c <rtems_string_to_unsigned_char+0xa8>
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
30010974: e28dd004 add sp, sp, #4
30010978: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
3001097c: e2473001 sub r3, r7, #1 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010980: e3730003 cmn r3, #3 <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
30010984: 83a0000a movhi r0, #10 <== NOT EXECUTED
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
30010988: 8afffff9 bhi 30010974 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
3001098c: e35700ff cmp r7, #255 ; 0xff <== NOT EXECUTED
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
30010990: 95c67000 strbls r7, [r6] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30010994: 93a00000 movls r0, #0 <== NOT EXECUTED
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
30010998: 9afffff5 bls 30010974 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
errno = ERANGE;
3001099c: eb0007fd bl 30012998 <__errno> <== NOT EXECUTED 300109a0: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED 300109a4: e5803000 str r3, [r0] <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
300109a8: e3a0000a mov r0, #10 <== NOT EXECUTED 300109ac: eafffff0 b 30010974 <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
30006240 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
30006240: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30006244: e24ddf6a sub sp, sp, #424 ; 0x1a8
30006248: e1a06001 mov r6, r1
3000624c: e1a07002 mov r7, r2
30006250: e58d0014 str r0, [sp, #20]
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
30006254: eb003ef4 bl 30015e2c <strlen> 30006258: e28d2e19 add r2, sp, #400 ; 0x190 3000625c: e1a01000 mov r1, r0 30006260: e58d2008 str r2, [sp, #8] 30006264: e59d0014 ldr r0, [sp, #20] 30006268: e3a02000 mov r2, #0 3000626c: e28d3e19 add r3, sp, #400 ; 0x190 30006270: e58d2000 str r2, [sp] 30006274: eb0002bd bl 30006d70 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006278: e3500000 cmp r0, #0
return -1;
3000627c: 13e02000 mvnne r2, #0
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006280: e58d0010 str r0, [sp, #16]
return -1;
30006284: 158d2010 strne r2, [sp, #16]
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
30006288: 1a000032 bne 30006358 <rtems_tarfs_load+0x118>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
3000628c: e59d319c ldr r3, [sp, #412] ; 0x19c 30006290: e59f21d0 ldr r2, [pc, #464] ; 30006468 <rtems_tarfs_load+0x228> 30006294: e1530002 cmp r3, r2 30006298: 059da010 ldreq sl, [sp, #16]
3000629c: 1a00006a bne 3000644c <rtems_tarfs_load+0x20c>
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062a0: e28a4c02 add r4, sl, #512 ; 0x200
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300062a4: e28d3f5f add r3, sp, #380 ; 0x17c
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062a8: e1540007 cmp r4, r7
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
300062ac: e28d5f46 add r5, sp, #280 ; 0x118
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
300062b0: e58d3004 str r3, [sp, #4]
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
300062b4: 8a000027 bhi 30006358 <rtems_tarfs_load+0x118>
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
300062b8: e086a00a add sl, r6, sl
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
300062bc: e28a0c01 add r0, sl, #256 ; 0x100 300062c0: e2800001 add r0, r0, #1 300062c4: e59f11a0 ldr r1, [pc, #416] ; 3000646c <rtems_tarfs_load+0x22c> 300062c8: e3a02005 mov r2, #5 300062cc: eb003eee bl 30015e8c <strncmp> 300062d0: e2508000 subs r8, r0, #0
300062d4: 1a00001f bne 30006358 <rtems_tarfs_load+0x118>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
300062d8: e3a02063 mov r2, #99 ; 0x63 300062dc: e1a0100a mov r1, sl 300062e0: e1a00005 mov r0, r5 300062e4: eb003f49 bl 30016010 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
300062e8: e5cd817b strb r8, [sp, #379] ; 0x17b
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
300062ec: e3a01008 mov r1, #8 300062f0: e28a0064 add r0, sl, #100 ; 0x64
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
300062f4: e5dab09c ldrb fp, [sl, #156] ; 0x9c
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
300062f8: eb002067 bl 3000e49c <_rtems_octal2ulong>
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
300062fc: e3a0100c mov r1, #12
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
30006300: e1a09000 mov r9, r0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30006304: e28a007c add r0, sl, #124 ; 0x7c 30006308: eb002063 bl 3000e49c <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
3000630c: e3a01008 mov r1, #8
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
30006310: e1a08000 mov r8, r0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
30006314: e28a0094 add r0, sl, #148 ; 0x94 30006318: eb00205f bl 3000e49c <_rtems_octal2ulong> 3000631c: e1a03000 mov r3, r0
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
30006320: e1a0000a mov r0, sl 30006324: e58d300c str r3, [sp, #12] 30006328: eb002168 bl 3000e8d0 <_rtems_tar_header_checksum> 3000632c: e59d300c ldr r3, [sp, #12] 30006330: e1500003 cmp r0, r3
30006334: 1a000007 bne 30006358 <rtems_tarfs_load+0x118>
* Generate an IMFS node depending on the file type.
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
30006338: e35b0035 cmp fp, #53 ; 0x35
3000633c: 0a00001a beq 300063ac <rtems_tarfs_load+0x16c>
* IMFS_create_node was ONLY passed a NULL when we created the
* root node. We added a new IMFS_create_root_node() so this
* path no longer existed. The result was simpler code which
* should not have this path.
*/
else if (linkflag == REGTYPE) {
30006340: e35b0030 cmp fp, #48 ; 0x30
30006344: 0a000006 beq 30006364 <rtems_tarfs_load+0x124>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30006348: e1a0a004 mov sl, r4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
3000634c: e28a4c02 add r4, sl, #512 ; 0x200 30006350: e1540007 cmp r4, r7
30006354: 9affffd7 bls 300062b8 <rtems_tarfs_load+0x78>
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
30006358: e59d0010 ldr r0, [sp, #16]
3000635c: e28ddf6a add sp, sp, #424 ; 0x1a8
30006360: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30006364: e59dc008 ldr ip, [sp, #8]
30006368: e59de004 ldr lr, [sp, #4]
3000636c: e8bc000f ldm ip!, {r0, r1, r2, r3}
30006370: e8ae000f stmia lr!, {r0, r1, r2, r3}
30006374: e59cc000 ldr ip, [ip]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30006378: e1a00005 mov r0, r5 3000637c: e28d1f5f add r1, sp, #380 ; 0x17c 30006380: e28d2f69 add r2, sp, #420 ; 0x1a4
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
30006384: e58ec000 str ip, [lr]
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
30006388: eb002368 bl 3000f130 <IMFS_evaluate_for_make> 3000638c: e250a000 subs sl, r0, #0
30006390: 0a00001c beq 30006408 <rtems_tarfs_load+0x1c8>
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
30006394: e2888f7f add r8, r8, #508 ; 0x1fc <== NOT EXECUTED 30006398: e2888003 add r8, r8, #3 <== NOT EXECUTED 3000639c: e1a084a8 lsr r8, r8, #9 <== NOT EXECUTED
offset += 512 * nblocks;
300063a0: e0844488 add r4, r4, r8, lsl #9 <== NOT EXECUTED
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
300063a4: e1a0a004 mov sl, r4 300063a8: eaffffe7 b 3000634c <rtems_tarfs_load+0x10c>
* - For directories, just create directories as usual. IMFS
* will take care of the rest.
* - For files, create a file node with special tarfs properties.
*/
if (linkflag == DIRTYPE) {
strcpy(full_filename, mountpoint);
300063ac: e59d1014 ldr r1, [sp, #20] 300063b0: e28d0018 add r0, sp, #24 300063b4: eb003cd8 bl 3001571c <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
300063b8: e28d0018 add r0, sp, #24 300063bc: eb003e9a bl 30015e2c <strlen> 300063c0: e28def6a add lr, sp, #424 ; 0x1a8 300063c4: e08e3000 add r3, lr, r0 300063c8: e5533191 ldrb r3, [r3, #-401] ; 0x191 300063cc: e353002f cmp r3, #47 ; 0x2f
300063d0: 0a000004 beq 300063e8 <rtems_tarfs_load+0x1a8>
strcat(full_filename, "/");
300063d4: e28d2018 add r2, sp, #24 <== NOT EXECUTED 300063d8: e0820000 add r0, r2, r0 <== NOT EXECUTED 300063dc: e59f108c ldr r1, [pc, #140] ; 30006470 <rtems_tarfs_load+0x230><== NOT EXECUTED 300063e0: e3a02002 mov r2, #2 <== NOT EXECUTED 300063e4: eb0039b5 bl 30014ac0 <memcpy> <== NOT EXECUTED
strcat(full_filename, filename);
300063e8: e1a01005 mov r1, r5 300063ec: e28d0018 add r0, sp, #24 300063f0: eb003c12 bl 30015440 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
300063f4: e28d0018 add r0, sp, #24 300063f8: e59f1074 ldr r1, [pc, #116] ; 30006474 <rtems_tarfs_load+0x234> 300063fc: eb0004be bl 300076fc <mkdir>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
30006400: e1a0a004 mov sl, r4 30006404: eaffffd0 b 3000634c <rtems_tarfs_load+0x10c>
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
30006408: e1a03b89 lsl r3, r9, #23 3000640c: e1a03ba3 lsr r3, r3, #23
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
node = IMFS_create_node(
30006410: e3833902 orr r3, r3, #32768 ; 0x8000 30006414: e3a01006 mov r1, #6 30006418: e28d0f5f add r0, sp, #380 ; 0x17c 3000641c: e59d21a4 ldr r2, [sp, #420] ; 0x1a4 30006420: e58da000 str sl, [sp] 30006424: eb00219c bl 3000ea9c <IMFS_create_node>
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
30006428: e5808050 str r8, [r0, #80] ; 0x50
node->info.linearfile.direct = &tar_image[offset];
}
nblocks = (((file_size) + 511) & ~511) / 512;
3000642c: e2888f7f add r8, r8, #508 ; 0x1fc 30006430: e2888003 add r8, r8, #3
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
30006434: e0863004 add r3, r6, r4
}
nblocks = (((file_size) + 511) & ~511) / 512;
30006438: e1a084a8 lsr r8, r8, #9
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
3000643c: e580a054 str sl, [r0, #84] ; 0x54
node->info.linearfile.direct = &tar_image[offset];
30006440: e5803058 str r3, [r0, #88] ; 0x58
}
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
30006444: e0844488 add r4, r4, r8, lsl #9 30006448: eaffffd5 b 300063a4 <rtems_tarfs_load+0x164>
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
3000644c: e59f2024 ldr r2, [pc, #36] ; 30006478 <rtems_tarfs_load+0x238><== NOT EXECUTED 30006450: e1530002 cmp r3, r2 <== NOT EXECUTED 30006454: 01a0a000 moveq sl, r0 <== NOT EXECUTED 30006458: 0affff90 beq 300062a0 <rtems_tarfs_load+0x60> <== NOT EXECUTED
return -1;
3000645c: e3e03000 mvn r3, #0 <== NOT EXECUTED 30006460: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 30006464: eaffffbb b 30006358 <rtems_tarfs_load+0x118> <== NOT EXECUTED
30009d20 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
30009d20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30009d24: e24dd01c sub sp, sp, #28
30009d28: e59d9044 ldr r9, [sp, #68] ; 0x44
30009d2c: e1a04000 mov r4, r0
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
30009d30: e3590000 cmp r9, #0
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
rtems_id *id
)
{
30009d34: e1a0a001 mov sl, r1 30009d38: e1a06002 mov r6, r2 30009d3c: e1a05003 mov r5, r3
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009d40: 03a00009 moveq r0, #9
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
30009d44: 0a000031 beq 30009e10 <rtems_task_create+0xf0>
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
30009d48: e3540000 cmp r4, #0
return RTEMS_INVALID_NAME;
30009d4c: 03a00003 moveq r0, #3
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
30009d50: 0a00002e beq 30009e10 <rtems_task_create+0xf0>
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
30009d54: e59d3040 ldr r3, [sp, #64] ; 0x40 30009d58: e3130902 tst r3, #32768 ; 0x8000
30009d5c: 1a000005 bne 30009d78 <rtems_task_create+0x58>
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
30009d60: e3510000 cmp r1, #0
30009d64: 0a00002b beq 30009e18 <rtems_task_create+0xf8>
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
30009d68: e59f30e0 ldr r3, [pc, #224] ; 30009e50 <rtems_task_create+0x130> 30009d6c: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
30009d70: e1510003 cmp r1, r3
30009d74: 8a000027 bhi 30009e18 <rtems_task_create+0xf8>
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
30009d78: e59fb0d4 ldr fp, [pc, #212] ; 30009e54 <rtems_task_create+0x134> 30009d7c: e59b0000 ldr r0, [fp] 30009d80: eb0001aa bl 3000a430 <_API_Mutex_Lock>
* This function allocates a task control block from
* the inactive chain of free task control blocks.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_RTEMS_tasks_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_RTEMS_tasks_Information );
30009d84: e59f00cc ldr r0, [pc, #204] ; 30009e58 <rtems_task_create+0x138> 30009d88: eb00043d bl 3000ae84 <_Objects_Allocate>
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
30009d8c: e2507000 subs r7, r0, #0
30009d90: 0a00002a beq 30009e40 <rtems_task_create+0x120>
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
30009d94: e3150c01 tst r5, #256 ; 0x100 30009d98: 13a01000 movne r1, #0 30009d9c: 03a01001 moveq r1, #1 30009da0: e3150c02 tst r5, #512 ; 0x200
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point(
rtems_attribute attribute_set
)
{
return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false;
30009da4: e3a08000 mov r8, #0 30009da8: 03a02000 moveq r2, #0 30009dac: 13a02001 movne r2, #1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
30009db0: e2053080 and r3, r5, #128 ; 0x80
30009db4: e58d1008 str r1, [sp, #8]
30009db8: e58d200c str r2, [sp, #12]
30009dbc: e58d3014 str r3, [sp, #20]
30009dc0: e59f0090 ldr r0, [pc, #144] ; 30009e58 <rtems_task_create+0x138>
30009dc4: e1a01007 mov r1, r7
30009dc8: e1a02008 mov r2, r8
30009dcc: e1a03006 mov r3, r6
30009dd0: e88d0500 stm sp, {r8, sl}
30009dd4: e58d8010 str r8, [sp, #16]
30009dd8: e58d4018 str r4, [sp, #24]
30009ddc: eb0008d6 bl 3000c13c <_Thread_Initialize>
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
30009de0: e1500008 cmp r0, r8
30009de4: 0a00000d beq 30009e20 <rtems_task_create+0x100>
_RTEMS_Unlock_allocator();
return RTEMS_UNSATISFIED;
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
30009de8: e59720f4 ldr r2, [r7, #244] ; 0xf4
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
30009dec: e5973008 ldr r3, [r7, #8]
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
30009df0: e3150b01 tst r5, #1024 ; 0x400 30009df4: 13a01000 movne r1, #0 30009df8: 03a01001 moveq r1, #1
);
}
#endif
_RTEMS_Unlock_allocator();
30009dfc: e59b0000 ldr r0, [fp]
* id - thread id
* RTEMS_SUCCESSFUL - if successful
* error code - if unsuccessful
*/
rtems_status_code rtems_task_create(
30009e00: e5c21008 strb r1, [r2, #8]
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
*id = the_thread->Object.id;
30009e04: e5893000 str r3, [r9]
);
}
#endif
_RTEMS_Unlock_allocator();
30009e08: eb0001a4 bl 3000a4a0 <_API_Mutex_Unlock>
return RTEMS_SUCCESSFUL;
30009e0c: e1a00008 mov r0, r8
}
30009e10: e28dd01c add sp, sp, #28
30009e14: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
return RTEMS_INVALID_PRIORITY;
30009e18: e3a00013 mov r0, #19 <== NOT EXECUTED 30009e1c: eafffffb b 30009e10 <rtems_task_create+0xf0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
30009e20: e5970008 ldr r0, [r7, #8] 30009e24: eb00050d bl 3000b260 <_Objects_Get_information_id> 30009e28: e1a01007 mov r1, r7 30009e2c: eb0004ee bl 3000b1ec <_Objects_Free>
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
30009e30: e59b0000 ldr r0, [fp] 30009e34: eb000199 bl 3000a4a0 <_API_Mutex_Unlock>
return RTEMS_UNSATISFIED;
30009e38: e3a0000d mov r0, #13 30009e3c: eafffff3 b 30009e10 <rtems_task_create+0xf0>
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
30009e40: e59b0000 ldr r0, [fp] 30009e44: eb000195 bl 3000a4a0 <_API_Mutex_Unlock>
return RTEMS_TOO_MANY;
30009e48: e3a00005 mov r0, #5 30009e4c: eaffffef b 30009e10 <rtems_task_create+0xf0>
30009e5c <rtems_task_delete>:
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
30009e5c: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
30009e60: e59f4070 ldr r4, [pc, #112] ; 30009ed8 <rtems_task_delete+0x7c>
*/
rtems_status_code rtems_task_delete(
rtems_id id
)
{
30009e64: e24dd004 sub sp, sp, #4 30009e68: e1a05000 mov r5, r0
register Thread_Control *the_thread;
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
30009e6c: e5940000 ldr r0, [r4] 30009e70: eb00016e bl 3000a430 <_API_Mutex_Lock>
the_thread = _Thread_Get( id, &location );
30009e74: e1a00005 mov r0, r5 30009e78: e1a0100d mov r1, sp 30009e7c: eb000889 bl 3000c0a8 <_Thread_Get>
switch ( location ) {
30009e80: e59d5000 ldr r5, [sp]
Objects_Locations location;
Objects_Information *the_information;
_RTEMS_Lock_allocator();
the_thread = _Thread_Get( id, &location );
30009e84: e1a06000 mov r6, r0
switch ( location ) {
30009e88: e3550000 cmp r5, #0
30009e8c: 1a00000d bne 30009ec8 <rtems_task_delete+0x6c>
case OBJECTS_LOCAL:
the_information = _Objects_Get_information_id( the_thread->Object.id );
30009e90: e5900008 ldr r0, [r0, #8] 30009e94: eb0004f1 bl 3000b260 <_Objects_Get_information_id>
0 /* Not used */
);
}
#endif
_Thread_Close( the_information, the_thread );
30009e98: e1a01006 mov r1, r6 30009e9c: eb0007ae bl 3000bd5c <_Thread_Close> 30009ea0: e5960008 ldr r0, [r6, #8] 30009ea4: eb0004ed bl 3000b260 <_Objects_Get_information_id> 30009ea8: e1a01006 mov r1, r6 30009eac: eb0004ce bl 3000b1ec <_Objects_Free>
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
30009eb0: e5940000 ldr r0, [r4] 30009eb4: eb000179 bl 3000a4a0 <_API_Mutex_Unlock>
_Thread_Enable_dispatch();
30009eb8: eb000871 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
30009ebc: e1a00005 mov r0, r5
break;
}
_RTEMS_Unlock_allocator();
return RTEMS_INVALID_ID;
}
30009ec0: e28dd004 add sp, sp, #4
30009ec4: e8bd8070 pop {r4, r5, r6, pc}
case OBJECTS_ERROR:
break;
}
_RTEMS_Unlock_allocator();
30009ec8: e5940000 ldr r0, [r4] <== NOT EXECUTED 30009ecc: eb000173 bl 3000a4a0 <_API_Mutex_Unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
30009ed0: e3a00004 mov r0, #4 <== NOT EXECUTED 30009ed4: eafffff9 b 30009ec0 <rtems_task_delete+0x64> <== NOT EXECUTED
3000c128 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c128: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c12c: e59f30a8 ldr r3, [pc, #168] ; 3000c1dc <rtems_task_get_note+0xb4>
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c130: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c134: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c138: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c13c: e3530000 cmp r3, #0
rtems_status_code rtems_task_get_note(
rtems_id id,
uint32_t notepad,
uint32_t *note
)
{
3000c140: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000c144: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c148: 0a000019 beq 3000c1b4 <rtems_task_get_note+0x8c>
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c14c: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000c150: 03a00009 moveq r0, #9
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
if ( !note )
3000c154: 0a000016 beq 3000c1b4 <rtems_task_get_note+0x8c>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c158: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c15c: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c160: 8a000013 bhi 3000c1b4 <rtems_task_get_note+0x8c>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c164: e35c0000 cmp ip, #0
3000c168: 0a000013 beq 3000c1bc <rtems_task_get_note+0x94>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c16c: e59f306c ldr r3, [pc, #108] ; 3000c1e0 <rtems_task_get_note+0xb8> 3000c170: e5933004 ldr r3, [r3, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c174: e5931008 ldr r1, [r3, #8] 3000c178: e15c0001 cmp ip, r1
3000c17c: 0a000010 beq 3000c1c4 <rtems_task_get_note+0x9c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000c180: e28d1004 add r1, sp, #4 3000c184: e58d2000 str r2, [sp] 3000c188: eb00094a bl 3000e6b8 <_Thread_Get>
switch ( location ) {
3000c18c: e89d0024 ldm sp, {r2, r5}
3000c190: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c194: 13a00004 movne r0, #4
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c198: 1a000005 bne 3000c1b4 <rtems_task_get_note+0x8c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c19c: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000c1a0: e2844008 add r4, r4, #8 3000c1a4: e7933104 ldr r3, [r3, r4, lsl #2] 3000c1a8: e5823000 str r3, [r2]
_Thread_Enable_dispatch();
3000c1ac: eb000938 bl 3000e694 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c1b0: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c1b4: e28dd008 add sp, sp, #8
3000c1b8: e8bd8030 pop {r4, r5, pc}
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c1bc: e59f301c ldr r3, [pc, #28] ; 3000c1e0 <rtems_task_get_note+0xb8><== NOT EXECUTED 3000c1c0: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c1c4: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000c1c8: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c1cc: e7933104 ldr r3, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c1d0: e3a00000 mov r0, #0 <== NOT EXECUTED
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
3000c1d4: e5823000 str r3, [r2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c1d8: eafffff5 b 3000c1b4 <rtems_task_get_note+0x8c> <== NOT EXECUTED
30009edc <rtems_task_ident>:
rtems_id *id
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009edc: e2523000 subs r3, r2, #0
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
rtems_id *id
)
{
30009ee0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
30009ee4: e1a0c000 mov ip, r0
30009ee8: e1a02001 mov r2, r1
Objects_Name_or_id_lookup_errors status;
if ( !id )
30009eec: 0a00000c beq 30009f24 <rtems_task_ident+0x48>
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
30009ef0: e3500000 cmp r0, #0
30009ef4: 1a000004 bne 30009f0c <rtems_task_ident+0x30>
*id = _Thread_Executing->Object.id;
30009ef8: e59f202c ldr r2, [pc, #44] ; 30009f2c <rtems_task_ident+0x50><== NOT EXECUTED 30009efc: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 30009f00: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 30009f04: e5832000 str r2, [r3] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30009f08: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
30009f0c: e59f001c ldr r0, [pc, #28] ; 30009f30 <rtems_task_ident+0x54> 30009f10: e1a0100c mov r1, ip 30009f14: eb00055f bl 3000b498 <_Objects_Name_to_id_u32>
return _Status_Object_name_errors_to_status[ status ];
30009f18: e59f3014 ldr r3, [pc, #20] ; 30009f34 <rtems_task_ident+0x58>
30009f1c: e7930100 ldr r0, [r3, r0, lsl #2]
30009f20: e49df004 pop {pc} ; (ldr pc, [sp], #4)
)
{
Objects_Name_or_id_lookup_errors status;
if ( !id )
return RTEMS_INVALID_ADDRESS;
30009f24: e3a00009 mov r0, #9 <== NOT EXECUTED
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
return _Status_Object_name_errors_to_status[ status ];
}
30009f28: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30019918 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
rtems_id id
)
{
30019918: e92d4010 push {r4, lr} <== NOT EXECUTED
3001991c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
30019920: e1a0100d mov r1, sp <== NOT EXECUTED 30019924: eb001098 bl 3001db8c <_Thread_Get> <== NOT EXECUTED
switch ( location ) {
30019928: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001992c: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30019930: 13a00004 movne r0, #4 <== NOT EXECUTED
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30019934: 1a000004 bne 3001994c <rtems_task_is_suspended+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
30019938: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3001993c: e2144002 ands r4, r4, #2 <== NOT EXECUTED 30019940: 0a000003 beq 30019954 <rtems_task_is_suspended+0x3c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
30019944: eb001087 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
30019948: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001994c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
30019950: e8bd8010 pop {r4, pc} <== NOT EXECUTED
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
30019954: eb001083 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
30019958: e1a00004 mov r0, r4 <== NOT EXECUTED 3001995c: eafffffa b 3001994c <rtems_task_is_suspended+0x34> <== NOT EXECUTED
30010ca8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30010ca8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30010cac: e2525000 subs r5, r2, #0
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
30010cb0: e1a04000 mov r4, r0 30010cb4: e1a06001 mov r6, r1
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
30010cb8: 03a00009 moveq r0, #9
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
30010cbc: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
30010cc0: e59f9148 ldr r9, [pc, #328] ; 30010e10 <rtems_task_mode+0x168> 30010cc4: e5997004 ldr r7, [r9, #4]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30010cc8: e5d7a074 ldrb sl, [r7, #116] ; 0x74
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
30010ccc: e59780f4 ldr r8, [r7, #244] ; 0xf4
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30010cd0: e597307c ldr r3, [r7, #124] ; 0x7c
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30010cd4: e35a0000 cmp sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30010cd8: e5d8b008 ldrb fp, [r8, #8]
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
30010cdc: 03a0ac01 moveq sl, #256 ; 0x100 30010ce0: 13a0a000 movne sl, #0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
30010ce4: e3530000 cmp r3, #0
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
30010ce8: 138aac02 orrne sl, sl, #512 ; 0x200
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30010cec: e35b0000 cmp fp, #0 30010cf0: 03a0bb01 moveq fp, #1024 ; 0x400 30010cf4: 13a0b000 movne fp, #0
old_mode |= _ISR_Get_level();
30010cf8: ebfff232 bl 3000d5c8 <_CPU_ISR_Get_level>
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
30010cfc: e18bb000 orr fp, fp, r0
old_mode |= _ISR_Get_level();
30010d00: e18ba00a orr sl, fp, sl
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30010d04: e3160c01 tst r6, #256 ; 0x100
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
30010d08: e585a000 str sl, [r5]
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
30010d0c: 0a000003 beq 30010d20 <rtems_task_mode+0x78>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
30010d10: e3140c01 tst r4, #256 ; 0x100 30010d14: 13a03000 movne r3, #0 30010d18: 03a03001 moveq r3, #1 30010d1c: e5c73074 strb r3, [r7, #116] ; 0x74
if ( mask & RTEMS_TIMESLICE_MASK ) {
30010d20: e3160c02 tst r6, #512 ; 0x200
30010d24: 1a000028 bne 30010dcc <rtems_task_mode+0x124>
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30010d28: e3160080 tst r6, #128 ; 0x80
30010d2c: 1a00002f bne 30010df0 <rtems_task_mode+0x148>
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
30010d30: e2166b01 ands r6, r6, #1024 ; 0x400
30010d34: 0a000012 beq 30010d84 <rtems_task_mode+0xdc>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
30010d38: e3140b01 tst r4, #1024 ; 0x400
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30010d3c: e5d82008 ldrb r2, [r8, #8]
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
30010d40: 13a03000 movne r3, #0 30010d44: 03a03001 moveq r3, #1
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30010d48: e1520003 cmp r2, r3
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30010d4c: 03a06000 moveq r6, #0
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
30010d50: 0a00000b beq 30010d84 <rtems_task_mode+0xdc>
asr->is_enabled = is_asr_enabled;
30010d54: e5c83008 strb r3, [r8, #8]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30010d58: e10f3000 mrs r3, CPSR 30010d5c: e3832080 orr r2, r3, #128 ; 0x80 30010d60: e129f002 msr CPSR_fc, r2
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
30010d64: e5981018 ldr r1, [r8, #24]
information->signals_pending = information->signals_posted;
30010d68: e5982014 ldr r2, [r8, #20]
information->signals_posted = _signals;
30010d6c: e5881014 str r1, [r8, #20]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
30010d70: e5882018 str r2, [r8, #24]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30010d74: e129f003 msr CPSR_fc, r3
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
30010d78: e5986014 ldr r6, [r8, #20] 30010d7c: e3560000 cmp r6, #0
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
30010d80: 13a06001 movne r6, #1
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30010d84: e59f3088 ldr r3, [pc, #136] ; 30010e14 <rtems_task_mode+0x16c> 30010d88: e5933000 ldr r3, [r3] 30010d8c: e3530003 cmp r3, #3
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30010d90: 13a00000 movne r0, #0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
30010d94: 18bd8ff0 popne {r4, r5, r6, r7, r8, r9, sl, fp, pc}
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
30010d98: e3560000 cmp r6, #0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
30010d9c: e5993004 ldr r3, [r9, #4]
if ( are_signals_pending ||
30010da0: 1a000015 bne 30010dfc <rtems_task_mode+0x154>
30010da4: e59f2064 ldr r2, [pc, #100] ; 30010e10 <rtems_task_mode+0x168> 30010da8: e5922008 ldr r2, [r2, #8] 30010dac: e1530002 cmp r3, r2
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
30010db0: 01a00006 moveq r0, r6
30010db4: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
30010db8: e5d33074 ldrb r3, [r3, #116] ; 0x74 30010dbc: e3530000 cmp r3, #0
30010dc0: 1a00000d bne 30010dfc <rtems_task_mode+0x154>
30010dc4: e1a00006 mov r0, r6 <== NOT EXECUTED
}
30010dc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
30010dcc: e2143c02 ands r3, r4, #512 ; 0x200
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30010dd0: 159f3040 ldrne r3, [pc, #64] ; 30010e18 <rtems_task_mode+0x170>
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30010dd4: 13a02001 movne r2, #1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30010dd8: 15933000 ldrne r3, [r3]
if ( mask & RTEMS_PREEMPT_MASK )
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
if ( mask & RTEMS_TIMESLICE_MASK ) {
if ( _Modes_Is_timeslice(mode_set) ) {
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
30010ddc: 1587207c strne r2, [r7, #124] ; 0x7c
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
30010de0: 15873078 strne r3, [r7, #120] ; 0x78
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
30010de4: 0587307c streq r3, [r7, #124] ; 0x7c
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
30010de8: e3160080 tst r6, #128 ; 0x80
30010dec: 0affffcf beq 30010d30 <rtems_task_mode+0x88>
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
30010df0: e2040080 and r0, r4, #128 ; 0x80 30010df4: ebfff1ee bl 3000d5b4 <_CPU_ISR_Set_level> 30010df8: eaffffcc b 30010d30 <rtems_task_mode+0x88>
_Thread_Dispatch_necessary = true;
30010dfc: e3a03001 mov r3, #1 30010e00: e5c93010 strb r3, [r9, #16]
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
30010e04: ebffec48 bl 3000bf2c <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
30010e08: e3a00000 mov r0, #0
30010e0c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
3000ac40 <rtems_task_restart>:
rtems_status_code rtems_task_restart(
rtems_id id,
uint32_t argument
)
{
3000ac40: e92d4030 push {r4, r5, lr}
3000ac44: e24dd004 sub sp, sp, #4
3000ac48: e1a05001 mov r5, r1
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000ac4c: e1a0100d mov r1, sp 3000ac50: eb000859 bl 3000cdbc <_Thread_Get>
switch ( location ) {
3000ac54: e59d4000 ldr r4, [sp] 3000ac58: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000ac5c: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000ac60: 1a000006 bne 3000ac80 <rtems_task_restart+0x40>
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
3000ac64: e1a01004 mov r1, r4 3000ac68: e1a02005 mov r2, r5 3000ac6c: eb000a5a bl 3000d5dc <_Thread_Restart> 3000ac70: e3500000 cmp r0, #0
3000ac74: 1a000003 bne 3000ac88 <rtems_task_restart+0x48>
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000ac78: eb000846 bl 3000cd98 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000ac7c: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ac80: e28dd004 add sp, sp, #4
3000ac84: e8bd8030 pop {r4, r5, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Restart( the_thread, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000ac88: eb000842 bl 3000cd98 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ac8c: e1a00004 mov r0, r4 3000ac90: eafffffa b 3000ac80 <rtems_task_restart+0x40>
3000d68c <rtems_task_resume>:
*/
rtems_status_code rtems_task_resume(
rtems_id id
)
{
3000d68c: e92d4010 push {r4, lr}
3000d690: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d694: e1a0100d mov r1, sp 3000d698: eb000871 bl 3000f864 <_Thread_Get>
switch ( location ) {
3000d69c: e59d4000 ldr r4, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d6a0: e1a03000 mov r3, r0
switch ( location ) {
3000d6a4: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000d6a8: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000d6ac: 1a000004 bne 3000d6c4 <rtems_task_resume+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000d6b0: e5933010 ldr r3, [r3, #16]
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
3000d6b4: e3130002 tst r3, #2
3000d6b8: 1a000003 bne 3000d6cc <rtems_task_resume+0x40>
_Thread_Resume( the_thread, true );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000d6bc: eb00085f bl 3000f840 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000d6c0: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000d6c4: e28dd004 add sp, sp, #4
3000d6c8: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _States_Is_suspended( the_thread->current_state ) ) {
_Thread_Resume( the_thread, true );
3000d6cc: e3a01001 mov r1, #1 3000d6d0: eb000a6b bl 30010084 <_Thread_Resume>
_Thread_Enable_dispatch();
3000d6d4: eb000859 bl 3000f840 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d6d8: e1a00004 mov r0, r4 3000d6dc: eafffff8 b 3000d6c4 <rtems_task_resume+0x38>
3000c2dc <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2dc: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2e0: e59f3094 ldr r3, [pc, #148] ; 3000c37c <rtems_task_set_note+0xa0>
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2e4: e1a0c000 mov ip, r0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2e8: e5d33004 ldrb r3, [r3, #4]
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2ec: e24dd008 sub sp, sp, #8
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2f0: e3530000 cmp r3, #0
rtems_status_code rtems_task_set_note(
rtems_id id,
uint32_t notepad,
uint32_t note
)
{
3000c2f4: e1a04001 mov r4, r1
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
return RTEMS_NOT_CONFIGURED;
3000c2f8: 03a00016 moveq r0, #22
{
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
3000c2fc: 0a000015 beq 3000c358 <rtems_task_set_note+0x7c>
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c300: e351000f cmp r1, #15
return RTEMS_INVALID_NUMBER;
3000c304: 83a0000a movhi r0, #10
/*
* NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would
* be checking an unsigned number for being negative.
*/
if ( notepad > RTEMS_NOTEPAD_LAST )
3000c308: 8a000012 bhi 3000c358 <rtems_task_set_note+0x7c>
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c30c: e35c0000 cmp ip, #0
3000c310: 0a000012 beq 3000c360 <rtems_task_set_note+0x84>
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
3000c314: e59f3064 ldr r3, [pc, #100] ; 3000c380 <rtems_task_set_note+0xa4> 3000c318: e5933004 ldr r3, [r3, #4]
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c31c: e5931008 ldr r1, [r3, #8] 3000c320: e15c0001 cmp ip, r1
3000c324: 0a00000f beq 3000c368 <rtems_task_set_note+0x8c>
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
3000c328: e28d1004 add r1, sp, #4 3000c32c: e58d2000 str r2, [sp] 3000c330: eb0008e0 bl 3000e6b8 <_Thread_Get>
switch ( location ) {
3000c334: e89d0024 ldm sp, {r2, r5}
3000c338: e3550000 cmp r5, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000c33c: 13a00004 movne r0, #4
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000c340: 1a000004 bne 3000c358 <rtems_task_set_note+0x7c>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c344: e59030f4 ldr r3, [r0, #244] ; 0xf4 3000c348: e2844008 add r4, r4, #8 3000c34c: e7832104 str r2, [r3, r4, lsl #2]
_Thread_Enable_dispatch();
3000c350: eb0008cf bl 3000e694 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000c354: e1a00005 mov r0, r5
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000c358: e28dd008 add sp, sp, #8
3000c35c: e8bd8030 pop {r4, r5, pc}
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
3000c360: e59f3018 ldr r3, [pc, #24] ; 3000c380 <rtems_task_set_note+0xa4><== NOT EXECUTED 3000c364: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
3000c368: e59330f4 ldr r3, [r3, #244] ; 0xf4 <== NOT EXECUTED 3000c36c: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000c370: e7832104 str r2, [r3, r4, lsl #2] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000c374: e3a00000 mov r0, #0 <== NOT EXECUTED 3000c378: eafffff6 b 3000c358 <rtems_task_set_note+0x7c> <== NOT EXECUTED
3000e550 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000e550: e92d4030 push {r4, r5, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e554: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
3000e558: e24dd004 sub sp, sp, #4 3000e55c: e1a05002 mov r5, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
3000e560: 0a000004 beq 3000e578 <rtems_task_set_priority+0x28>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3000e564: e59f3078 ldr r3, [pc, #120] ; 3000e5e4 <rtems_task_set_priority+0x94> 3000e568: e5d33000 ldrb r3, [r3]
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3000e56c: e1540003 cmp r4, r3
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
3000e570: 83a00013 movhi r0, #19
3000e574: 8a000018 bhi 3000e5dc <rtems_task_set_priority+0x8c>
if ( !old_priority )
3000e578: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000e57c: 03a00009 moveq r0, #9
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
3000e580: 0a000015 beq 3000e5dc <rtems_task_set_priority+0x8c>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
3000e584: e1a0100d mov r1, sp 3000e588: eb0008cc bl 300108c0 <_Thread_Get>
switch ( location ) {
3000e58c: e59d3000 ldr r3, [sp] 3000e590: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000e594: 13a00004 movne r0, #4
if ( !old_priority )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000e598: 1a00000f bne 3000e5dc <rtems_task_set_priority+0x8c>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000e59c: e5903014 ldr r3, [r0, #20]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e5a0: e3540000 cmp r4, #0
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
3000e5a4: e5853000 str r3, [r5]
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
3000e5a8: 0a000009 beq 3000e5d4 <rtems_task_set_priority+0x84>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
3000e5ac: e590301c ldr r3, [r0, #28]
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
the_thread->real_priority = new_priority;
3000e5b0: e5804018 str r4, [r0, #24]
if ( the_thread->resource_count == 0 ||
3000e5b4: e3530000 cmp r3, #0
3000e5b8: 0a000002 beq 3000e5c8 <rtems_task_set_priority+0x78>
3000e5bc: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 3000e5c0: e1540003 cmp r4, r3 <== NOT EXECUTED 3000e5c4: 2a000002 bcs 3000e5d4 <rtems_task_set_priority+0x84> <== NOT EXECUTED
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
3000e5c8: e1a01004 mov r1, r4 3000e5cc: e3a02000 mov r2, #0 3000e5d0: eb000794 bl 30010428 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
3000e5d4: eb0008b0 bl 3001089c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000e5d8: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000e5dc: e28dd004 add sp, sp, #4
3000e5e0: e8bd8030 pop {r4, r5, pc}
30009fc8 <rtems_task_start>:
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
30009fc8: e92d4070 push {r4, r5, r6, lr}
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
30009fcc: e2515000 subs r5, r1, #0
rtems_status_code rtems_task_start(
rtems_id id,
rtems_task_entry entry_point,
rtems_task_argument argument
)
{
30009fd0: e24dd008 sub sp, sp, #8 30009fd4: e1a06002 mov r6, r2
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
30009fd8: 03a00009 moveq r0, #9
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( entry_point == NULL )
30009fdc: 0a00000e beq 3000a01c <rtems_task_start+0x54>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
30009fe0: e28d1004 add r1, sp, #4 30009fe4: eb00082f bl 3000c0a8 <_Thread_Get>
switch ( location ) {
30009fe8: e59d4004 ldr r4, [sp, #4] 30009fec: e3540000 cmp r4, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
30009ff0: 13a00004 movne r0, #4
if ( entry_point == NULL )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
30009ff4: 1a000008 bne 3000a01c <rtems_task_start+0x54>
case OBJECTS_LOCAL:
if ( _Thread_Start(
30009ff8: e1a01004 mov r1, r4 30009ffc: e1a02005 mov r2, r5 3000a000: e1a03004 mov r3, r4 3000a004: e58d6000 str r6, [sp] 3000a008: eb000a8e bl 3000ca48 <_Thread_Start> 3000a00c: e3500000 cmp r0, #0
3000a010: 1a000003 bne 3000a024 <rtems_task_start+0x5c>
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000a014: eb00081a bl 3000c084 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3000a018: e3a0000e mov r0, #14 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a01c: e28dd008 add sp, sp, #8
3000a020: e8bd8070 pop {r4, r5, r6, pc}
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Thread_Start(
the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
_Thread_Enable_dispatch();
3000a024: eb000816 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a028: e1a00004 mov r0, r4 3000a02c: eafffffa b 3000a01c <rtems_task_start+0x54>
3000d930 <rtems_task_suspend>:
*/
rtems_status_code rtems_task_suspend(
rtems_id id
)
{
3000d930: e92d4010 push {r4, lr}
3000d934: e24dd004 sub sp, sp, #4
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d938: e1a0100d mov r1, sp 3000d93c: eb00083d bl 3000fa38 <_Thread_Get>
switch ( location ) {
3000d940: e59d3000 ldr r3, [sp]
)
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
3000d944: e1a02000 mov r2, r0
switch ( location ) {
3000d948: e3530000 cmp r3, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000d94c: 13a00004 movne r0, #4
{
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
switch ( location ) {
3000d950: 1a000004 bne 3000d968 <rtems_task_suspend+0x38>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_suspended (
States_Control the_states
)
{
return (the_states & STATES_SUSPENDED);
3000d954: e5924010 ldr r4, [r2, #16]
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
3000d958: e2144002 ands r4, r4, #2
3000d95c: 0a000003 beq 3000d970 <rtems_task_suspend+0x40>
_Thread_Suspend( the_thread );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
3000d960: eb00082b bl 3000fa14 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_ALREADY_SUSPENDED;
3000d964: e3a0000f mov r0, #15 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000d968: e28dd004 add sp, sp, #4
3000d96c: e8bd8010 pop {r4, pc}
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Suspend( the_thread );
3000d970: eb000aab bl 30010424 <_Thread_Suspend>
_Thread_Enable_dispatch();
3000d974: eb000826 bl 3000fa14 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000d978: e1a00004 mov r0, r4 3000d97c: eafffff9 b 3000d968 <rtems_task_suspend+0x38>
3000addc <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000addc: e92d4070 push {r4, r5, r6, lr}
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000ade0: e2514000 subs r4, r1, #0
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
3000ade4: e24dd004 sub sp, sp, #4 3000ade8: e1a05002 mov r5, r2
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000adec: 03a00009 moveq r0, #9
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
3000adf0: 0a000016 beq 3000ae50 <rtems_task_variable_add+0x74>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000adf4: e1a0100d mov r1, sp 3000adf8: eb00087a bl 3000cfe8 <_Thread_Get>
switch (location) {
3000adfc: e59d3000 ldr r3, [sp]
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000ae00: e1a06000 mov r6, r0
switch (location) {
3000ae04: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000ae08: 13a00004 movne r0, #4
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000ae0c: 1a00000f bne 3000ae50 <rtems_task_variable_add+0x74>
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
3000ae10: e5963100 ldr r3, [r6, #256] ; 0x100
while (tvp) {
3000ae14: e3530000 cmp r3, #0
3000ae18: 1a000011 bne 3000ae64 <rtems_task_variable_add+0x88>
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
3000ae1c: e3a00014 mov r0, #20 3000ae20: eb000cbc bl 3000e118 <_Workspace_Allocate>
if (new == NULL) {
3000ae24: e3500000 cmp r0, #0
3000ae28: 0a000014 beq 3000ae80 <rtems_task_variable_add+0xa4>
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
3000ae2c: e5942000 ldr r2, [r4]
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000ae30: e5963100 ldr r3, [r6, #256] ; 0x100
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
3000ae34: e5802008 str r2, [r0, #8]
new->ptr = ptr;
3000ae38: e5804004 str r4, [r0, #4]
new->dtor = dtor;
3000ae3c: e5805010 str r5, [r0, #16]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
3000ae40: e5803000 str r3, [r0]
the_thread->task_variables = new;
3000ae44: e5860100 str r0, [r6, #256] ; 0x100
_Thread_Enable_dispatch();
3000ae48: eb00085d bl 3000cfc4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000ae4c: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000ae50: e28dd004 add sp, sp, #4
3000ae54: e8bd8070 pop {r4, r5, r6, pc}
if (tvp->ptr == ptr) {
tvp->dtor = dtor;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
3000ae58: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000ae5c: e3530000 cmp r3, #0 <== NOT EXECUTED 3000ae60: 0affffed beq 3000ae1c <rtems_task_variable_add+0x40> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000ae64: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000ae68: e1520004 cmp r2, r4 <== NOT EXECUTED 3000ae6c: 1afffff9 bne 3000ae58 <rtems_task_variable_add+0x7c> <== NOT EXECUTED
tvp->dtor = dtor;
3000ae70: e5835010 str r5, [r3, #16] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000ae74: eb000852 bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000ae78: e3a00000 mov r0, #0 <== NOT EXECUTED 3000ae7c: eafffff3 b 3000ae50 <rtems_task_variable_add+0x74> <== NOT EXECUTED
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
3000ae80: eb00084f bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
3000ae84: e3a0001a mov r0, #26 <== NOT EXECUTED 3000ae88: eafffff0 b 3000ae50 <rtems_task_variable_add+0x74> <== NOT EXECUTED
3000ae8c <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
3000ae8c: e92d4010 push {r4, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
3000ae90: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
3000ae94: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
3000ae98: 03a00009 moveq r0, #9 <== NOT EXECUTED
{
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
3000ae9c: 0a000015 beq 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
3000aea0: e1a0100d mov r1, sp <== NOT EXECUTED 3000aea4: eb00084f bl 3000cfe8 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000aea8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000aeac: e3530000 cmp r3, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000aeb0: 13a00004 movne r0, #4 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000aeb4: 1a00000f bne 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
3000aeb8: e5903100 ldr r3, [r0, #256] ; 0x100 <== NOT EXECUTED
while (tvp) {
3000aebc: e3530000 cmp r3, #0 <== NOT EXECUTED 3000aec0: 0a00000a beq 3000aef0 <rtems_task_variable_delete+0x64> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000aec4: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000aec8: e1520004 cmp r2, r4 <== NOT EXECUTED 3000aecc: 1a000004 bne 3000aee4 <rtems_task_variable_delete+0x58> <== NOT EXECUTED 3000aed0: ea000010 b 3000af18 <rtems_task_variable_delete+0x8c> <== NOT EXECUTED 3000aed4: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED 3000aed8: e1520004 cmp r2, r4 <== NOT EXECUTED 3000aedc: 0a000007 beq 3000af00 <rtems_task_variable_delete+0x74> <== NOT EXECUTED 3000aee0: e1a03001 mov r3, r1 <== NOT EXECUTED
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
3000aee4: e5931000 ldr r1, [r3] <== NOT EXECUTED
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
3000aee8: e3510000 cmp r1, #0 <== NOT EXECUTED 3000aeec: 1afffff8 bne 3000aed4 <rtems_task_variable_delete+0x48> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000aef0: eb000833 bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000aef4: e3a00009 mov r0, #9 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000aef8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000aefc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
3000af00: e5912000 ldr r2, [r1] <== NOT EXECUTED 3000af04: e5832000 str r2, [r3] <== NOT EXECUTED
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
3000af08: eb000028 bl 3000afb0 <_RTEMS_Tasks_Invoke_task_variable_dtor><== NOT EXECUTED
_Thread_Enable_dispatch();
3000af0c: eb00082c bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000af10: e3a00000 mov r0, #0 <== NOT EXECUTED 3000af14: eafffff7 b 3000aef8 <rtems_task_variable_delete+0x6c> <== NOT EXECUTED
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
3000af18: e5932000 ldr r2, [r3] <== NOT EXECUTED 3000af1c: e1a01003 mov r1, r3 <== NOT EXECUTED 3000af20: e5802100 str r2, [r0, #256] ; 0x100 <== NOT EXECUTED 3000af24: eafffff7 b 3000af08 <rtems_task_variable_delete+0x7c> <== NOT EXECUTED
3000af28 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000af28: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000af2c: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
3000af30: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3000af34: e1a05002 mov r5, r2 <== NOT EXECUTED
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
3000af38: 0a000017 beq 3000af9c <rtems_task_variable_get+0x74> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !result )
3000af3c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000af40: 0a000015 beq 3000af9c <rtems_task_variable_get+0x74> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
3000af44: e1a0100d mov r1, sp <== NOT EXECUTED 3000af48: eb000826 bl 3000cfe8 <_Thread_Get> <== NOT EXECUTED
switch (location) {
3000af4c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3000af50: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000af54: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !result )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
switch (location) {
3000af58: 1a00000d bne 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
3000af5c: e5903100 ldr r3, [r0, #256] ; 0x100 <== NOT EXECUTED
while (tvp) {
3000af60: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af64: 1a000003 bne 3000af78 <rtems_task_variable_get+0x50> <== NOT EXECUTED 3000af68: ea00000d b 3000afa4 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
*/
*result = tvp->tval;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
3000af6c: e5933000 ldr r3, [r3] <== NOT EXECUTED
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
3000af70: e3530000 cmp r3, #0 <== NOT EXECUTED 3000af74: 0a00000a beq 3000afa4 <rtems_task_variable_get+0x7c> <== NOT EXECUTED
if (tvp->ptr == ptr) {
3000af78: e5932004 ldr r2, [r3, #4] <== NOT EXECUTED 3000af7c: e1520004 cmp r2, r4 <== NOT EXECUTED 3000af80: 1afffff9 bne 3000af6c <rtems_task_variable_get+0x44> <== NOT EXECUTED
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
3000af84: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 3000af88: e5853000 str r3, [r5] <== NOT EXECUTED
_Thread_Enable_dispatch();
3000af8c: eb00080c bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000af90: e3a00000 mov r0, #0 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000af94: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3000af98: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
if ( !result )
return RTEMS_INVALID_ADDRESS;
3000af9c: e3a00009 mov r0, #9 <== NOT EXECUTED 3000afa0: eafffffb b 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
3000afa4: eb000806 bl 3000cfc4 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3000afa8: e3a00009 mov r0, #9 <== NOT EXECUTED 3000afac: eafffff8 b 3000af94 <rtems_task_variable_get+0x6c> <== NOT EXECUTED
3000a030 <rtems_task_wake_after>:
3000a030: e59f307c ldr r3, [pc, #124] ; 3000a0b4 <rtems_task_wake_after+0x84>
*/
rtems_status_code rtems_task_wake_after(
rtems_interval ticks
)
{
3000a034: e92d4030 push {r4, r5, lr}
3000a038: e5932000 ldr r2, [r3]
3000a03c: e1a04000 mov r4, r0
3000a040: e2822001 add r2, r2, #1
3000a044: e5832000 str r2, [r3]
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
3000a048: e3500000 cmp r0, #0
3000a04c: 0a000012 beq 3000a09c <rtems_task_wake_after+0x6c>
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
3000a050: e59f5060 ldr r5, [pc, #96] ; 3000a0b8 <rtems_task_wake_after+0x88><== NOT EXECUTED 3000a054: e3a01008 mov r1, #8 <== NOT EXECUTED 3000a058: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 3000a05c: eb000a20 bl 3000c8e4 <_Thread_Set_state> <== NOT EXECUTED
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000a060: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a064: e59f0050 ldr r0, [pc, #80] ; 3000a0bc <rtems_task_wake_after+0x8c><== NOT EXECUTED
_Thread_Disable_dispatch();
if ( ticks == 0 ) {
_Scheduler_Yield();
} else {
_Thread_Set_state( _Thread_Executing, STATES_DELAYING );
_Watchdog_Initialize(
3000a068: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a06c: e3a03000 mov r3, #0 <== NOT EXECUTED 3000a070: e5813050 str r3, [r1, #80] ; 0x50 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id;
3000a074: e5812068 str r2, [r1, #104] ; 0x68 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3000a078: e581306c str r3, [r1, #108] ; 0x6c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000a07c: e5810064 str r0, [r1, #100] ; 0x64 <== NOT EXECUTED
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a080: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a084: e59f0034 ldr r0, [pc, #52] ; 3000a0c0 <rtems_task_wake_after+0x90><== NOT EXECUTED 3000a088: e2811048 add r1, r1, #72 ; 0x48 <== NOT EXECUTED 3000a08c: eb000b76 bl 3000ce6c <_Watchdog_Insert> <== NOT EXECUTED
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a090: eb0007fb bl 3000c084 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL; }
3000a094: e3a00000 mov r0, #0 <== NOT EXECUTED
3000a098: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
3000a09c: e59f3020 ldr r3, [pc, #32] ; 3000a0c4 <rtems_task_wake_after+0x94> 3000a0a0: e1a0e00f mov lr, pc 3000a0a4: e593f00c ldr pc, [r3, #12]
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
}
_Thread_Enable_dispatch();
3000a0a8: eb0007f5 bl 3000c084 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL; }
3000a0ac: e3a00000 mov r0, #0
3000a0b0: e8bd8030 pop {r4, r5, pc}
3000b0ec <rtems_task_wake_when>:
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0ec: e59f30bc ldr r3, [pc, #188] ; 3000b1b0 <rtems_task_wake_when+0xc4>
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b0f0: e92d40f0 push {r4, r5, r6, r7, lr}
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0f4: e5d33000 ldrb r3, [r3]
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
3000b0f8: e1a05000 mov r5, r0
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b0fc: e3530000 cmp r3, #0
return RTEMS_NOT_DEFINED;
3000b100: 03a0000b moveq r0, #11
rtems_time_of_day *time_buffer
)
{
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
3000b104: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b108: e3550000 cmp r5, #0
return RTEMS_INVALID_ADDRESS;
3000b10c: 03a00009 moveq r0, #9
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
3000b110: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
3000b114: e3a04000 mov r4, #0 3000b118: e5854018 str r4, [r5, #24]
if ( !_TOD_Validate( time_buffer ) )
3000b11c: ebfffcfa bl 3000a50c <_TOD_Validate> 3000b120: e1500004 cmp r0, r4
return RTEMS_INVALID_CLOCK;
3000b124: 03a00014 moveq r0, #20
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
3000b128: 08bd80f0 popeq {r4, r5, r6, r7, pc}
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000b12c: e1a00005 mov r0, r5 3000b130: ebfffcca bl 3000a460 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
3000b134: e59f6078 ldr r6, [pc, #120] ; 3000b1b4 <rtems_task_wake_when+0xc8>
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
3000b138: e1a05000 mov r5, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3000b13c: e5963000 ldr r3, [r6] 3000b140: e1500003 cmp r0, r3
3000b144: 8a000001 bhi 3000b150 <rtems_task_wake_when+0x64>
return RTEMS_INVALID_CLOCK;
3000b148: e3a00014 mov r0, #20 <== NOT EXECUTED
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000b14c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
3000b150: e59f3060 ldr r3, [pc, #96] ; 3000b1b8 <rtems_task_wake_when+0xcc> 3000b154: e5932000 ldr r2, [r3] 3000b158: e2822001 add r2, r2, #1 3000b15c: e5832000 str r2, [r3]
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
3000b160: e59f7054 ldr r7, [pc, #84] ; 3000b1bc <rtems_task_wake_when+0xd0> 3000b164: e3a01010 mov r1, #16 3000b168: e5970004 ldr r0, [r7, #4] 3000b16c: eb000a28 bl 3000da14 <_Thread_Set_state>
_Watchdog_Initialize(
&_Thread_Executing->Timer,
3000b170: e5971004 ldr r1, [r7, #4]
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000b174: e5962000 ldr r2, [r6]
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
_Watchdog_Initialize(
3000b178: e5913008 ldr r3, [r1, #8]
&_Thread_Executing->Timer,
_Thread_Delay_ended,
_Thread_Executing->Object.id,
NULL
);
_Watchdog_Insert_seconds(
3000b17c: e0625005 rsb r5, r2, r5
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b180: e59f2038 ldr r2, [pc, #56] ; 3000b1c0 <rtems_task_wake_when+0xd4>
the_watchdog->id = id;
3000b184: e5813068 str r3, [r1, #104] ; 0x68
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3000b188: e5812064 str r2, [r1, #100] ; 0x64
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b18c: e59f0030 ldr r0, [pc, #48] ; 3000b1c4 <rtems_task_wake_when+0xd8>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000b190: e5814050 str r4, [r1, #80] ; 0x50
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3000b194: e581406c str r4, [r1, #108] ; 0x6c
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000b198: e5815054 str r5, [r1, #84] ; 0x54
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3000b19c: e2811048 add r1, r1, #72 ; 0x48 3000b1a0: eb000bae bl 3000e060 <_Watchdog_Insert>
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3000b1a4: eb000802 bl 3000d1b4 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000b1a8: e1a00004 mov r0, r4 <== NOT EXECUTED
3000b1ac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
30009448 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009448: e3500009 cmp r0, #9 <== NOT EXECUTED 3000944c: 012fff1e bxeq lr <== NOT EXECUTED 30009450: da000010 ble 30009498 <rtems_termios_baud_to_index+0x50> <== NOT EXECUTED 30009454: e350000e cmp r0, #14 <== NOT EXECUTED 30009458: 012fff1e bxeq lr <== NOT EXECUTED 3000945c: da000018 ble 300094c4 <rtems_termios_baud_to_index+0x7c> <== NOT EXECUTED 30009460: e59f30d0 ldr r3, [pc, #208] ; 30009538 <rtems_termios_baud_to_index+0xf0><== NOT EXECUTED 30009464: e1500003 cmp r0, r3 <== NOT EXECUTED
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
30009468: 03a00011 moveq r0, #17 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
3000946c: 012fff1e bxeq lr <== NOT EXECUTED 30009470: da000026 ble 30009510 <rtems_termios_baud_to_index+0xc8> <== NOT EXECUTED 30009474: e59f30c0 ldr r3, [pc, #192] ; 3000953c <rtems_termios_baud_to_index+0xf4><== NOT EXECUTED 30009478: e1500003 cmp r0, r3 <== NOT EXECUTED
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
3000947c: 03a00012 moveq r0, #18 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009480: 012fff1e bxeq lr <== NOT EXECUTED 30009484: e2833001 add r3, r3, #1 <== NOT EXECUTED 30009488: e1500003 cmp r0, r3 <== NOT EXECUTED 3000948c: 1a00001d bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
30009490: e3a00013 mov r0, #19 <== NOT EXECUTED 30009494: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009498: e3500004 cmp r0, #4 <== NOT EXECUTED 3000949c: 012fff1e bxeq lr <== NOT EXECUTED 300094a0: ca000010 bgt 300094e8 <rtems_termios_baud_to_index+0xa0> <== NOT EXECUTED 300094a4: e3500001 cmp r0, #1 <== NOT EXECUTED 300094a8: 012fff1e bxeq lr <== NOT EXECUTED 300094ac: da00001e ble 3000952c <rtems_termios_baud_to_index+0xe4> <== NOT EXECUTED 300094b0: e3500002 cmp r0, #2 <== NOT EXECUTED 300094b4: 012fff1e bxeq lr <== NOT EXECUTED 300094b8: e3500003 cmp r0, #3 <== NOT EXECUTED 300094bc: 1a000011 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED 300094c0: e12fff1e bx lr <== NOT EXECUTED 300094c4: e350000b cmp r0, #11 <== NOT EXECUTED 300094c8: 012fff1e bxeq lr <== NOT EXECUTED
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
case B1800: baud_index = 10; break;
300094cc: b3a0000a movlt r0, #10 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
300094d0: b12fff1e bxlt lr <== NOT EXECUTED 300094d4: e350000c cmp r0, #12 <== NOT EXECUTED 300094d8: 012fff1e bxeq lr <== NOT EXECUTED 300094dc: e350000d cmp r0, #13 <== NOT EXECUTED 300094e0: 1a000008 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED 300094e4: e12fff1e bx lr <== NOT EXECUTED 300094e8: e3500006 cmp r0, #6 <== NOT EXECUTED 300094ec: 012fff1e bxeq lr <== NOT EXECUTED
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
300094f0: b3a00005 movlt r0, #5 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
300094f4: b12fff1e bxlt lr <== NOT EXECUTED 300094f8: e3500007 cmp r0, #7 <== NOT EXECUTED 300094fc: 012fff1e bxeq lr <== NOT EXECUTED 30009500: e3500008 cmp r0, #8 <== NOT EXECUTED 30009504: 012fff1e bxeq lr <== NOT EXECUTED
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
30009508: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
return baud_index;
}
3000950c: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
30009510: e350000f cmp r0, #15 <== NOT EXECUTED 30009514: 012fff1e bxeq lr <== NOT EXECUTED 30009518: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3000951c: e1500003 cmp r0, r3 <== NOT EXECUTED 30009520: 1afffff8 bne 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
30009524: e3a00010 mov r0, #16 <== NOT EXECUTED 30009528: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
3000952c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009530: 012fff1e bxeq lr <== NOT EXECUTED 30009534: eafffff3 b 30009508 <rtems_termios_baud_to_index+0xc0> <== NOT EXECUTED
30009540 <rtems_termios_baud_to_number>:
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
30009540: e92d4010 push {r4, lr} <== NOT EXECUTED
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
30009544: e1a01000 mov r1, r0 <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];
int32_t rtems_termios_baud_to_number(
int termios_baud
)
{
30009548: e1a04000 mov r4, r0 <== NOT EXECUTED
int baud;
baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud );
3000954c: e59f001c ldr r0, [pc, #28] ; 30009570 <rtems_termios_baud_to_number+0x30><== NOT EXECUTED 30009550: eb001c9b bl 300107c4 <rtems_assoc_local_by_remote> <== NOT EXECUTED
if ( baud == 0 && termios_baud != 0 )
30009554: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 30009558: 33a03000 movcc r3, #0 <== NOT EXECUTED 3000955c: e3540000 cmp r4, #0 <== NOT EXECUTED 30009560: 03a03000 moveq r3, #0 <== NOT EXECUTED 30009564: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return baud;
}
30009568: 13e00000 mvnne r0, #0 <== NOT EXECUTED
3000956c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007af8 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
30007af8: e59f300c ldr r3, [pc, #12] ; 30007b0c <rtems_termios_bufsize+0x14><== NOT EXECUTED 30007afc: e5830008 str r0, [r3, #8] <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
30007b00: e8830006 stm r3, {r1, r2} <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output; return RTEMS_SUCCESSFUL; }
30007b04: e3a00000 mov r0, #0 <== NOT EXECUTED 30007b08: e12fff1e bx lr <== NOT EXECUTED
30007938 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
30007938: e92d4070 push {r4, r5, r6, lr}
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
3000793c: e59f51a4 ldr r5, [pc, #420] ; 30007ae8 <rtems_termios_close+0x1b0>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30007940: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain(
30007944: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
30007948: e1a06000 mov r6, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain(
3000794c: e1a02001 mov r2, r1 30007950: e5950000 ldr r0, [r5]
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30007954: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain(
30007958: eb00087d bl 30009b54 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3000795c: e3500000 cmp r0, #0
30007960: 1a00005f bne 30007ae4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
30007964: e5943008 ldr r3, [r4, #8] 30007968: e2433001 sub r3, r3, #1 3000796c: e3530000 cmp r3, #0 30007970: e5843008 str r3, [r4, #8]
30007974: 1a00002f bne 30007a38 <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007978: e59420cc ldr r2, [r4, #204] ; 0xcc 3000797c: e59f3168 ldr r3, [pc, #360] ; 30007aec <rtems_termios_close+0x1b4> 30007980: e0833282 add r3, r3, r2, lsl #5 30007984: e5931004 ldr r1, [r3, #4] 30007988: e3510000 cmp r1, #0
3000798c: 0a00003e beq 30007a8c <rtems_termios_close+0x154>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
30007990: e1a00004 mov r0, r4 <== NOT EXECUTED 30007994: e1a0e00f mov lr, pc <== NOT EXECUTED 30007998: e12fff11 bx r1 <== NOT EXECUTED
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000799c: e59430b4 ldr r3, [r4, #180] ; 0xb4 <== NOT EXECUTED 300079a0: e3530002 cmp r3, #2 <== NOT EXECUTED 300079a4: 0a000044 beq 30007abc <rtems_termios_close+0x184> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
300079a8: e594309c ldr r3, [r4, #156] ; 0x9c 300079ac: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
300079b0: 1594000c ldrne r0, [r4, #12] 300079b4: 15941010 ldrne r1, [r4, #16] 300079b8: 11a02006 movne r2, r6 300079bc: 11a0e00f movne lr, pc 300079c0: 112fff13 bxne r3
if (tty->forw == NULL) {
300079c4: e5943000 ldr r3, [r4] 300079c8: e3530000 cmp r3, #0
300079cc: 0a000026 beq 30007a6c <rtems_termios_close+0x134>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
} else {
tty->forw->back = tty->back;
300079d0: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 300079d4: e5832004 str r2, [r3, #4] <== NOT EXECUTED 300079d8: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
}
if (tty->back == NULL) {
300079dc: e3520000 cmp r2, #0 <== NOT EXECUTED 300079e0: 0a00001b beq 30007a54 <rtems_termios_close+0x11c> <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
} else {
tty->back->forw = tty->forw;
300079e4: e5823000 str r3, [r2] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
300079e8: e5940014 ldr r0, [r4, #20] 300079ec: eb00082f bl 30009ab0 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
300079f0: e5940018 ldr r0, [r4, #24] 300079f4: eb00082d bl 30009ab0 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
300079f8: e594008c ldr r0, [r4, #140] ; 0x8c 300079fc: eb00082b bl 30009ab0 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
30007a00: e59430a0 ldr r3, [r4, #160] ; 0xa0 30007a04: e3530000 cmp r3, #0
30007a08: 0a00000e beq 30007a48 <rtems_termios_close+0x110>
30007a0c: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007a10: e3530002 cmp r3, #2
30007a14: 0a00000b beq 30007a48 <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
30007a18: e5940058 ldr r0, [r4, #88] ; 0x58 30007a1c: ebfffa9d bl 30006498 <free>
free (tty->rawOutBuf.theBuf);
30007a20: e594007c ldr r0, [r4, #124] ; 0x7c 30007a24: ebfffa9b bl 30006498 <free>
free (tty->cbuf);
30007a28: e594001c ldr r0, [r4, #28] 30007a2c: ebfffa99 bl 30006498 <free>
free (tty);
30007a30: e1a00004 mov r0, r4 30007a34: ebfffa97 bl 30006498 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
30007a38: e5950000 ldr r0, [r5] 30007a3c: eb00088d bl 30009c78 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30007a40: e3a00000 mov r0, #0
30007a44: e8bd8070 pop {r4, r5, r6, pc}
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
30007a48: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30007a4c: eb000817 bl 30009ab0 <rtems_semaphore_delete> <== NOT EXECUTED 30007a50: eafffff0 b 30007a18 <rtems_termios_close+0xe0> <== NOT EXECUTED
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30007a54: e59f2094 ldr r2, [pc, #148] ; 30007af0 <rtems_termios_close+0x1b8>
if ( rtems_termios_ttyHead != NULL ) {
30007a58: e3530000 cmp r3, #0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
30007a5c: e5823000 str r3, [r2]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
30007a60: 13a02000 movne r2, #0 30007a64: 15832004 strne r2, [r3, #4] 30007a68: eaffffde b 300079e8 <rtems_termios_close+0xb0>
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
30007a6c: e5942004 ldr r2, [r4, #4] 30007a70: e59f107c ldr r1, [pc, #124] ; 30007af4 <rtems_termios_close+0x1bc>
if ( rtems_termios_ttyTail != NULL ) {
30007a74: e3520000 cmp r2, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
30007a78: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
30007a7c: 0afffff4 beq 30007a54 <rtems_termios_close+0x11c>
rtems_termios_ttyTail->forw = NULL;
30007a80: e5823000 str r3, [r2] <== NOT EXECUTED 30007a84: e5943000 ldr r3, [r4] <== NOT EXECUTED 30007a88: eaffffd5 b 300079e4 <rtems_termios_close+0xac> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007a8c: e5940018 ldr r0, [r4, #24] 30007a90: e1a02001 mov r2, r1 30007a94: eb00082e bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30007a98: e3500000 cmp r0, #0
30007a9c: 1a000010 bne 30007ae4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
30007aa0: e1a00004 mov r0, r4 30007aa4: ebfffe57 bl 30007408 <drainOutput>
rtems_semaphore_release (tty->osem);
30007aa8: e5940018 ldr r0, [r4, #24] 30007aac: eb000871 bl 30009c78 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007ab0: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007ab4: e3530002 cmp r3, #2
30007ab8: 1affffba bne 300079a8 <rtems_termios_close+0x70>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
30007abc: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED 30007ac0: e3a01001 mov r1, #1 <== NOT EXECUTED 30007ac4: eb0006ff bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30007ac8: e3500000 cmp r0, #0 <== NOT EXECUTED 30007acc: 1a000004 bne 30007ae4 <rtems_termios_close+0x1ac> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
30007ad0: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED 30007ad4: e3a01001 mov r1, #1 <== NOT EXECUTED 30007ad8: eb0006fa bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30007adc: e3500000 cmp r0, #0 <== NOT EXECUTED 30007ae0: 0affffb0 beq 300079a8 <rtems_termios_close+0x70> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30007ae4: eb0009c1 bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
300090cc <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090cc: e590c090 ldr ip, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090d0: e59020b4 ldr r2, [r0, #180] ; 0xb4 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090d4: e08c1001 add r1, ip, r1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090d8: e3520002 cmp r2, #2 <== NOT EXECUTED
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
300090dc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
300090e0: e5801090 str r1, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
300090e4: 0a00000c beq 3000911c <rtems_termios_dequeue_characters+0x50><== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
300090e8: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 300090ec: e3530005 cmp r3, #5 <== NOT EXECUTED 300090f0: 0a000001 beq 300090fc <rtems_termios_dequeue_characters+0x30><== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
300090f4: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
300090f8: eaffff55 b 30008e54 <rtems_termios_refill_transmitter> <== NOT EXECUTED
if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
300090fc: e59f303c ldr r3, [pc, #60] ; 30009140 <rtems_termios_dequeue_characters+0x74><== NOT EXECUTED 30009100: e59330b4 ldr r3, [r3, #180] ; 0xb4 <== NOT EXECUTED 30009104: e3530000 cmp r3, #0 <== NOT EXECUTED 30009108: 0a00000a beq 30009138 <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
3000910c: e1a0e00f mov lr, pc <== NOT EXECUTED 30009110: e12fff13 bx r3 <== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
30009114: e3a00000 mov r0, #0 <== NOT EXECUTED
30009118: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
3000911c: e59000c8 ldr r0, [r0, #200] ; 0xc8 <== NOT EXECUTED 30009120: e1a01002 mov r1, r2 <== NOT EXECUTED 30009124: eb000167 bl 300096c8 <rtems_event_send> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30009128: e2503000 subs r3, r0, #0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
3000912c: 01a00003 moveq r0, r3 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
30009130: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
30009134: eb00042d bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
30009138: e1a00003 mov r0, r3 <== NOT EXECUTED
}
return rtems_termios_refill_transmitter(tty);
}
3000913c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008ad8 <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
30008ad8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
30008adc: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED 30008ae0: e59f72d8 ldr r7, [pc, #728] ; 30008dc0 <rtems_termios_enqueue_raw_characters+0x2e8><== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
30008ae4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
30008ae8: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30008aec: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
30008af0: e1a04000 mov r4, r0 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
30008af4: e3590000 cmp r9, #0 <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
30008af8: e1a05001 mov r5, r1 <== NOT EXECUTED 30008afc: e1a06002 mov r6, r2 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
30008b00: 0a00001e beq 30008b80 <rtems_termios_enqueue_raw_characters+0xa8><== NOT EXECUTED
while (len--) {
30008b04: e3520000 cmp r2, #0 <== NOT EXECUTED 30008b08: 0a00000b beq 30008b3c <rtems_termios_enqueue_raw_characters+0x64><== NOT EXECUTED 30008b0c: e3a08000 mov r8, #0 <== NOT EXECUTED 30008b10: ea000002 b 30008b20 <rtems_termios_enqueue_raw_characters+0x48><== NOT EXECUTED 30008b14: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED 30008b18: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30008b1c: e5939010 ldr r9, [r3, #16] <== NOT EXECUTED
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
30008b20: e7d50008 ldrb r0, [r5, r8] <== NOT EXECUTED 30008b24: e1a01004 mov r1, r4 <== NOT EXECUTED 30008b28: e2888001 add r8, r8, #1 <== NOT EXECUTED 30008b2c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008b30: e12fff19 bx r9 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
30008b34: e1580006 cmp r8, r6 <== NOT EXECUTED 30008b38: 1afffff5 bne 30008b14 <rtems_termios_enqueue_raw_characters+0x3c><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b3c: e594a0e4 ldr sl, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008b40: e35a0000 cmp sl, #0 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30008b44: 13a0a000 movne sl, #0 <== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b48: 1a000009 bne 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED 30008b4c: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 30008b50: e3530000 cmp r3, #0 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
}
return 0;
30008b54: 01a0a003 moveq sl, r3 <== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008b58: 0a000005 beq 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008b5c: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30008b60: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 30008b64: e1a0e00f mov lr, pc <== NOT EXECUTED 30008b68: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
30008b6c: e3a03001 mov r3, #1 <== NOT EXECUTED 30008b70: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
30008b74: e1a0000a mov r0, sl <== NOT EXECUTED
30008b78: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30008b7c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008b80: e2803030 add r3, r0, #48 ; 0x30 <== NOT EXECUTED 30008b84: e58d3000 str r3, [sp] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008b88: e3560000 cmp r6, #0 <== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
30008b8c: e280304a add r3, r0, #74 ; 0x4a <== NOT EXECUTED 30008b90: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 30008b94: e1a0b009 mov fp, r9 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008b98: 0a000042 beq 30008ca8 <rtems_termios_enqueue_raw_characters+0x1d0><== NOT EXECUTED
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008b9c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
30008ba0: e4d58001 ldrb r8, [r5], #1 <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
30008ba4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED 30008ba8: 0a000005 beq 30008bc4 <rtems_termios_enqueue_raw_characters+0xec><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
30008bac: e5d4304a ldrb r3, [r4, #74] ; 0x4a <== NOT EXECUTED 30008bb0: e1530008 cmp r3, r8 <== NOT EXECUTED 30008bb4: 0a000056 beq 30008d14 <rtems_termios_enqueue_raw_characters+0x23c><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
30008bb8: e5d43049 ldrb r3, [r4, #73] ; 0x49 <== NOT EXECUTED 30008bbc: e1530008 cmp r3, r8 <== NOT EXECUTED 30008bc0: 0a00003f beq 30008cc4 <rtems_termios_enqueue_raw_characters+0x1ec><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
30008bc4: e3590000 cmp r9, #0 <== NOT EXECUTED 30008bc8: 1a000041 bne 30008cd4 <rtems_termios_enqueue_raw_characters+0x1fc><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
30008bcc: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED 30008bd0: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 30008bd4: e2800001 add r0, r0, #1 <== NOT EXECUTED 30008bd8: eb002f5b bl 3001494c <__umodsi3> <== NOT EXECUTED 30008bdc: e1a07000 mov r7, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008be0: e10fa000 mrs sl, CPSR <== NOT EXECUTED 30008be4: e38a3080 orr r3, sl, #128 ; 0x80 <== NOT EXECUTED 30008be8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
30008bec: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30008bf0: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008bf4: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
30008bf8: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
30008bfc: e0800007 add r0, r0, r7 <== NOT EXECUTED 30008c00: eb002f51 bl 3001494c <__umodsi3> <== NOT EXECUTED
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
30008c04: e59430c0 ldr r3, [r4, #192] ; 0xc0 <== NOT EXECUTED 30008c08: e1500003 cmp r0, r3 <== NOT EXECUTED 30008c0c: 9a00000e bls 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
30008c10: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
30008c14: e3130001 tst r3, #1 <== NOT EXECUTED 30008c18: 1a00000b bne 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30008c1c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
30008c20: e59f319c ldr r3, [pc, #412] ; 30008dc4 <rtems_termios_enqueue_raw_characters+0x2ec><== NOT EXECUTED
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
30008c24: e3822001 orr r2, r2, #1 <== NOT EXECUTED 30008c28: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
30008c2c: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008c30: e0023003 and r3, r2, r3 <== NOT EXECUTED 30008c34: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED 30008c38: 0a000047 beq 30008d5c <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
30008c3c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008c40: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED 30008c44: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED 30008c48: 0a000052 beq 30008d98 <rtems_termios_enqueue_raw_characters+0x2c0><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008c4c: e129f00a msr CPSR_fc, sl <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
30008c50: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED 30008c54: e1530007 cmp r3, r7 <== NOT EXECUTED
dropped++;
30008c58: 028bb001 addeq fp, fp, #1 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
30008c5c: 0a00000e beq 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
30008c60: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 30008c64: e7c38007 strb r8, [r3, r7] <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008c68: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
30008c6c: e5847060 str r7, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
30008c70: e3530000 cmp r3, #0 <== NOT EXECUTED 30008c74: 1a000008 bne 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED 30008c78: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED 30008c7c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008c80: 0a000005 beq 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
30008c84: e59d0000 ldr r0, [sp] <== NOT EXECUTED 30008c88: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED 30008c8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008c90: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
30008c94: e3a03001 mov r3, #1 <== NOT EXECUTED 30008c98: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED 30008c9c: e2466001 sub r6, r6, #1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
30008ca0: e3560000 cmp r6, #0 <== NOT EXECUTED 30008ca4: 1affffbc bne 30008b9c <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008ca8: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
30008cac: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
}
}
}
}
tty->rawInBufDropped += dropped;
30008cb0: e083300b add r3, r3, fp <== NOT EXECUTED 30008cb4: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED 30008cb8: e1a0a00b mov sl, fp <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
30008cbc: eb0003ed bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return dropped;
30008cc0: eaffffab b 30008b74 <rtems_termios_enqueue_raw_characters+0x9c><== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
30008cc4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
30008cc8: e3a09001 mov r9, #1 <== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
30008ccc: e3c33010 bic r3, r3, #16 <== NOT EXECUTED 30008cd0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
30008cd4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008cd8: e2033030 and r3, r3, #48 ; 0x30 <== NOT EXECUTED 30008cdc: e3530020 cmp r3, #32 <== NOT EXECUTED 30008ce0: 1affffed bne 30008c9c <rtems_termios_enqueue_raw_characters+0x1c4><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008ce4: e10f7000 mrs r7, CPSR <== NOT EXECUTED 30008ce8: e3873080 orr r3, r7, #128 ; 0x80 <== NOT EXECUTED 30008cec: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008cf0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008cf4: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008cf8: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008cfc: e3520000 cmp r2, #0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30008d00: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30008d04: 1a00000c bne 30008d3c <rtems_termios_enqueue_raw_characters+0x264><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008d08: e129f007 msr CPSR_fc, r7 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
30008d0c: e2466001 sub r6, r6, #1 <== NOT EXECUTED 30008d10: eaffffe2 b 30008ca0 <rtems_termios_enqueue_raw_characters+0x1c8><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
30008d14: e5d42049 ldrb r2, [r4, #73] ; 0x49 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
30008d18: e3a09001 mov r9, #1 <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
30008d1c: e1520003 cmp r2, r3 <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30008d20: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d24: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30008d28: 02233010 eoreq r3, r3, #16 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d2c: 13833010 orrne r3, r3, #16 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
30008d30: 058430b8 streq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
30008d34: 158430b8 strne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008d38: eaffffe5 b 30008cd4 <rtems_termios_enqueue_raw_characters+0x1fc><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
30008d3c: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
30008d40: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30008d44: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008d48: e0811003 add r1, r1, r3 <== NOT EXECUTED 30008d4c: e3a02001 mov r2, #1 <== NOT EXECUTED 30008d50: e1a0e00f mov lr, pc <== NOT EXECUTED 30008d54: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30008d58: eaffffea b 30008d08 <rtems_termios_enqueue_raw_characters+0x230><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
30008d5c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008d60: e3130020 tst r3, #32 <== NOT EXECUTED 30008d64: 1a000002 bne 30008d74 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED 30008d68: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 30008d6c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008d70: 1affffb5 bne 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
30008d74: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
30008d78: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
30008d7c: e3833002 orr r3, r3, #2 <== NOT EXECUTED 30008d80: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
30008d84: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 30008d88: e3a02001 mov r2, #1 <== NOT EXECUTED 30008d8c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008d90: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30008d94: eaffffac b 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008d98: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008d9c: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008da0: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008da4: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
tty->flow_ctrl |= FL_IRTSOFF;
30008da8: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
30008dac: 0affffa6 beq 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
30008db0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008db4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008db8: e12fff13 bx r3 <== NOT EXECUTED 30008dbc: eaffffa2 b 30008c4c <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
30007b10 <rtems_termios_ioctl>:
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30007b10: e5902000 ldr r2, [r0]
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30007b14: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30007b18: e5925034 ldr r5, [r2, #52] ; 0x34
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
30007b1c: e3a03000 mov r3, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
30007b20: e1a04000 mov r4, r0
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
30007b24: e580300c str r3, [r0, #12]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007b28: e1a01003 mov r1, r3 30007b2c: e5950018 ldr r0, [r5, #24] 30007b30: e1a02003 mov r2, r3
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
30007b34: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30007b38: eb000805 bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
30007b3c: e2506000 subs r6, r0, #0
30007b40: 1a00000e bne 30007b80 <rtems_termios_ioctl+0x70>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007b44: e5943004 ldr r3, [r4, #4] 30007b48: e3530004 cmp r3, #4
30007b4c: 0a000006 beq 30007b6c <rtems_termios_ioctl+0x5c> 30007b50: 8a00000d bhi 30007b8c <rtems_termios_ioctl+0x7c>
30007b54: e3530002 cmp r3, #2
30007b58: 0a00001e beq 30007bd8 <rtems_termios_ioctl+0xc8>
30007b5c: 9a000085 bls 30007d78 <rtems_termios_ioctl+0x268>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
30007b60: e1a00005 mov r0, r5 30007b64: ebfffe27 bl 30007408 <drainOutput>
break;
30007b68: ea000002 b 30007b78 <rtems_termios_ioctl+0x68>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
30007b6c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007b70: e58520dc str r2, [r5, #220] ; 0xdc <== NOT EXECUTED
30007b74: e58530e0 str r3, [r5, #224] ; 0xe0 <== NOT EXECUTED
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
30007b78: e5950018 ldr r0, [r5, #24] 30007b7c: eb00083d bl 30009c78 <rtems_semaphore_release>
args->ioctl_return = sc;
30007b80: e584600c str r6, [r4, #12]
return sc; }
30007b84: e1a00006 mov r0, r6
30007b88: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007b8c: e59f2340 ldr r2, [pc, #832] ; 30007ed4 <rtems_termios_ioctl+0x3c4><== NOT EXECUTED 30007b90: e1530002 cmp r3, r2 <== NOT EXECUTED 30007b94: 0a00006b beq 30007d48 <rtems_termios_ioctl+0x238> <== NOT EXECUTED 30007b98: 8a000082 bhi 30007da8 <rtems_termios_ioctl+0x298> <== NOT EXECUTED 30007b9c: e3530005 cmp r3, #5 <== NOT EXECUTED 30007ba0: 0a0000a1 beq 30007e2c <rtems_termios_ioctl+0x31c> <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
30007ba4: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED 30007ba8: e59f3328 ldr r3, [pc, #808] ; 30007ed8 <rtems_termios_ioctl+0x3c8><== NOT EXECUTED 30007bac: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 30007bb0: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 30007bb4: e3530000 cmp r3, #0 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
30007bb8: 03a0600a moveq r6, #10 <== NOT EXECUTED
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
30007bbc: 0affffed beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
30007bc0: e1a00005 mov r0, r5 <== NOT EXECUTED 30007bc4: e1a01004 mov r1, r4 <== NOT EXECUTED 30007bc8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007bcc: e12fff13 bx r3 <== NOT EXECUTED 30007bd0: e1a06000 mov r6, r0 <== NOT EXECUTED 30007bd4: eaffffe7 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007bd8: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED
30007bdc: e2857030 add r7, r5, #48 ; 0x30 <== NOT EXECUTED
30007be0: e1a0c007 mov ip, r7 <== NOT EXECUTED
30007be4: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007be8: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007bec: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007bf0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
30007bf4: e59520b8 ldr r2, [r5, #184] ; 0xb8 <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007bf8: e59e3000 ldr r3, [lr] <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
30007bfc: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
30007c00: e58c3000 str r3, [ip] <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
30007c04: 0a000012 beq 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
30007c08: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
30007c0c: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 30007c10: 1a00000f bne 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
30007c14: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c18: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED 30007c1c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
30007c20: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c24: e3130020 tst r3, #32 <== NOT EXECUTED 30007c28: 0a000009 beq 30007c54 <rtems_termios_ioctl+0x144> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007c2c: e10f8000 mrs r8, CPSR <== NOT EXECUTED 30007c30: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED 30007c34: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c38: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c3c: e5952094 ldr r2, [r5, #148] ; 0x94 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c40: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c44: e3520000 cmp r2, #0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
30007c48: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
30007c4c: 1a000098 bne 30007eb4 <rtems_termios_ioctl+0x3a4> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007c50: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
30007c54: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c58: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED 30007c5c: 0a000008 beq 30007c84 <rtems_termios_ioctl+0x174> <== NOT EXECUTED 30007c60: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED 30007c64: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED 30007c68: 1a000005 bne 30007c84 <rtems_termios_ioctl+0x174> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
30007c6c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c70: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED 30007c74: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
30007c78: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c7c: e3c33002 bic r3, r3, #2 <== NOT EXECUTED 30007c80: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
30007c84: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007c88: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 30007c8c: 05952038 ldreq r2, [r5, #56] ; 0x38 <== NOT EXECUTED 30007c90: 0a000012 beq 30007ce0 <rtems_termios_ioctl+0x1d0> <== NOT EXECUTED 30007c94: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED 30007c98: e3520000 cmp r2, #0 <== NOT EXECUTED 30007c9c: ba000078 blt 30007e84 <rtems_termios_ioctl+0x374> <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
30007ca0: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007ca4: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED 30007ca8: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
30007cac: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cb0: e3130004 tst r3, #4 <== NOT EXECUTED 30007cb4: 0a000006 beq 30007cd4 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED 30007cb8: e59530b0 ldr r3, [r5, #176] ; 0xb0 <== NOT EXECUTED 30007cbc: e3530000 cmp r3, #0 <== NOT EXECUTED 30007cc0: 0a000003 beq 30007cd4 <rtems_termios_ioctl+0x1c4> <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
30007cc4: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007cc8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ccc: e12fff13 bx r3 <== NOT EXECUTED 30007cd0: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
30007cd4: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cd8: e3c33004 bic r3, r3, #4 <== NOT EXECUTED 30007cdc: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
30007ce0: e3520000 cmp r2, #0 <== NOT EXECUTED 30007ce4: ba000066 blt 30007e84 <rtems_termios_ioctl+0x374> <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
30007ce8: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
30007cec: e595803c ldr r8, [r5, #60] ; 0x3c <== NOT EXECUTED
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
30007cf0: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
30007cf4: 159520b8 ldrne r2, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007cf8: 13822b01 orrne r2, r2, #1024 ; 0x400 <== NOT EXECUTED 30007cfc: 158520b8 strne r2, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
30007d00: e3130b01 tst r3, #1024 ; 0x400 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
30007d04: 159530b8 ldrne r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007d08: 13833c02 orrne r3, r3, #512 ; 0x200 <== NOT EXECUTED 30007d0c: 158530b8 strne r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
30007d10: e2188002 ands r8, r8, #2 <== NOT EXECUTED 30007d14: 0a000048 beq 30007e3c <rtems_termios_ioctl+0x32c> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007d18: e3a03000 mov r3, #0 <== NOT EXECUTED 30007d1c: e585306c str r3, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30007d20: e5853070 str r3, [r5, #112] ; 0x70 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007d24: e5853074 str r3, [r5, #116] ; 0x74 <== NOT EXECUTED
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
30007d28: e59530a8 ldr r3, [r5, #168] ; 0xa8 <== NOT EXECUTED 30007d2c: e3530000 cmp r3, #0 <== NOT EXECUTED 30007d30: 0affff90 beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
30007d34: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007d38: e1a01007 mov r1, r7 <== NOT EXECUTED 30007d3c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007d40: e12fff13 bx r3 <== NOT EXECUTED 30007d44: eaffff8b b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
30007d48: e5952060 ldr r2, [r5, #96] ; 0x60 <== NOT EXECUTED 30007d4c: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007d50: e5950020 ldr r0, [r5, #32] <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
30007d54: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
30007d58: 45952064 ldrmi r2, [r5, #100] ; 0x64 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007d5c: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
30007d60: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
30007d64: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED 30007d68: e0622000 rsb r2, r2, r0 <== NOT EXECUTED 30007d6c: e0823003 add r3, r2, r3 <== NOT EXECUTED 30007d70: e5813000 str r3, [r1] <== NOT EXECUTED
}
break;
30007d74: eaffff7f b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007d78: e3530001 cmp r3, #1 <== NOT EXECUTED 30007d7c: 1affff88 bne 30007ba4 <rtems_termios_ioctl+0x94> <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
30007d80: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED
30007d84: e285c030 add ip, r5, #48 ; 0x30 <== NOT EXECUTED
30007d88: e1a0e007 mov lr, r7 <== NOT EXECUTED
30007d8c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d90: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d94: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d98: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
30007d9c: e59c3000 ldr r3, [ip] <== NOT EXECUTED
30007da0: e58e3000 str r3, [lr] <== NOT EXECUTED
break;
30007da4: eaffff73 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
30007da8: e59f212c ldr r2, [pc, #300] ; 30007edc <rtems_termios_ioctl+0x3cc><== NOT EXECUTED 30007dac: e1530002 cmp r3, r2 <== NOT EXECUTED 30007db0: 0a000019 beq 30007e1c <rtems_termios_ioctl+0x30c> <== NOT EXECUTED 30007db4: e2822105 add r2, r2, #1073741825 ; 0x40000001 <== NOT EXECUTED 30007db8: e1530002 cmp r3, r2 <== NOT EXECUTED 30007dbc: 1affff78 bne 30007ba4 <rtems_termios_ioctl+0x94> <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
30007dc0: e59f7110 ldr r7, [pc, #272] ; 30007ed8 <rtems_termios_ioctl+0x3c8><== NOT EXECUTED 30007dc4: e59530cc ldr r3, [r5, #204] ; 0xcc <== NOT EXECUTED 30007dc8: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED 30007dcc: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED 30007dd0: e3530000 cmp r3, #0 <== NOT EXECUTED 30007dd4: 0a000003 beq 30007de8 <rtems_termios_ioctl+0x2d8> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
30007dd8: e1a00005 mov r0, r5 <== NOT EXECUTED 30007ddc: e1a0e00f mov lr, pc <== NOT EXECUTED 30007de0: e12fff13 bx r3 <== NOT EXECUTED 30007de4: e1a06000 mov r6, r0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
30007de8: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30007dec: e5932000 ldr r2, [r3] <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
30007df0: e3a03000 mov r3, #0 <== NOT EXECUTED 30007df4: e58530d0 str r3, [r5, #208] ; 0xd0 <== NOT EXECUTED
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
30007df8: e7973282 ldr r3, [r7, r2, lsl #5] <== NOT EXECUTED
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
30007dfc: e58520cc str r2, [r5, #204] ; 0xcc <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
30007e00: e3530000 cmp r3, #0 <== NOT EXECUTED 30007e04: 0affff5b beq 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
30007e08: e1a00005 mov r0, r5 <== NOT EXECUTED 30007e0c: e1a0e00f mov lr, pc <== NOT EXECUTED 30007e10: e12fff13 bx r3 <== NOT EXECUTED 30007e14: e1a06000 mov r6, r0 <== NOT EXECUTED 30007e18: eaffff56 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
30007e1c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 30007e20: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED 30007e24: e5832000 str r2, [r3] <== NOT EXECUTED
break;
30007e28: eaffff52 b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
30007e2c: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
30007e30: e58520d4 str r2, [r5, #212] ; 0xd4 <== NOT EXECUTED
30007e34: e58530d8 str r3, [r5, #216] ; 0xd8 <== NOT EXECUTED
break;
30007e38: eaffff4e b 30007b78 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
30007e3c: e5d5a046 ldrb sl, [r5, #70] ; 0x46 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
30007e40: eb00059b bl 300094b4 <rtems_clock_get_ticks_per_second> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
30007e44: e000009a mul r0, sl, r0 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
30007e48: e59f3090 ldr r3, [pc, #144] ; 30007ee0 <rtems_termios_ioctl+0x3d0><== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
30007e4c: e5d52046 ldrb r2, [r5, #70] ; 0x46 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
30007e50: e0831390 umull r1, r3, r0, r3 <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
30007e54: e3520000 cmp r2, #0 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
30007e58: e1a031a3 lsr r3, r3, #3 <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
30007e5c: e5853054 str r3, [r5, #84] ; 0x54 <== NOT EXECUTED
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
30007e60: 0a00000b beq 30007e94 <rtems_termios_ioctl+0x384> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
30007e64: e5d52047 ldrb r2, [r5, #71] ; 0x47 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007e68: e585806c str r8, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007e6c: e3520000 cmp r2, #0 <== NOT EXECUTED 30007e70: 01a02003 moveq r2, r3 <== NOT EXECUTED 30007e74: 13a02000 movne r2, #0 <== NOT EXECUTED
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
30007e78: e5853070 str r3, [r5, #112] ; 0x70 <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007e7c: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED 30007e80: eaffffa8 b 30007d28 <rtems_termios_ioctl+0x218> <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
30007e84: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007e88: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED 30007e8c: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED 30007e90: eaffff94 b 30007ce8 <rtems_termios_ioctl+0x1d8> <== NOT EXECUTED
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
30007e94: e5d53047 ldrb r3, [r5, #71] ; 0x47 <== NOT EXECUTED 30007e98: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
30007e9c: 03a03001 moveq r3, #1 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
30007ea0: 1585206c strne r2, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
30007ea4: 15852070 strne r2, [r5, #112] ; 0x70 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
30007ea8: 15852074 strne r2, [r5, #116] ; 0x74 <== NOT EXECUTED
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
30007eac: 0585306c streq r3, [r5, #108] ; 0x6c <== NOT EXECUTED 30007eb0: eaffff9c b 30007d28 <rtems_termios_ioctl+0x218> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
30007eb4: e5953084 ldr r3, [r5, #132] ; 0x84 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(
30007eb8: e595107c ldr r1, [r5, #124] ; 0x7c <== NOT EXECUTED 30007ebc: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED 30007ec0: e0811003 add r1, r1, r3 <== NOT EXECUTED 30007ec4: e3a02001 mov r2, #1 <== NOT EXECUTED 30007ec8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007ecc: e595f0a4 ldr pc, [r5, #164] ; 0xa4 <== NOT EXECUTED 30007ed0: eaffff5e b 30007c50 <rtems_termios_ioctl+0x140> <== NOT EXECUTED
300095bc <rtems_termios_number_to_baud>:
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
300095bc: e92d4010 push {r4, lr} <== NOT EXECUTED
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
300095c0: e1a01000 mov r1, r0 <== NOT EXECUTED
extern rtems_assoc_t termios_assoc_table[];
int rtems_termios_number_to_baud(
int32_t baud
)
{
300095c4: e1a04000 mov r4, r0 <== NOT EXECUTED
int termios_baud;
termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud );
300095c8: e59f001c ldr r0, [pc, #28] ; 300095ec <rtems_termios_number_to_baud+0x30><== NOT EXECUTED 300095cc: eb001cc9 bl 300108f8 <rtems_assoc_remote_by_local> <== NOT EXECUTED
if ( termios_baud == 0 && baud != 0 )
300095d0: e2703001 rsbs r3, r0, #1 <== NOT EXECUTED 300095d4: 33a03000 movcc r3, #0 <== NOT EXECUTED 300095d8: e3540000 cmp r4, #0 <== NOT EXECUTED 300095dc: 03a03000 moveq r3, #0 <== NOT EXECUTED 300095e0: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
return termios_baud;
}
300095e4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
300095e8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
30007484 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30007484: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30007488: e59f7468 ldr r7, [pc, #1128] ; 300078f8 <rtems_termios_open+0x474>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
3000748c: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
30007490: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
30007494: e24dd018 sub sp, sp, #24 30007498: e1a05000 mov r5, r0 3000749c: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300074a0: e5970000 ldr r0, [r7] 300074a4: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
300074a8: e58d3010 str r3, [sp, #16]
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
300074ac: eb0009a8 bl 30009b54 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
300074b0: e250a000 subs sl, r0, #0
300074b4: 1a000021 bne 30007540 <rtems_termios_open+0xbc>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
300074b8: e59fb43c ldr fp, [pc, #1084] ; 300078fc <rtems_termios_open+0x478> 300074bc: e59b9000 ldr r9, [fp] 300074c0: e3590000 cmp r9, #0
300074c4: 0a00002d beq 30007580 <rtems_termios_open+0xfc>
300074c8: e1a04009 mov r4, r9 300074cc: ea000002 b 300074dc <rtems_termios_open+0x58>
300074d0: e5944000 ldr r4, [r4] <== NOT EXECUTED 300074d4: e3540000 cmp r4, #0 <== NOT EXECUTED 300074d8: 0a000028 beq 30007580 <rtems_termios_open+0xfc> <== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
300074dc: e594300c ldr r3, [r4, #12] 300074e0: e1530005 cmp r3, r5
300074e4: 1afffff9 bne 300074d0 <rtems_termios_open+0x4c>
300074e8: e5943010 ldr r3, [r4, #16] 300074ec: e1530006 cmp r3, r6
300074f0: 1afffff6 bne 300074d0 <rtems_termios_open+0x4c>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
300074f4: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
300074f8: e5981000 ldr r1, [r8]
if (!tty->refcount++) {
300074fc: e2832001 add r2, r3, #1 30007500: e3530000 cmp r3, #0
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
30007504: e5814034 str r4, [r1, #52] ; 0x34
if (!tty->refcount++) {
30007508: e5842008 str r2, [r4, #8]
3000750c: 1a000009 bne 30007538 <rtems_termios_open+0xb4>
if (tty->device.firstOpen)
30007510: e5943098 ldr r3, [r4, #152] ; 0x98 30007514: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
30007518: 11a00005 movne r0, r5 3000751c: 11a01006 movne r1, r6 30007520: 11a02008 movne r2, r8 30007524: 11a0e00f movne lr, pc 30007528: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000752c: e59430b4 ldr r3, [r4, #180] ; 0xb4 30007530: e3530002 cmp r3, #2
30007534: 0a000004 beq 3000754c <rtems_termios_open+0xc8>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
30007538: e5970000 ldr r0, [r7] 3000753c: eb0009cd bl 30009c78 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
30007540: e1a0000a mov r0, sl
30007544: e28dd018 add sp, sp, #24
30007548: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(
3000754c: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED 30007550: e59f13a8 ldr r1, [pc, #936] ; 30007900 <rtems_termios_open+0x47c><== NOT EXECUTED 30007554: e1a02004 mov r2, r4 <== NOT EXECUTED 30007558: eb000a9a bl 30009fc8 <rtems_task_start> <== NOT EXECUTED
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
3000755c: e3500000 cmp r0, #0 <== NOT EXECUTED 30007560: 1a0000ca bne 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
30007564: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED 30007568: e59f1394 ldr r1, [pc, #916] ; 30007904 <rtems_termios_open+0x480><== NOT EXECUTED 3000756c: e1a02004 mov r2, r4 <== NOT EXECUTED 30007570: eb000a94 bl 30009fc8 <rtems_task_start> <== NOT EXECUTED
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
30007574: e3500000 cmp r0, #0 <== NOT EXECUTED 30007578: 0affffee beq 30007538 <rtems_termios_open+0xb4> <== NOT EXECUTED 3000757c: ea0000c3 b 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007580: e3a00001 mov r0, #1 30007584: e3a010e8 mov r1, #232 ; 0xe8 30007588: ebfffb55 bl 300062e4 <calloc>
if (tty == NULL) {
3000758c: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
30007590: e58d0014 str r0, [sp, #20] 30007594: e1a04000 mov r4, r0
if (tty == NULL) {
30007598: 0a0000a8 beq 30007840 <rtems_termios_open+0x3bc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
3000759c: e59f0364 ldr r0, [pc, #868] ; 30007908 <rtems_termios_open+0x484> 300075a0: e59d1014 ldr r1, [sp, #20] 300075a4: e5903000 ldr r3, [r0] 300075a8: e5813064 str r3, [r1, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
300075ac: e5910064 ldr r0, [r1, #100] ; 0x64 300075b0: ebfffc92 bl 30006800 <malloc> 300075b4: e59d2014 ldr r2, [sp, #20]
if (tty->rawInBuf.theBuf == NULL) {
300075b8: e3500000 cmp r0, #0
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
300075bc: e1a03000 mov r3, r0 300075c0: e5820058 str r0, [r2, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
300075c4: 0a0000a1 beq 30007850 <rtems_termios_open+0x3cc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
300075c8: e59fe338 ldr lr, [pc, #824] ; 30007908 <rtems_termios_open+0x484> 300075cc: e59d0014 ldr r0, [sp, #20] 300075d0: e59e2004 ldr r2, [lr, #4] 300075d4: e5802088 str r2, [r0, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
300075d8: e5900088 ldr r0, [r0, #136] ; 0x88 300075dc: e58d3008 str r3, [sp, #8] 300075e0: ebfffc86 bl 30006800 <malloc> 300075e4: e59de014 ldr lr, [sp, #20]
if (tty->rawOutBuf.theBuf == NULL) {
300075e8: e3500000 cmp r0, #0
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
300075ec: e1a02000 mov r2, r0 300075f0: e58e007c str r0, [lr, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
300075f4: e59d3008 ldr r3, [sp, #8]
300075f8: 0a00008c beq 30007830 <rtems_termios_open+0x3ac>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
300075fc: e59f1304 ldr r1, [pc, #772] ; 30007908 <rtems_termios_open+0x484> 30007600: e5910008 ldr r0, [r1, #8] 30007604: e58d200c str r2, [sp, #12] 30007608: e58d3008 str r3, [sp, #8] 3000760c: ebfffc7b bl 30006800 <malloc> 30007610: e59de014 ldr lr, [sp, #20]
if (tty->cbuf == NULL) {
30007614: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
30007618: e58e001c str r0, [lr, #28]
if (tty->cbuf == NULL) {
3000761c: e59d200c ldr r2, [sp, #12]
30007620: 0a00007f beq 30007824 <rtems_termios_open+0x3a0>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30007624: e59d0014 ldr r0, [sp, #20] 30007628: e3a03000 mov r3, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
3000762c: e5803004 str r3, [r0, #4]
if (rtems_termios_ttyHead != NULL)
30007630: e1590003 cmp r9, r3
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
30007634: e58030d4 str r3, [r0, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
30007638: e58030d8 str r3, [r0, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
3000763c: e58030dc str r3, [r0, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
30007640: e58030e0 str r3, [r0, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
30007644: e58030e4 str r3, [r0, #228] ; 0xe4
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
30007648: e59f32bc ldr r3, [pc, #700] ; 3000790c <rtems_termios_open+0x488>
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
3000764c: 15890004 strne r0, [r9, #4]
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
30007650: e5932000 ldr r2, [r3]
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
30007654: e59d1014 ldr r1, [sp, #20]
if (rtems_termios_ttyTail == NULL)
30007658: e3520000 cmp r2, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
3000765c: e59f22a4 ldr r2, [pc, #676] ; 30007908 <rtems_termios_open+0x484>
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
30007660: 05831000 streq r1, [r3]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
30007664: e5809000 str r9, [r0]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
30007668: e5d2300c ldrb r3, [r2, #12]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
3000766c: e59de014 ldr lr, [sp, #20] 30007670: e59f0298 ldr r0, [pc, #664] ; 30007910 <rtems_termios_open+0x48c>
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
30007674: e58b1000 str r1, [fp]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
30007678: e28ec014 add ip, lr, #20 3000767c: e1830000 orr r0, r3, r0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
30007680: e58e6010 str r6, [lr, #16]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
30007684: e3a03000 mov r3, #0
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
30007688: e58e500c str r5, [lr, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
3000768c: e3a01001 mov r1, #1 30007690: e3a02054 mov r2, #84 ; 0x54 30007694: e58dc000 str ip, [sp] 30007698: eb000893 bl 300098ec <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
3000769c: e2503000 subs r3, r0, #0
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
300076a0: e59f9260 ldr r9, [pc, #608] ; 30007908 <rtems_termios_open+0x484>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
300076a4: 1a000079 bne 30007890 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
300076a8: e5d9200c ldrb r2, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
300076ac: e59d1014 ldr r1, [sp, #20] 300076b0: e59f025c ldr r0, [pc, #604] ; 30007914 <rtems_termios_open+0x490> 300076b4: e281c018 add ip, r1, #24 300076b8: e1820000 orr r0, r2, r0 300076bc: e3a01001 mov r1, #1 300076c0: e3a02054 mov r2, #84 ; 0x54 300076c4: e58dc000 str ip, [sp] 300076c8: eb000887 bl 300098ec <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
300076cc: e2501000 subs r1, r0, #0
300076d0: 1a00006e bne 30007890 <rtems_termios_open+0x40c>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
300076d4: e5d9300c ldrb r3, [r9, #12]
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
300076d8: e59d2014 ldr r2, [sp, #20] 300076dc: e59f0234 ldr r0, [pc, #564] ; 30007918 <rtems_termios_open+0x494> 300076e0: e282c08c add ip, r2, #140 ; 0x8c 300076e4: e1830000 orr r0, r3, r0 300076e8: e3a02020 mov r2, #32 300076ec: e1a03001 mov r3, r1 300076f0: e58dc000 str ip, [sp] 300076f4: eb00087c bl 300098ec <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
300076f8: e250b000 subs fp, r0, #0
300076fc: 1a000063 bne 30007890 <rtems_termios_open+0x40c>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
30007700: e59d3014 ldr r3, [sp, #20]
30007704: e59dc010 ldr ip, [sp, #16]
30007708: e283e098 add lr, r3, #152 ; 0x98
3000770c: e8bc000f ldm ip!, {r0, r1, r2, r3}
30007710: e8ae000f stmia lr!, {r0, r1, r2, r3}
30007714: e89c000f ldm ip, {r0, r1, r2, r3}
30007718: e88e000f stm lr, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
3000771c: e59de014 ldr lr, [sp, #20] 30007720: e59e30b4 ldr r3, [lr, #180] ; 0xb4
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
30007724: e58eb094 str fp, [lr, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
30007728: e3530002 cmp r3, #2
3000772c: 0a000058 beq 30007894 <rtems_termios_open+0x410>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
30007730: e59d2014 ldr r2, [sp, #20] 30007734: e59230a0 ldr r3, [r2, #160] ; 0xa0 30007738: e3530000 cmp r3, #0
3000773c: 0a000046 beq 3000785c <rtems_termios_open+0x3d8>
30007740: e59230b4 ldr r3, [r2, #180] ; 0xb4 30007744: e3530002 cmp r3, #2
30007748: 0a000043 beq 3000785c <rtems_termios_open+0x3d8>
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
3000774c: e59de014 ldr lr, [sp, #20]
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
30007750: e3a03000 mov r3, #0
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
30007754: e58e30b8 str r3, [lr, #184] ; 0xb8
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
30007758: e59f01a8 ldr r0, [pc, #424] ; 30007908 <rtems_termios_open+0x484>
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
3000775c: e59ec064 ldr ip, [lr, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
30007760: e59e1064 ldr r1, [lr, #100] ; 0x64
/*
* Bump name characer
*/
if (c++ == 'z')
30007764: e5d0200c ldrb r2, [r0, #12]
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
30007768: e0811081 add r1, r1, r1, lsl #1
/*
* Bump name characer
*/
if (c++ == 'z')
3000776c: e352007a cmp r2, #122 ; 0x7a
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
30007770: e1a00121 lsr r0, r1, #2
/*
* Bump name characer
*/
if (c++ == 'z')
30007774: e2821001 add r1, r2, #1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007778: e59f219c ldr r2, [pc, #412] ; 3000791c <rtems_termios_open+0x498>
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
3000777c: e5ce304c strb r3, [lr, #76] ; 0x4c
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
30007780: e58e2030 str r2, [lr, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
30007784: e59f2194 ldr r2, [pc, #404] ; 30007920 <rtems_termios_open+0x49c>
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
30007788: e5ce3051 strb r3, [lr, #81] ; 0x51
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
3000778c: e58e2034 str r2, [lr, #52] ; 0x34
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
30007790: e59f218c ldr r2, [pc, #396] ; 30007924 <rtems_termios_open+0x4a0>
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
30007794: e3a03011 mov r3, #17
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
30007798: e58e2038 str r2, [lr, #56] ; 0x38
tty->termios.c_lflag =
3000779c: e59f2184 ldr r2, [pc, #388] ; 30007928 <rtems_termios_open+0x4a4>
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
300077a0: e5ce3049 strb r3, [lr, #73] ; 0x49
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
300077a4: e58e203c str r2, [lr, #60] ; 0x3c
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
300077a8: e3a03013 mov r3, #19
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
300077ac: e3a02003 mov r2, #3 300077b0: e5ce2041 strb r2, [lr, #65] ; 0x41
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
300077b4: e5ce304a strb r3, [lr, #74] ; 0x4a
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
300077b8: e3a0201c mov r2, #28
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
300077bc: e3a0301a mov r3, #26
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
300077c0: e5ce2042 strb r2, [lr, #66] ; 0x42
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
300077c4: e5ce304b strb r3, [lr, #75] ; 0x4b
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
300077c8: e3a0207f mov r2, #127 ; 0x7f
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
300077cc: e3a03012 mov r3, #18
tty->termios.c_lflag =
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
300077d0: e5ce2043 strb r2, [lr, #67] ; 0x43
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
300077d4: e5ce304d strb r3, [lr, #77] ; 0x4d
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
300077d8: e3a02015 mov r2, #21
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
300077dc: e3a0300f mov r3, #15
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
300077e0: e5ce2044 strb r2, [lr, #68] ; 0x44
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
300077e4: e5ce304e strb r3, [lr, #78] ; 0x4e
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
300077e8: e3a02004 mov r2, #4
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
300077ec: e3a03017 mov r3, #23
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
300077f0: e5ce2045 strb r2, [lr, #69] ; 0x45
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
300077f4: e5ce304f strb r3, [lr, #79] ; 0x4f
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
300077f8: e59f2108 ldr r2, [pc, #264] ; 30007908 <rtems_termios_open+0x484>
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
300077fc: e3a03016 mov r3, #22 30007800: e5ce3050 strb r3, [lr, #80] ; 0x50
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30007804: 059f30fc ldreq r3, [pc, #252] ; 30007908 <rtems_termios_open+0x484>
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
30007808: e5c2100c strb r1, [r2, #12]
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
3000780c: e1a0c0ac lsr ip, ip, #1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
30007810: 03a02061 moveq r2, #97 ; 0x61
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
30007814: e58ec0bc str ip, [lr, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4;
30007818: e58e00c0 str r0, [lr, #192] ; 0xc0
/*
* Bump name characer
*/
if (c++ == 'z')
c = 'a';
3000781c: 05c3200c strbeq r2, [r3, #12] 30007820: eaffff33 b 300074f4 <rtems_termios_open+0x70>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
30007824: e1a00002 mov r0, r2 <== NOT EXECUTED 30007828: ebfffb1a bl 30006498 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
3000782c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 30007830: e1a00003 mov r0, r3 <== NOT EXECUTED 30007834: ebfffb17 bl 30006498 <free> <== NOT EXECUTED
free(tty);
30007838: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 3000783c: ebfffb15 bl 30006498 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
30007840: e5970000 ldr r0, [r7] <== NOT EXECUTED 30007844: eb00090b bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
30007848: e3a0a01a mov sl, #26 <== NOT EXECUTED 3000784c: eaffff3b b 30007540 <rtems_termios_open+0xbc> <== NOT EXECUTED
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
30007850: e1a00002 mov r0, r2 <== NOT EXECUTED 30007854: ebfffb0f bl 30006498 <free> <== NOT EXECUTED 30007858: eafffff8 b 30007840 <rtems_termios_open+0x3bc> <== NOT EXECUTED
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
3000785c: e59fe0a4 ldr lr, [pc, #164] ; 30007908 <rtems_termios_open+0x484><== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
30007860: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
30007864: e5de300c ldrb r3, [lr, #12] <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
30007868: e59f00bc ldr r0, [pc, #188] ; 3000792c <rtems_termios_open+0x4a8><== NOT EXECUTED 3000786c: e3a01000 mov r1, #0 <== NOT EXECUTED 30007870: e282c068 add ip, r2, #104 ; 0x68 <== NOT EXECUTED 30007874: e1830000 orr r0, r3, r0 <== NOT EXECUTED 30007878: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED 3000787c: e1a03001 mov r3, r1 <== NOT EXECUTED 30007880: e58dc000 str ip, [sp] <== NOT EXECUTED 30007884: eb000818 bl 300098ec <rtems_semaphore_create> <== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
30007888: e3500000 cmp r0, #0 <== NOT EXECUTED 3000788c: 0affffae beq 3000774c <rtems_termios_open+0x2c8> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007890: eb000a56 bl 3000a1f0 <rtems_fatal_error_occurred>
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
30007894: e5d9300c ldrb r3, [r9, #12] <== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
30007898: e59f0090 ldr r0, [pc, #144] ; 30007930 <rtems_termios_open+0x4ac><== NOT EXECUTED
3000789c: e28ec0c8 add ip, lr, #200 ; 0xc8 <== NOT EXECUTED
300078a0: e1830000 orr r0, r3, r0 <== NOT EXECUTED
300078a4: e3a0100a mov r1, #10 <== NOT EXECUTED
300078a8: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
300078ac: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
300078b0: e88d1800 stm sp, {fp, ip} <== NOT EXECUTED
300078b4: eb000919 bl 30009d20 <rtems_task_create> <== NOT EXECUTED
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
300078b8: e250e000 subs lr, r0, #0 <== NOT EXECUTED 300078bc: 1afffff3 bne 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
300078c0: e5d9300c ldrb r3, [r9, #12] <== NOT EXECUTED
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
300078c4: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 300078c8: e59f0064 ldr r0, [pc, #100] ; 30007934 <rtems_termios_open+0x4b0><== NOT EXECUTED 300078cc: e281c0c4 add ip, r1, #196 ; 0xc4 <== NOT EXECUTED 300078d0: e1830000 orr r0, r3, r0 <== NOT EXECUTED 300078d4: e3a01009 mov r1, #9 <== NOT EXECUTED 300078d8: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED 300078dc: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED 300078e0: e58de000 str lr, [sp] <== NOT EXECUTED 300078e4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 300078e8: eb00090c bl 30009d20 <rtems_task_create> <== NOT EXECUTED
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
300078ec: e3500000 cmp r0, #0 <== NOT EXECUTED 300078f0: 0affff8e beq 30007730 <rtems_termios_open+0x2ac> <== NOT EXECUTED 300078f4: eaffffe5 b 30007890 <rtems_termios_open+0x40c> <== NOT EXECUTED
30007ee4 <rtems_termios_puts>:
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007ee4: e59230b4 ldr r3, [r2, #180] ; 0xb4
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007ee8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007eec: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
30007ef0: e1a04002 mov r4, r2 30007ef4: e1a0a000 mov sl, r0 30007ef8: e1a08001 mov r8, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
30007efc: 0a000038 beq 30007fe4 <rtems_termios_puts+0x100>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30007f00: e3510000 cmp r1, #0 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
30007f04: e5927080 ldr r7, [r2, #128] ; 0x80 <== NOT EXECUTED
while (len) {
30007f08: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
30007f0c: e3a06002 mov r6, #2 <== NOT EXECUTED
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
30007f10: e3a09001 mov r9, #1 <== NOT EXECUTED
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
30007f14: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 30007f18: e2870001 add r0, r7, #1 <== NOT EXECUTED 30007f1c: eb00328a bl 3001494c <__umodsi3> <== NOT EXECUTED 30007f20: e1a07000 mov r7, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007f24: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007f28: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007f2c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
30007f30: e5945084 ldr r5, [r4, #132] ; 0x84 <== NOT EXECUTED 30007f34: e1550000 cmp r5, r0 <== NOT EXECUTED 30007f38: 1a00000d bne 30007f74 <rtems_termios_puts+0x90> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
30007f3c: e5846094 str r6, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007f40: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
30007f44: e3a01000 mov r1, #0 <== NOT EXECUTED 30007f48: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30007f4c: e1a02001 mov r2, r1 <== NOT EXECUTED 30007f50: eb0006ff bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
30007f54: e3500000 cmp r0, #0 <== NOT EXECUTED 30007f58: 1a000027 bne 30007ffc <rtems_termios_puts+0x118> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30007f5c: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30007f60: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30007f64: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
30007f68: e5942084 ldr r2, [r4, #132] ; 0x84 <== NOT EXECUTED 30007f6c: e1520005 cmp r2, r5 <== NOT EXECUTED 30007f70: 0afffff1 beq 30007f3c <rtems_termios_puts+0x58> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
30007f74: e4da1001 ldrb r1, [sl], #1 <== NOT EXECUTED
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
30007f78: e1a05003 mov r5, r3 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
30007f7c: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED 30007f80: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 30007f84: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
30007f88: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
30007f8c: e5847080 str r7, [r4, #128] ; 0x80 <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
30007f90: e3530000 cmp r3, #0 <== NOT EXECUTED 30007f94: 1a000006 bne 30007fb4 <rtems_termios_puts+0xd0> <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
30007f98: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007f9c: e3130010 tst r3, #16 <== NOT EXECUTED 30007fa0: 0a000007 beq 30007fc4 <rtems_termios_puts+0xe0> <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
30007fa4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30007fa8: e3833020 orr r3, r3, #32 <== NOT EXECUTED 30007fac: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
30007fb0: e5849094 str r9, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30007fb4: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
30007fb8: e2588001 subs r8, r8, #1 <== NOT EXECUTED
30007fbc: 1affffd4 bne 30007f14 <rtems_termios_puts+0x30> <== NOT EXECUTED
30007fc0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
30007fc4: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
30007fc8: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED 30007fcc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30007fd0: e0811003 add r1, r1, r3 <== NOT EXECUTED 30007fd4: e3a02001 mov r2, #1 <== NOT EXECUTED 30007fd8: e1a0e00f mov lr, pc <== NOT EXECUTED 30007fdc: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 30007fe0: eafffff2 b 30007fb0 <rtems_termios_puts+0xcc> <== NOT EXECUTED
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
30007fe4: e5920010 ldr r0, [r2, #16] 30007fe8: e1a0100a mov r1, sl 30007fec: e1a02008 mov r2, r8 30007ff0: e1a0e00f mov lr, pc 30007ff4: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
30007ff8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
30007ffc: eb00087b bl 3000a1f0 <rtems_fatal_error_occurred> <== NOT EXECUTED
30008718 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008718: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3000871c: e5903000 ldr r3, [r0] <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008720: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30008724: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
30008728: e1a09000 mov r9, r0 <== NOT EXECUTED 3000872c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008730: e1a02001 mov r2, r1 <== NOT EXECUTED 30008734: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
30008738: e5998010 ldr r8, [r9, #16] <== NOT EXECUTED
char *buffer = args->buffer;
3000873c: e599a00c ldr sl, [r9, #12] <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008740: eb000503 bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
30008744: e3500000 cmp r0, #0 <== NOT EXECUTED 30008748: e58d0000 str r0, [sp] <== NOT EXECUTED 3000874c: 1a00000e bne 3000878c <rtems_termios_read+0x74> <== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
30008750: e59420cc ldr r2, [r4, #204] ; 0xcc <== NOT EXECUTED 30008754: e59f3364 ldr r3, [pc, #868] ; 30008ac0 <rtems_termios_read+0x3a8><== NOT EXECUTED 30008758: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED 3000875c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED 30008760: e3530000 cmp r3, #0 <== NOT EXECUTED 30008764: 0a00000b beq 30008798 <rtems_termios_read+0x80> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
30008768: e1a00004 mov r0, r4 <== NOT EXECUTED 3000876c: e1a01009 mov r1, r9 <== NOT EXECUTED 30008770: e1a0e00f mov lr, pc <== NOT EXECUTED 30008774: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008778: e3a03000 mov r3, #0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
3000877c: e58d0000 str r0, [sp] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008780: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
30008784: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED 30008788: eb00053a bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
3000878c: e59d0000 ldr r0, [sp] <== NOT EXECUTED
30008790: e28dd008 add sp, sp, #8 <== NOT EXECUTED
30008794: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
30008798: e5942024 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED 3000879c: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 300087a0: e1520003 cmp r2, r3 <== NOT EXECUTED 300087a4: 0a000018 beq 3000880c <rtems_termios_read+0xf4> <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300087a8: e3580000 cmp r8, #0 <== NOT EXECUTED 300087ac: 0a00000e beq 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED 300087b0: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 300087b4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 300087b8: e1530002 cmp r3, r2 <== NOT EXECUTED 300087bc: ba000003 blt 300087d0 <rtems_termios_read+0xb8> <== NOT EXECUTED 300087c0: ea000009 b 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED 300087c4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 300087c8: e1520003 cmp r2, r3 <== NOT EXECUTED 300087cc: da000006 ble 300087ec <rtems_termios_read+0xd4> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
300087d0: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300087d4: e2588001 subs r8, r8, #1 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
300087d8: e7d22003 ldrb r2, [r2, r3] <== NOT EXECUTED 300087dc: e2833001 add r3, r3, #1 <== NOT EXECUTED 300087e0: e4ca2001 strb r2, [sl], #1 <== NOT EXECUTED 300087e4: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
300087e8: 1afffff5 bne 300087c4 <rtems_termios_read+0xac> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087ec: e5993010 ldr r3, [r9, #16] <== NOT EXECUTED
tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem);
300087f0: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087f4: e0688003 rsb r8, r8, r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
300087f8: e3a03000 mov r3, #0 <== NOT EXECUTED
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
300087fc: e5898018 str r8, [r9, #24] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
30008800: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
30008804: eb00051b bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
return sc;
30008808: eaffffdf b 3000878c <rtems_termios_read+0x74> <== NOT EXECUTED
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
3000880c: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
30008810: e59d1000 ldr r1, [sp] <== NOT EXECUTED
tty->read_start_column = tty->column;
30008814: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
if (tty->device.pollRead != NULL &&
30008818: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
3000881c: e5841020 str r1, [r4, #32] <== NOT EXECUTED 30008820: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
tty->read_start_column = tty->column;
30008824: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
if (tty->device.pollRead != NULL &&
30008828: 0a000002 beq 30008838 <rtems_termios_read+0x120> <== NOT EXECUTED 3000882c: e59420b4 ldr r2, [r4, #180] ; 0xb4 <== NOT EXECUTED 30008830: e3520000 cmp r2, #0 <== NOT EXECUTED 30008834: 0a000065 beq 300089d0 <rtems_termios_read+0x2b8> <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
30008838: e2843049 add r3, r4, #73 ; 0x49 <== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
3000883c: e5946074 ldr r6, [r4, #116] ; 0x74 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
30008840: e59f727c ldr r7, [pc, #636] ; 30008ac4 <rtems_termios_read+0x3ac><== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30008844: e59fb27c ldr fp, [pc, #636] ; 30008ac8 <rtems_termios_read+0x3b0><== NOT EXECUTED
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
30008848: e3a05001 mov r5, #1 <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
3000884c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008850: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30008854: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 30008858: e1520003 cmp r2, r3 <== NOT EXECUTED 3000885c: 0a000046 beq 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008860: e5972008 ldr r2, [r7, #8] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008864: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
30008868: e2422001 sub r2, r2, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3000886c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008870: ca00000f bgt 300088b4 <rtems_termios_read+0x19c> <== NOT EXECUTED 30008874: ea000040 b 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
30008878: e1a00006 mov r0, r6 <== NOT EXECUTED 3000887c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008880: ebffff59 bl 300085ec <siproc> <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008884: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 30008888: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
3000888c: e3500000 cmp r0, #0 <== NOT EXECUTED 30008890: 13a05000 movne r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008894: e1520003 cmp r2, r3 <== NOT EXECUTED
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
30008898: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3000889c: 0a000036 beq 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
300088a0: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300088a4: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
300088a8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
300088ac: e1520003 cmp r2, r3 <== NOT EXECUTED 300088b0: aa000031 bge 3000897c <rtems_termios_read+0x264> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
300088b4: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 300088b8: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED 300088bc: e2800001 add r0, r0, #1 <== NOT EXECUTED 300088c0: eb003021 bl 3001494c <__umodsi3> <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
300088c4: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED 300088c8: e7d36000 ldrb r6, [r3, r0] <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
300088cc: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
300088d0: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED 300088d4: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
% tty->rawInBuf.Size)
300088d8: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
300088dc: e0823003 add r3, r2, r3 <== NOT EXECUTED
% tty->rawInBuf.Size)
300088e0: e0600003 rsb r0, r0, r3 <== NOT EXECUTED 300088e4: eb003018 bl 3001494c <__umodsi3> <== NOT EXECUTED
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
300088e8: e59430bc ldr r3, [r4, #188] ; 0xbc <== NOT EXECUTED 300088ec: e1500003 cmp r0, r3 <== NOT EXECUTED 300088f0: 2a000012 bcs 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
300088f4: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
300088f8: e59f31c8 ldr r3, [pc, #456] ; 30008ac8 <rtems_termios_read+0x3b0><== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
tty->rawInBuf.Head = newHead;
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
300088fc: e3c22001 bic r2, r2, #1 <== NOT EXECUTED 30008900: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
30008904: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008908: e0023003 and r3, r2, r3 <== NOT EXECUTED 3000890c: e153000b cmp r3, fp <== NOT EXECUTED 30008910: 0a000022 beq 300089a0 <rtems_termios_read+0x288> <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
30008914: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008918: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000891c: 0a000007 beq 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
30008920: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
30008924: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
30008928: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
3000892c: e3530000 cmp r3, #0 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
30008930: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
30008934: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED 30008938: 11a0e00f movne lr, pc <== NOT EXECUTED 3000893c: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
30008940: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED 30008944: e3130002 tst r3, #2 <== NOT EXECUTED 30008948: 1affffca bne 30008878 <rtems_termios_read+0x160> <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
3000894c: e1a00006 mov r0, r6 <== NOT EXECUTED 30008950: e1a01004 mov r1, r4 <== NOT EXECUTED 30008954: ebffff24 bl 300085ec <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30008958: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 3000895c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
30008960: e5946070 ldr r6, [r4, #112] ; 0x70 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
30008964: e1520003 cmp r2, r3 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008968: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED 3000896c: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if (siproc (c, tty))
wait = 0;
} else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
30008970: a3a05000 movge r5, #0 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
30008974: e1520003 cmp r2, r3 <== NOT EXECUTED 30008978: 1affffc8 bne 300088a0 <rtems_termios_read+0x188> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
3000897c: e3550000 cmp r5, #0 <== NOT EXECUTED 30008980: 0affff88 beq 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
sc = rtems_semaphore_obtain(
30008984: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 30008988: e594106c ldr r1, [r4, #108] ; 0x6c <== NOT EXECUTED 3000898c: e1a02006 mov r2, r6 <== NOT EXECUTED 30008990: eb00046f bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
30008994: e3500000 cmp r0, #0 <== NOT EXECUTED 30008998: 0affffac beq 30008850 <rtems_termios_read+0x138> <== NOT EXECUTED 3000899c: eaffff81 b 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
300089a0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED 300089a4: e3530000 cmp r3, #0 <== NOT EXECUTED 300089a8: 0a000002 beq 300089b8 <rtems_termios_read+0x2a0> <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
300089ac: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 300089b0: e3130020 tst r3, #32 <== NOT EXECUTED 300089b4: 0affffd6 beq 30008914 <rtems_termios_read+0x1fc> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
300089b8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300089bc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 300089c0: e3a02001 mov r2, #1 <== NOT EXECUTED 300089c4: e1a0e00f mov lr, pc <== NOT EXECUTED 300089c8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED 300089cc: eaffffdb b 30008940 <rtems_termios_read+0x228> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
300089d0: e594203c ldr r2, [r4, #60] ; 0x3c <== NOT EXECUTED 300089d4: e3120002 tst r2, #2 <== NOT EXECUTED 300089d8: 0a00000b beq 30008a0c <rtems_termios_read+0x2f4> <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
300089dc: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 300089e0: e1a0e00f mov lr, pc <== NOT EXECUTED 300089e4: e12fff13 bx r3 <== NOT EXECUTED
if (n < 0) {
300089e8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
300089ec: e1a01004 mov r1, r4 <== NOT EXECUTED 300089f0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
300089f4: ba00002d blt 30008ab0 <rtems_termios_read+0x398> <== NOT EXECUTED
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
300089f8: ebfffefb bl 300085ec <siproc> <== NOT EXECUTED 300089fc: e3500000 cmp r0, #0 <== NOT EXECUTED 30008a00: 1affff68 bne 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30008a04: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED 30008a08: eafffff3 b 300089dc <rtems_termios_read+0x2c4> <== NOT EXECUTED
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
30008a0c: eb0002b0 bl 300094d4 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED 30008a10: e1a05000 mov r5, r0 <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
30008a14: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008a18: e1a0e00f mov lr, pc <== NOT EXECUTED 30008a1c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (n < 0) {
30008a20: e3500000 cmp r0, #0 <== NOT EXECUTED 30008a24: ba00000c blt 30008a5c <rtems_termios_read+0x344> <== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
30008a28: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED 30008a2c: e1a01004 mov r1, r4 <== NOT EXECUTED 30008a30: ebfffeed bl 300085ec <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
30008a34: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 30008a38: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED 30008a3c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008a40: aaffff58 bge 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
30008a44: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a48: 0afffff1 beq 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED 30008a4c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a50: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a54: 0affffee beq 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED 30008a58: eaffffeb b 30008a0c <rtems_termios_read+0x2f4> <== NOT EXECUTED
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
30008a5c: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED 30008a60: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a64: 0a000008 beq 30008a8c <rtems_termios_read+0x374> <== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
30008a68: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a6c: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a70: 0a000002 beq 30008a80 <rtems_termios_read+0x368> <== NOT EXECUTED 30008a74: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 30008a78: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a7c: 1a000005 bne 30008a98 <rtems_termios_read+0x380> <== NOT EXECUTED
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
30008a80: e3a00001 mov r0, #1 <== NOT EXECUTED 30008a84: eb000569 bl 3000a030 <rtems_task_wake_after> <== NOT EXECUTED 30008a88: eaffffe1 b 30008a14 <rtems_termios_read+0x2fc> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
30008a8c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED 30008a90: e3530000 cmp r3, #0 <== NOT EXECUTED 30008a94: 0affff43 beq 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
30008a98: eb00028d bl 300094d4 <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
30008a9c: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED 30008aa0: e0650000 rsb r0, r5, r0 <== NOT EXECUTED 30008aa4: e1500003 cmp r0, r3 <== NOT EXECUTED 30008aa8: 9afffff4 bls 30008a80 <rtems_termios_read+0x368> <== NOT EXECUTED 30008aac: eaffff3d b 300087a8 <rtems_termios_read+0x90> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
30008ab0: e3a00001 mov r0, #1 <== NOT EXECUTED 30008ab4: eb00055d bl 3000a030 <rtems_task_wake_after> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
30008ab8: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED 30008abc: eaffffc6 b 300089dc <rtems_termios_read+0x2c4> <== NOT EXECUTED
30008e54 <rtems_termios_refill_transmitter>:
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
30008e54: e59020b8 ldr r2, [r0, #184] ; 0xb8 <== NOT EXECUTED 30008e58: e59f31f4 ldr r3, [pc, #500] ; 30009054 <rtems_termios_refill_transmitter+0x200><== NOT EXECUTED
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
30008e5c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
30008e60: e0023003 and r3, r2, r3 <== NOT EXECUTED 30008e64: e59f21ec ldr r2, [pc, #492] ; 30009058 <rtems_termios_refill_transmitter+0x204><== NOT EXECUTED
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
30008e68: e1a04000 mov r4, r0 <== NOT EXECUTED
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
30008e6c: e1530002 cmp r3, r2 <== NOT EXECUTED 30008e70: 0a000048 beq 30008f98 <rtems_termios_refill_transmitter+0x144><== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
30008e74: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED 30008e78: e2033003 and r3, r3, #3 <== NOT EXECUTED 30008e7c: e3530002 cmp r3, #2 <== NOT EXECUTED 30008e80: 0a000056 beq 30008fe0 <rtems_termios_refill_transmitter+0x18c><== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
30008e84: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED 30008e88: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED 30008e8c: e1520003 cmp r2, r3 <== NOT EXECUTED 30008e90: 0a00002a beq 30008f40 <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008e94: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008e98: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008e9c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
30008ea0: e3a02000 mov r2, #0 <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
30008ea4: e5900090 ldr r0, [r0, #144] ; 0x90 <== NOT EXECUTED
tty->t_dqlen = 0;
30008ea8: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008eac: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
30008eb0: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 30008eb4: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 30008eb8: e0800003 add r0, r0, r3 <== NOT EXECUTED 30008ebc: eb002ea2 bl 3001494c <__umodsi3> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30008ec0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
30008ec4: e1a05000 mov r5, r0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
30008ec8: e3530002 cmp r3, #2 <== NOT EXECUTED
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
30008ecc: e5840084 str r0, [r4, #132] ; 0x84 <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
30008ed0: 0a00002d beq 30008f8c <rtems_termios_refill_transmitter+0x138><== NOT EXECUTED
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
30008ed4: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED 30008ed8: e1530005 cmp r3, r5 <== NOT EXECUTED 30008edc: 0a00001f beq 30008f60 <rtems_termios_refill_transmitter+0x10c><== NOT EXECUTED
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
30008ee0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED 30008ee4: e2033e21 and r3, r3, #528 ; 0x210 <== NOT EXECUTED 30008ee8: e3530e21 cmp r3, #528 ; 0x210 <== NOT EXECUTED 30008eec: 0a00004d beq 30009028 <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008ef0: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(
30008ef4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
30008ef8: e1550003 cmp r5, r3 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
30008efc: 85946088 ldrhi r6, [r4, #136] ; 0x88 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
30008f00: 95946080 ldrls r6, [r4, #128] ; 0x80 <== NOT EXECUTED
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
30008f04: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
30008f08: 80656006 rsbhi r6, r5, r6 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
30008f0c: 90656006 rsbls r6, r5, r6 <== NOT EXECUTED
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
30008f10: e3130c06 tst r3, #1536 ; 0x600 <== NOT EXECUTED 30008f14: 13a06001 movne r6, #1 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
30008f18: e3a03001 mov r3, #1 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
30008f1c: e1a02006 mov r2, r6 <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy; /*apm*/
30008f20: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
(*tty->device.write)(
30008f24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008f28: e0811005 add r1, r1, r5 <== NOT EXECUTED 30008f2c: e1a0e00f mov lr, pc <== NOT EXECUTED 30008f30: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
30008f34: e5845084 str r5, [r4, #132] ; 0x84 <== NOT EXECUTED
} return nToSend; }
30008f38: e1a00006 mov r0, r6 <== NOT EXECUTED
30008f3c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30008f40: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED 30008f44: e3530002 cmp r3, #2 <== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
30008f48: 13a06000 movne r6, #0 <== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
30008f4c: 1afffff9 bne 30008f38 <rtems_termios_refill_transmitter+0xe4><== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30008f50: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED 30008f54: eb000347 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
}
return 0;
30008f58: e3a06000 mov r6, #0 <== NOT EXECUTED 30008f5c: eafffff5 b 30008f38 <rtems_termios_refill_transmitter+0xe4><== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f60: e59430d4 ldr r3, [r4, #212] ; 0xd4 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30008f64: e3a06000 mov r6, #0 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f68: e1530006 cmp r3, r6 <== NOT EXECUTED
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
30008f6c: e5846094 str r6, [r4, #148] ; 0x94 <== NOT EXECUTED
nToSend = 0;
30008f70: 01a06003 moveq r6, r3 <== NOT EXECUTED
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
30008f74: 0affffee beq 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
30008f78: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED 30008f7c: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED 30008f80: e1a0e00f mov lr, pc <== NOT EXECUTED 30008f84: e12fff13 bx r3 <== NOT EXECUTED 30008f88: eaffffe9 b 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
30008f8c: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED 30008f90: eb000338 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED 30008f94: eaffffce b 30008ed4 <rtems_termios_refill_transmitter+0x80><== NOT EXECUTED
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
30008f98: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED 30008f9c: e3a02001 mov r2, #1 <== NOT EXECUTED 30008fa0: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30008fa4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008fa8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008fac: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008fb0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008fb4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fb8: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fbc: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fc0: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fc4: e3822002 orr r2, r2, #2 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30008fc8: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
30008fcc: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30008fd0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
30008fd4: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30008fd8: e1a00006 mov r0, r6 <== NOT EXECUTED
30008fdc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
30008fe0: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED 30008fe4: e3a02001 mov r2, #1 <== NOT EXECUTED 30008fe8: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 30008fec: e1a0e00f mov lr, pc <== NOT EXECUTED 30008ff0: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30008ff4: e10f3000 mrs r3, CPSR <== NOT EXECUTED 30008ff8: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30008ffc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009000: e5941090 ldr r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30009004: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009008: e2411001 sub r1, r1, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3000900c: e3c22002 bic r2, r2, #2 <== NOT EXECUTED
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
30009010: e5841090 str r1, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
30009014: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009018: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
3000901c: e3a06001 mov r6, #1 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
30009020: e1a00006 mov r0, r6 <== NOT EXECUTED
30009024: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
30009028: e10f3000 mrs r3, CPSR <== NOT EXECUTED 3000902c: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED 30009030: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
30009034: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED 30009038: e3822020 orr r2, r2, #32 <== NOT EXECUTED 3000903c: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
30009040: e3a02001 mov r2, #1 <== NOT EXECUTED 30009044: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
30009048: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
3000904c: e3a06000 mov r6, #0 <== NOT EXECUTED 30009050: eaffffb7 b 30008f34 <rtems_termios_refill_transmitter+0xe0><== NOT EXECUTED
30008dc8 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
30008dc8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30008dcc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
30008dd0: e1a04000 mov r4, r0 <== NOT EXECUTED
30008dd4: e28d7007 add r7, sp, #7 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008dd8: e3a06000 mov r6, #0 <== NOT EXECUTED 30008ddc: ea000005 b 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008de0: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008de4: e1a0e00f mov lr, pc <== NOT EXECUTED 30008de8: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
30008dec: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008df0: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
30008df4: 1a000010 bne 30008e3c <rtems_termios_rxdaemon+0x74> <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30008df8: e1a0300d mov r3, sp <== NOT EXECUTED 30008dfc: e3a01002 mov r1, #2 <== NOT EXECUTED 30008e00: e3a02000 mov r2, #0 <== NOT EXECUTED 30008e04: e3a00003 mov r0, #3 <== NOT EXECUTED 30008e08: eb0001d1 bl 30009554 <rtems_event_receive> <== NOT EXECUTED
(TERMIOS_RX_PROC_EVENT | TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
30008e0c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 30008e10: e3130001 tst r3, #1 <== NOT EXECUTED 30008e14: 0afffff1 beq 30008de0 <rtems_termios_rxdaemon+0x18> <== NOT EXECUTED
tty->rxTaskId = 0;
30008e18: e58460c4 str r6, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
30008e1c: e1a00006 mov r0, r6 <== NOT EXECUTED 30008e20: eb00040d bl 30009e5c <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008e24: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 30008e28: e1a0e00f mov lr, pc <== NOT EXECUTED 30008e2c: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
30008e30: e3700001 cmn r0, #1 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
30008e34: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
30008e38: 0affffee beq 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
30008e3c: e1a00004 mov r0, r4 <== NOT EXECUTED 30008e40: e1a01007 mov r1, r7 <== NOT EXECUTED 30008e44: e3a02001 mov r2, #1 <== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
30008e48: e5cd3007 strb r3, [sp, #7] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
30008e4c: ebffff21 bl 30008ad8 <rtems_termios_enqueue_raw_characters><== NOT EXECUTED 30008e50: eaffffe8 b 30008df8 <rtems_termios_rxdaemon+0x30> <== NOT EXECUTED
30008acc <rtems_termios_rxirq_occured>:
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
30008acc: e59000c4 ldr r0, [r0, #196] ; 0xc4 <== NOT EXECUTED 30008ad0: e3a01002 mov r1, #2 <== NOT EXECUTED 30008ad4: ea0002fb b 300096c8 <rtems_event_send> <== NOT EXECUTED
3000b32c <rtems_termios_set_initial_baud>:
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *ttyp,
int32_t baud
)
{
3000b32c: e92d4010 push {r4, lr} <== NOT EXECUTED
3000b330: e1a04000 mov r4, r0 <== NOT EXECUTED
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
3000b334: e1a00001 mov r0, r1 <== NOT EXECUTED 3000b338: ebfff89f bl 300095bc <rtems_termios_number_to_baud> <== NOT EXECUTED
if ( cflags_baud == -1 )
3000b33c: e3700001 cmn r0, #1 <== NOT EXECUTED
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b340: 15942038 ldrne r2, [r4, #56] ; 0x38 <== NOT EXECUTED
int32_t baud
)
{
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
3000b344: e1a03000 mov r3, r0 <== NOT EXECUTED
if ( cflags_baud == -1 )
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b348: 13c22a01 bicne r2, r2, #4096 ; 0x1000 <== NOT EXECUTED 3000b34c: 13c2200f bicne r2, r2, #15 <== NOT EXECUTED 3000b350: 11833002 orrne r3, r3, r2 <== NOT EXECUTED
return 0;
3000b354: 13a00000 movne r0, #0 <== NOT EXECUTED
cflags_baud = rtems_termios_number_to_baud(baud);
if ( cflags_baud == -1 )
return -1;
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
3000b358: 15843038 strne r3, [r4, #56] ; 0x38 <== NOT EXECUTED
{
int cflags_baud;
cflags_baud = rtems_termios_number_to_baud(baud);
if ( cflags_baud == -1 )
return -1;
3000b35c: 01a00003 moveq r0, r3 <== NOT EXECUTED
ttyp->termios.c_cflag = (ttyp->termios.c_cflag & ~CBAUD) | cflags_baud;
return 0;
}
3000b360: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000905c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
3000905c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
30009060: e59f6060 ldr r6, [pc, #96] ; 300090c8 <rtems_termios_txdaemon+0x6c><== NOT EXECUTED
30009064: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
30009068: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
3000906c: e3a07000 mov r7, #0 <== NOT EXECUTED 30009070: ea000008 b 30009098 <rtems_termios_txdaemon+0x3c> <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
30009074: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30009078: e1a00004 mov r0, r4 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
3000907c: e0863283 add r3, r6, r3, lsl #5 <== NOT EXECUTED 30009080: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED 30009084: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
30009088: 11a0e00f movne lr, pc <== NOT EXECUTED 3000908c: 112fff13 bxne r3 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
30009090: e1a00004 mov r0, r4 <== NOT EXECUTED 30009094: ebffff6e bl 30008e54 <rtems_termios_refill_transmitter> <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
30009098: e1a0300d mov r3, sp <== NOT EXECUTED 3000909c: e3a01002 mov r1, #2 <== NOT EXECUTED 300090a0: e3a02000 mov r2, #0 <== NOT EXECUTED 300090a4: e3a00003 mov r0, #3 <== NOT EXECUTED 300090a8: eb000129 bl 30009554 <rtems_event_receive> <== NOT EXECUTED
(TERMIOS_TX_START_EVENT | TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event
);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
300090ac: e59d3000 ldr r3, [sp] <== NOT EXECUTED 300090b0: e3130001 tst r3, #1 <== NOT EXECUTED 300090b4: 0affffee beq 30009074 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
tty->txTaskId = 0;
300090b8: e58470c8 str r7, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
300090bc: e1a00007 mov r0, r7 <== NOT EXECUTED 300090c0: eb000365 bl 30009e5c <rtems_task_delete> <== NOT EXECUTED 300090c4: eaffffea b 30009074 <rtems_termios_txdaemon+0x18> <== NOT EXECUTED
30008648 <rtems_termios_write>:
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
30008648: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
3000864c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
30008650: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008654: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
30008658: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3000865c: e1a02001 mov r2, r1 30008660: e5940018 ldr r0, [r4, #24] 30008664: eb00053a bl 30009b54 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
30008668: e2506000 subs r6, r0, #0
3000866c: 1a00000c bne 300086a4 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
30008670: e59420cc ldr r2, [r4, #204] ; 0xcc 30008674: e59f3098 ldr r3, [pc, #152] ; 30008714 <rtems_termios_write+0xcc> 30008678: e0833282 add r3, r3, r2, lsl #5 3000867c: e593300c ldr r3, [r3, #12] 30008680: e3530000 cmp r3, #0
30008684: 0a000008 beq 300086ac <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
30008688: e1a00004 mov r0, r4 <== NOT EXECUTED 3000868c: e1a01005 mov r1, r5 <== NOT EXECUTED 30008690: e1a0e00f mov lr, pc <== NOT EXECUTED 30008694: e12fff13 bx r3 <== NOT EXECUTED 30008698: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
3000869c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 300086a0: eb000574 bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
}
rtems_semaphore_release (tty->osem);
return sc;
}
300086a4: e1a00006 mov r0, r6 <== NOT EXECUTED
300086a8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
300086ac: e5943034 ldr r3, [r4, #52] ; 0x34 300086b0: e3130001 tst r3, #1
300086b4: 0a000011 beq 30008700 <rtems_termios_write+0xb8>
uint32_t count = args->count;
300086b8: e5958010 ldr r8, [r5, #16]
char *buffer = args->buffer;
300086bc: e595a00c ldr sl, [r5, #12]
while (count--)
300086c0: e3580000 cmp r8, #0 300086c4: 01a03006 moveq r3, r6
300086c8: 0a000007 beq 300086ec <rtems_termios_write+0xa4>
300086cc: e1a07006 mov r7, r6
oproc (*buffer++, tty);
300086d0: e7da0007 ldrb r0, [sl, r7] 300086d4: e1a01004 mov r1, r4 300086d8: e2877001 add r7, r7, #1 300086dc: ebfffe47 bl 30008000 <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
300086e0: e1570008 cmp r7, r8
300086e4: 1afffff9 bne 300086d0 <rtems_termios_write+0x88>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
300086e8: e5953010 ldr r3, [r5, #16] 300086ec: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
300086f0: e5940018 ldr r0, [r4, #24] 300086f4: eb00055f bl 30009c78 <rtems_semaphore_release>
return sc; }
300086f8: e1a00006 mov r0, r6
300086fc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
30008700: e595000c ldr r0, [r5, #12] <== NOT EXECUTED 30008704: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 30008708: e1a02004 mov r2, r4 <== NOT EXECUTED 3000870c: ebfffdf4 bl 30007ee4 <rtems_termios_puts> <== NOT EXECUTED 30008710: eafffff4 b 300086e8 <rtems_termios_write+0xa0> <== NOT EXECUTED
3000a524 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a524: e92d4070 push {r4, r5, r6, lr}
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a528: e2504000 subs r4, r0, #0
rtems_status_code rtems_timer_create(
rtems_name name,
rtems_id *id
)
{
3000a52c: e1a05001 mov r5, r1
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
3000a530: 03a00003 moveq r0, #3
rtems_id *id
)
{
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
3000a534: 08bd8070 popeq {r4, r5, r6, pc}
return RTEMS_INVALID_NAME;
if ( !id )
3000a538: e3510000 cmp r1, #0
3000a53c: 0a00001b beq 3000a5b0 <rtems_timer_create+0x8c>
3000a540: e59f3070 ldr r3, [pc, #112] ; 3000a5b8 <rtems_timer_create+0x94> 3000a544: e5932000 ldr r2, [r3] 3000a548: e2822001 add r2, r2, #1 3000a54c: e5832000 str r2, [r3]
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Allocate( void )
{
return (Timer_Control *) _Objects_Allocate( &_Timer_Information );
3000a550: e59f6064 ldr r6, [pc, #100] ; 3000a5bc <rtems_timer_create+0x98> 3000a554: e1a00006 mov r0, r6 3000a558: eb0003c6 bl 3000b478 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
3000a55c: e3500000 cmp r0, #0
3000a560: 0a00000f beq 3000a5a4 <rtems_timer_create+0x80>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
3000a564: e5903008 ldr r3, [r0, #8]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a568: e596201c ldr r2, [r6, #28]
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
3000a56c: e1a01803 lsl r1, r3, #16
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a570: e3a06000 mov r6, #0
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
3000a574: e3a0c004 mov ip, #4 3000a578: e580c038 str ip, [r0, #56] ; 0x38 3000a57c: e5806018 str r6, [r0, #24]
the_watchdog->routine = routine;
3000a580: e580602c str r6, [r0, #44] ; 0x2c
the_watchdog->id = id;
3000a584: e5806030 str r6, [r0, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a588: e5806034 str r6, [r0, #52] ; 0x34
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
3000a58c: e7820721 str r0, [r2, r1, lsr #14]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
3000a590: e580400c str r4, [r0, #12]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
3000a594: e5853000 str r3, [r5]
_Thread_Enable_dispatch();
3000a598: eb000814 bl 3000c5f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a59c: e1a00006 mov r0, r6
3000a5a0: e8bd8070 pop {r4, r5, r6, pc}
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
3000a5a4: eb000811 bl 3000c5f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_TOO_MANY;
3000a5a8: e3a00005 mov r0, #5 <== NOT EXECUTED
3000a5ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !id )
return RTEMS_INVALID_ADDRESS;
3000a5b0: e3a00009 mov r0, #9 <== NOT EXECUTED
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
3000a5b4: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a5c0 <rtems_timer_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a5c0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a5c4: e2516000 subs r6, r1, #0
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3000a5c8: e1a05000 mov r5, r0 3000a5cc: e24dd004 sub sp, sp, #4 3000a5d0: e1a04002 mov r4, r2 3000a5d4: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
3000a5d8: 03a0000a moveq r0, #10
{
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
3000a5dc: 0a000020 beq 3000a664 <rtems_timer_fire_after+0xa4>
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a5e0: e3520000 cmp r2, #0
return RTEMS_INVALID_ADDRESS;
3000a5e4: 03a00009 moveq r0, #9
ISR_Level level;
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
if ( !routine )
3000a5e8: 0a00001d beq 3000a664 <rtems_timer_fire_after+0xa4>
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
_Objects_Get( &_Timer_Information, id, location );
3000a5ec: e59f0088 ldr r0, [pc, #136] ; 3000a67c <rtems_timer_fire_after+0xbc> 3000a5f0: e1a01005 mov r1, r5 3000a5f4: e1a0200d mov r2, sp 3000a5f8: eb0004cf bl 3000b93c <_Objects_Get>
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a5fc: e59d3000 ldr r3, [sp] 3000a600: e1a08000 mov r8, r0 3000a604: e3530000 cmp r3, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3000a608: 13a00004 movne r0, #4
if ( !routine )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3000a60c: 1a000014 bne 3000a664 <rtems_timer_fire_after+0xa4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3000a610: e288a010 add sl, r8, #16 3000a614: e1a0000a mov r0, sl 3000a618: eb000bdd bl 3000d594 <_Watchdog_Remove>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3000a61c: e10f2000 mrs r2, CPSR 3000a620: e3823080 orr r3, r2, #128 ; 0x80 3000a624: e129f003 msr CPSR_fc, r3
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
3000a628: e5983018 ldr r3, [r8, #24] 3000a62c: e3530000 cmp r3, #0
3000a630: 1a00000d bne 3000a66c <rtems_timer_fire_after+0xac>
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL;
3000a634: e5883038 str r3, [r8, #56] ; 0x38
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3000a638: e5883018 str r3, [r8, #24]
the_watchdog->routine = routine;
3000a63c: e588402c str r4, [r8, #44] ; 0x2c
the_watchdog->id = id;
3000a640: e5885030 str r5, [r8, #48] ; 0x30
the_watchdog->user_data = user_data;
3000a644: e5887034 str r7, [r8, #52] ; 0x34
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3000a648: e129f002 msr CPSR_fc, r2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a64c: e59f002c ldr r0, [pc, #44] ; 3000a680 <rtems_timer_fire_after+0xc0> 3000a650: e1a0100a mov r1, sl
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3000a654: e588601c str r6, [r8, #28]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
3000a658: eb000b5e bl 3000d3d8 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
3000a65c: eb0007e3 bl 3000c5f0 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3000a660: e3a00000 mov r0, #0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3000a664: e28dd004 add sp, sp, #4
3000a668: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
3000a66c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3000a670: eb0007de bl 3000c5f0 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3000a674: e3a00000 mov r0, #0 <== NOT EXECUTED 3000a678: eafffff9 b 3000a664 <rtems_timer_fire_after+0xa4> <== NOT EXECUTED
3001a0f4 <rtems_timer_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a0f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3001a0f8: e1a05000 mov r5, r0
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a0fc: e59f00d0 ldr r0, [pc, #208] ; 3001a1d4 <rtems_timer_fire_when+0xe0>
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a100: e24dd004 sub sp, sp, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a104: e5d0c000 ldrb ip, [r0]
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a108: e1a06001 mov r6, r1
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a10c: e35c0000 cmp ip, #0
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a110: e1a04002 mov r4, r2 3001a114: e1a07003 mov r7, r3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
3001a118: 03a0000b moveq r0, #11
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
3001a11c: 1a000001 bne 3001a128 <rtems_timer_fire_when+0x34>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a120: e28dd004 add sp, sp, #4
3001a124: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_interval seconds;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
3001a128: e1a00001 mov r0, r1 3001a12c: ebfff4b6 bl 3001740c <_TOD_Validate> 3001a130: e3500000 cmp r0, #0
3001a134: 0a000009 beq 3001a160 <rtems_timer_fire_when+0x6c>
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001a138: e3540000 cmp r4, #0
return RTEMS_INVALID_ADDRESS;
3001a13c: 03a00009 moveq r0, #9
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
if ( !routine )
3001a140: 0afffff6 beq 3001a120 <rtems_timer_fire_when+0x2c>
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001a144: e1a00006 mov r0, r6 3001a148: ebfff484 bl 30017360 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a14c: e59f8084 ldr r8, [pc, #132] ; 3001a1d8 <rtems_timer_fire_when+0xe4>
return RTEMS_INVALID_CLOCK;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
3001a150: e1a06000 mov r6, r0
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a154: e5983000 ldr r3, [r8] 3001a158: e1500003 cmp r0, r3
3001a15c: 8a000001 bhi 3001a168 <rtems_timer_fire_when+0x74>
return RTEMS_INVALID_CLOCK;
3001a160: e3a00014 mov r0, #20 <== NOT EXECUTED 3001a164: eaffffed b 3001a120 <rtems_timer_fire_when+0x2c> <== NOT EXECUTED
3001a168: e59f006c ldr r0, [pc, #108] ; 3001a1dc <rtems_timer_fire_when+0xe8> 3001a16c: e1a01005 mov r1, r5 3001a170: e1a0200d mov r2, sp 3001a174: eb000b2c bl 3001ce2c <_Objects_Get>
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a178: e59da000 ldr sl, [sp] 3001a17c: e1a09000 mov r9, r0 3001a180: e35a0000 cmp sl, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a184: 13a00004 movne r0, #4
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a188: 1affffe4 bne 3001a120 <rtems_timer_fire_when+0x2c>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a18c: e289b010 add fp, r9, #16 3001a190: e1a0000b mov r0, fp 3001a194: eb001329 bl 3001ee40 <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
3001a198: e5983000 ldr r3, [r8]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a19c: e59f003c ldr r0, [pc, #60] ; 3001a1e0 <rtems_timer_fire_when+0xec> 3001a1a0: e0636006 rsb r6, r3, r6
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY;
3001a1a4: e3a03002 mov r3, #2 3001a1a8: e5893038 str r3, [r9, #56] ; 0x38 3001a1ac: e1a0100b mov r1, fp
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a1b0: e589a018 str sl, [r9, #24]
the_watchdog->routine = routine;
3001a1b4: e589402c str r4, [r9, #44] ; 0x2c
the_watchdog->id = id;
3001a1b8: e5895030 str r5, [r9, #48] ; 0x30
the_watchdog->user_data = user_data;
3001a1bc: e5897034 str r7, [r9, #52] ; 0x34
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
3001a1c0: e589601c str r6, [r9, #28]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
3001a1c4: eb0012ae bl 3001ec84 <_Watchdog_Insert>
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch()
);
_Thread_Enable_dispatch();
3001a1c8: eb000e66 bl 3001db68 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
3001a1cc: e1a0000a mov r0, sl 3001a1d0: eaffffd2 b 3001a120 <rtems_timer_fire_when+0x2c>
3001a1e4 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001a1e4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001a1e8: e2514000 subs r4, r1, #0 <== NOT EXECUTED
rtems_status_code rtems_timer_get_information(
rtems_id id,
rtems_timer_information *the_info
)
{
3001a1ec: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3001a1f0: e1a01000 mov r1, r0 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
3001a1f4: 03a00009 moveq r0, #9 <== NOT EXECUTED
)
{
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
3001a1f8: 0a00000e beq 3001a238 <rtems_timer_get_information+0x54> <== NOT EXECUTED 3001a1fc: e59f003c ldr r0, [pc, #60] ; 3001a240 <rtems_timer_get_information+0x5c><== NOT EXECUTED 3001a200: e1a0200d mov r2, sp <== NOT EXECUTED 3001a204: eb000b08 bl 3001ce2c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a208: e59d5000 ldr r5, [sp] <== NOT EXECUTED 3001a20c: e3550000 cmp r5, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a210: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( !the_info )
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a214: 1a000007 bne 3001a238 <rtems_timer_get_information+0x54> <== NOT EXECUTED
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001a218: e590c038 ldr ip, [r0, #56] ; 0x38 <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
3001a21c: e590101c ldr r1, [r0, #28] <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
3001a220: e5902024 ldr r2, [r0, #36] ; 0x24 <== NOT EXECUTED
the_info->stop_time = the_timer->Ticker.stop_time;
3001a224: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
3001a228: e584c000 str ip, [r4] <== NOT EXECUTED
the_info->initial = the_timer->Ticker.initial;
3001a22c: e984000e stmib r4, {r1, r2, r3} <== NOT EXECUTED
the_info->start_time = the_timer->Ticker.start_time;
the_info->stop_time = the_timer->Ticker.stop_time;
_Thread_Enable_dispatch();
3001a230: eb000e4c bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a234: e1a00005 mov r0, r5 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a238: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a23c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3001a8ec <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
3001a8ec: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a8f0: e3500000 cmp r0, #0 <== NOT EXECUTED
3001a8f4: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
3001a8f8: e1a06001 mov r6, r1 <== NOT EXECUTED
3001a8fc: e1a08002 mov r8, r2 <== NOT EXECUTED
3001a900: 0a00004a beq 3001aa30 <rtems_timer_initiate_server+0x144> <== NOT EXECUTED
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
3001a904: e59f313c ldr r3, [pc, #316] ; 3001aa48 <rtems_timer_initiate_server+0x15c><== NOT EXECUTED 3001a908: e5d33000 ldrb r3, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
3001a90c: e1500003 cmp r0, r3 <== NOT EXECUTED 3001a910: 9a00004a bls 3001aa40 <rtems_timer_initiate_server+0x154> <== NOT EXECUTED
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
3001a914: e3700001 cmn r0, #1 <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
_priority = 0;
3001a918: 03a07000 moveq r7, #0 <== NOT EXECUTED
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
3001a91c: 1a000043 bne 3001aa30 <rtems_timer_initiate_server+0x144> <== NOT EXECUTED 3001a920: e59f3124 ldr r3, [pc, #292] ; 3001aa4c <rtems_timer_initiate_server+0x160><== NOT EXECUTED 3001a924: e5932000 ldr r2, [r3] <== NOT EXECUTED 3001a928: e2822001 add r2, r2, #1 <== NOT EXECUTED 3001a92c: e5832000 str r2, [r3] <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001a930: e59f4118 ldr r4, [pc, #280] ; 3001aa50 <rtems_timer_initiate_server+0x164><== NOT EXECUTED
initialized = true;
3001a934: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
3001a938: e5d45000 ldrb r5, [r4] <== NOT EXECUTED
initialized = true;
3001a93c: e5c43000 strb r3, [r4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a940: eb000c88 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
if ( tmpInitialized )
3001a944: e3550000 cmp r5, #0 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
3001a948: 13a0300e movne r3, #14 <== NOT EXECUTED
_Thread_Disable_dispatch();
tmpInitialized = initialized;
initialized = true;
_Thread_Enable_dispatch();
if ( tmpInitialized )
3001a94c: 1a000038 bne 3001aa34 <rtems_timer_initiate_server+0x148> <== NOT EXECUTED
* other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create(
3001a950: e388c902 orr ip, r8, #32768 ; 0x8000 <== NOT EXECUTED 3001a954: e3a03c01 mov r3, #256 ; 0x100 <== NOT EXECUTED 3001a958: e58dc000 str ip, [sp] <== NOT EXECUTED 3001a95c: e59f00f0 ldr r0, [pc, #240] ; 3001aa54 <rtems_timer_initiate_server+0x168><== NOT EXECUTED 3001a960: e28dc008 add ip, sp, #8 <== NOT EXECUTED 3001a964: e1a01007 mov r1, r7 <== NOT EXECUTED 3001a968: e1a02006 mov r2, r6 <== NOT EXECUTED 3001a96c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 3001a970: ebfffb0f bl 300195b4 <rtems_task_create> <== NOT EXECUTED
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
3001a974: e2503000 subs r3, r0, #0 <== NOT EXECUTED
initialized = false;
3001a978: 15c45000 strbne r5, [r4] <== NOT EXECUTED
/* user may want floating point but we need */
/* system task specified for 0 priority */
attribute_set | RTEMS_SYSTEM_TASK,
&id /* get the id back */
);
if (status) {
3001a97c: 1a00002c bne 3001aa34 <rtems_timer_initiate_server+0x148> <== NOT EXECUTED
*/
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return NULL;
#endif
return information->local_table[ index ];
3001a980: e59f20d0 ldr r2, [pc, #208] ; 3001aa58 <rtems_timer_initiate_server+0x16c><== NOT EXECUTED
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
&_RTEMS_tasks_Information,
_Objects_Get_index(id)
3001a984: e59de008 ldr lr, [sp, #8] <== NOT EXECUTED 3001a988: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 3001a98c: e1a0180e lsl r1, lr, #16 <== NOT EXECUTED
/*
* We work with the TCB pointer, not the ID, so we need to convert
* to a TCB pointer from here out.
*/
ts->thread = (Thread_Control *)_Objects_Get_local_object(
3001a990: e7922721 ldr r2, [r2, r1, lsr #14] <== NOT EXECUTED 3001a994: e1a0c004 mov ip, r4 <== NOT EXECUTED 3001a998: e5ac2004 str r2, [ip, #4]! <== NOT EXECUTED
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a99c: e59f10b8 ldr r1, [pc, #184] ; 3001aa5c <rtems_timer_initiate_server+0x170><== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9a0: e59f20b8 ldr r2, [pc, #184] ; 3001aa60 <rtems_timer_initiate_server+0x174><== NOT EXECUTED
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a9a4: e5918000 ldr r8, [r1] <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9a8: e592a000 ldr sl, [r2] <== NOT EXECUTED
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot;
3001a9ac: e5848040 str r8, [r4, #64] ; 0x40 <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
3001a9b0: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
3001a9b4: e584a078 str sl, [r4, #120] ; 0x78 <== NOT EXECUTED 3001a9b8: e5843070 str r3, [r4, #112] ; 0x70 <== NOT EXECUTED
ts->insert_chain = NULL;
3001a9bc: e584307c str r3, [r4, #124] ; 0x7c <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a9c0: e5843014 str r3, [r4, #20] <== NOT EXECUTED
ts->active = false;
3001a9c4: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001a9c8: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a9cc: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data;
3001a9d0: e5843068 str r3, [r4, #104] ; 0x68 <== NOT EXECUTED
/*
* Initialize the pointer to the timer schedule method so applications that
* do not use the Timer Server do not have to pull it in.
*/
ts->schedule_operation = _Timer_server_Schedule_operation_method;
3001a9d4: e59f3088 ldr r3, [pc, #136] ; 3001aa64 <rtems_timer_initiate_server+0x178><== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001a9d8: e59f5088 ldr r5, [pc, #136] ; 3001aa68 <rtems_timer_initiate_server+0x17c><== NOT EXECUTED 3001a9dc: e5843008 str r3, [r4, #8] <== NOT EXECUTED
ts->active = false;
/*
* The default timer server is now available.
*/
_Timer_server = ts;
3001a9e0: e59f3084 ldr r3, [pc, #132] ; 3001aa6c <rtems_timer_initiate_server+0x180><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a9e4: e2847038 add r7, r4, #56 ; 0x38 <== NOT EXECUTED 3001a9e8: e583c000 str ip, [r3] <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a9ec: e2849034 add r9, r4, #52 ; 0x34 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001a9f0: e284b070 add fp, r4, #112 ; 0x70 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001a9f4: e284606c add r6, r4, #108 ; 0x6c <== NOT EXECUTED
/*
* Start the timer server
*/
status = rtems_task_start(
3001a9f8: e1a0000e mov r0, lr <== NOT EXECUTED 3001a9fc: e59f106c ldr r1, [pc, #108] ; 3001aa70 <rtems_timer_initiate_server+0x184><== NOT EXECUTED 3001aa00: e1a0200c mov r2, ip <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001aa04: e5847034 str r7, [r4, #52] ; 0x34 <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001aa08: e584903c str r9, [r4, #60] ; 0x3c <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
3001aa0c: e584b06c str fp, [r4, #108] ; 0x6c <== NOT EXECUTED
head->previous = NULL; tail->previous = head;
3001aa10: e5846074 str r6, [r4, #116] ; 0x74 <== NOT EXECUTED 3001aa14: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
the_watchdog->id = id;
3001aa18: e584e02c str lr, [r4, #44] ; 0x2c <== NOT EXECUTED
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
3001aa1c: e5845060 str r5, [r4, #96] ; 0x60 <== NOT EXECUTED
the_watchdog->id = id;
3001aa20: e584e064 str lr, [r4, #100] ; 0x64 <== NOT EXECUTED 3001aa24: ebfffca4 bl 30019cbc <rtems_task_start> <== NOT EXECUTED 3001aa28: e1a03000 mov r3, r0 <== NOT EXECUTED
if (status) {
initialized = false;
}
#endif
return status;
3001aa2c: ea000000 b 3001aa34 <rtems_timer_initiate_server+0x148> <== NOT EXECUTED
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
return RTEMS_INVALID_PRIORITY;
3001aa30: e3a03013 mov r3, #19 <== NOT EXECUTED
initialized = false;
}
#endif
return status;
}
3001aa34: e1a00003 mov r0, r3 <== NOT EXECUTED
3001aa38: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3001aa3c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3001aa40: e1a07000 mov r7, r0 <== NOT EXECUTED
3001aa44: eaffffb5 b 3001a920 <rtems_timer_initiate_server+0x34> <== NOT EXECUTED
3001a274 <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
rtems_id id
)
{
3001a274: e92d4070 push {r4, r5, r6, lr}
3001a278: e24dd004 sub sp, sp, #4
3001a27c: e1a01000 mov r1, r0
3001a280: e1a0200d mov r2, sp
3001a284: e59f0088 ldr r0, [pc, #136] ; 3001a314 <rtems_timer_reset+0xa0>
3001a288: eb000ae7 bl 3001ce2c <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a28c: e59d4000 ldr r4, [sp] 3001a290: e1a06000 mov r6, r0 3001a294: e3540000 cmp r4, #0
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a298: 13a05004 movne r5, #4
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a29c: 1a000006 bne 3001a2bc <rtems_timer_reset+0x48>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
3001a2a0: e5905038 ldr r5, [r0, #56] ; 0x38 3001a2a4: e3550000 cmp r5, #0
3001a2a8: 0a000006 beq 3001a2c8 <rtems_timer_reset+0x54>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a2ac: e3550001 cmp r5, #1 <== NOT EXECUTED
/*
* Must be dormant or time of day timer (e.g. TIMER_DORMANT,
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
3001a2b0: 13a0500b movne r5, #11 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
3001a2b4: 0a00000b beq 3001a2e8 <rtems_timer_reset+0x74> <== NOT EXECUTED
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
3001a2b8: eb000e2a bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a2bc: e1a00005 mov r0, r5
3001a2c0: e28dd004 add sp, sp, #4
3001a2c4: e8bd8070 pop {r4, r5, r6, pc}
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
3001a2c8: e2806010 add r6, r0, #16 3001a2cc: e1a00006 mov r0, r6 3001a2d0: eb0012da bl 3001ee40 <_Watchdog_Remove>
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
3001a2d4: e59f003c ldr r0, [pc, #60] ; 3001a318 <rtems_timer_reset+0xa4> 3001a2d8: e1a01006 mov r1, r6 3001a2dc: eb001268 bl 3001ec84 <_Watchdog_Insert>
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
3001a2e0: eb000e20 bl 3001db68 <_Thread_Enable_dispatch> 3001a2e4: eafffff4 b 3001a2bc <rtems_timer_reset+0x48>
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
3001a2e8: e59f302c ldr r3, [pc, #44] ; 3001a31c <rtems_timer_reset+0xa8><== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001a2ec: e2800010 add r0, r0, #16 <== NOT EXECUTED
case OBJECTS_LOCAL:
if ( the_timer->the_class == TIMER_INTERVAL ) {
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
Timer_server_Control *timer_server = _Timer_server;
3001a2f0: e5935000 ldr r5, [r3] <== NOT EXECUTED
if ( !timer_server ) {
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
#endif
_Watchdog_Remove( &the_timer->Ticker );
3001a2f4: eb0012d1 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a2f8: e1a00005 mov r0, r5 <== NOT EXECUTED 3001a2fc: e1a01006 mov r1, r6 <== NOT EXECUTED 3001a300: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a304: e595f004 ldr pc, [r5, #4] <== NOT EXECUTED
rtems_id id
)
{
Timer_Control *the_timer;
Objects_Locations location;
rtems_status_code status = RTEMS_SUCCESSFUL;
3001a308: e1a05004 mov r5, r4 <== NOT EXECUTED
* TIMER_TIME_OF_DAY, or TIMER_TIME_OF_DAY_ON_TASK). We
* can only reset active interval timers.
*/
status = RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
3001a30c: eb000e15 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED 3001a310: eaffffe9 b 3001a2bc <rtems_timer_reset+0x48> <== NOT EXECUTED
3001a320 <rtems_timer_server_fire_after>:
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a320: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3001a324: e1a07000 mov r7, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001a328: e59f00cc ldr r0, [pc, #204] ; 3001a3fc <rtems_timer_server_fire_after+0xdc><== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a32c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server;
3001a330: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a334: e1a06001 mov r6, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001a338: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a33c: e1a05002 mov r5, r2 <== NOT EXECUTED 3001a340: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001a344: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001a348: 0a000005 beq 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001a34c: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001a350: 03a00009 moveq r0, #9 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !routine )
3001a354: 0a000002 beq 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001a358: e3510000 cmp r1, #0 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
3001a35c: 03a0000a moveq r0, #10 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
3001a360: 1a000001 bne 3001a36c <rtems_timer_server_fire_after+0x4c> <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a364: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a368: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
3001a36c: e59f008c ldr r0, [pc, #140] ; 3001a400 <rtems_timer_server_fire_after+0xe0><== NOT EXECUTED
3001a370: e1a01007 mov r1, r7 <== NOT EXECUTED
3001a374: e1a0200d mov r2, sp <== NOT EXECUTED
3001a378: eb000aab bl 3001ce2c <_Objects_Get> <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a37c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3001a380: e1a0a000 mov sl, r0 <== NOT EXECUTED 3001a384: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a388: 13a00004 movne r0, #4 <== NOT EXECUTED
if ( ticks == 0 )
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a38c: 1afffff4 bne 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a390: e28a0010 add r0, sl, #16 <== NOT EXECUTED 3001a394: eb0012a9 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
__asm__ volatile (
3001a398: e10f2000 mrs r2, CPSR <== NOT EXECUTED 3001a39c: e3823080 orr r3, r2, #128 ; 0x80 <== NOT EXECUTED 3001a3a0: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/*
* Check to see if the watchdog has just been inserted by a
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
3001a3a4: e59a3018 ldr r3, [sl, #24] <== NOT EXECUTED 3001a3a8: e3530000 cmp r3, #0 <== NOT EXECUTED 3001a3ac: 1a00000e bne 3001a3ec <rtems_timer_server_fire_after+0xcc> <== NOT EXECUTED
/*
* OK. Now we now the timer was not rescheduled by an interrupt
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
3001a3b0: e3a01001 mov r1, #1 <== NOT EXECUTED 3001a3b4: e58a1038 str r1, [sl, #56] ; 0x38 <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a3b8: e58a3018 str r3, [sl, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001a3bc: e58a502c str r5, [sl, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001a3c0: e58a7030 str r7, [sl, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001a3c4: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
3001a3c8: e58a601c str r6, [sl, #28] <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
__asm__ volatile (
3001a3cc: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
_ISR_Enable( level );
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a3d0: e1a00004 mov r0, r4 <== NOT EXECUTED 3001a3d4: e1a0100a mov r1, sl <== NOT EXECUTED 3001a3d8: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a3dc: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a3e0: eb000de0 bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a3e4: e3a00000 mov r0, #0 <== NOT EXECUTED 3001a3e8: eaffffdd b 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED 3001a3ec: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
* higher priority interrupt. If so, abandon this insert.
*/
if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
_Thread_Enable_dispatch();
3001a3f0: eb000ddc bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a3f4: e3a00000 mov r0, #0 <== NOT EXECUTED 3001a3f8: eaffffd9 b 3001a364 <rtems_timer_server_fire_after+0x44> <== NOT EXECUTED
3001a404 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a404: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3001a408: e1a06000 mov r6, r0 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001a40c: e59f00e0 ldr r0, [pc, #224] ; 3001a4f4 <rtems_timer_server_fire_when+0xf0><== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a410: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server;
3001a414: e5904000 ldr r4, [r0] <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a418: e1a07001 mov r7, r1 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001a41c: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
3001a420: e1a05002 mov r5, r2 <== NOT EXECUTED 3001a424: e1a08003 mov r8, r3 <== NOT EXECUTED
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
3001a428: 03a0000e moveq r0, #14 <== NOT EXECUTED
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
3001a42c: 0a00000c beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
3001a430: e59f30c0 ldr r3, [pc, #192] ; 3001a4f8 <rtems_timer_server_fire_when+0xf4><== NOT EXECUTED 3001a434: e5d33000 ldrb r3, [r3] <== NOT EXECUTED 3001a438: e3530000 cmp r3, #0 <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
3001a43c: 03a0000b moveq r0, #11 <== NOT EXECUTED
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
3001a440: 0a000007 beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_NOT_DEFINED;
if ( !routine )
3001a444: e3520000 cmp r2, #0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
3001a448: 03a00009 moveq r0, #9 <== NOT EXECUTED
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
3001a44c: 0a000004 beq 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
3001a450: e1a00001 mov r0, r1 <== NOT EXECUTED 3001a454: ebfff3ec bl 3001740c <_TOD_Validate> <== NOT EXECUTED 3001a458: e3500000 cmp r0, #0 <== NOT EXECUTED 3001a45c: 1a000002 bne 3001a46c <rtems_timer_server_fire_when+0x68> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
3001a460: e3a00014 mov r0, #20 <== NOT EXECUTED
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
3001a464: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3001a468: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001a46c: e1a00007 mov r0, r7 <== NOT EXECUTED 3001a470: ebfff3ba bl 30017360 <_TOD_To_seconds> <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a474: e59fa080 ldr sl, [pc, #128] ; 3001a4fc <rtems_timer_server_fire_when+0xf8><== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
3001a478: e1a07000 mov r7, r0 <== NOT EXECUTED
if ( seconds <= _TOD_Seconds_since_epoch() )
3001a47c: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3001a480: e1500003 cmp r0, r3 <== NOT EXECUTED 3001a484: 9afffff5 bls 3001a460 <rtems_timer_server_fire_when+0x5c> <== NOT EXECUTED 3001a488: e59f0070 ldr r0, [pc, #112] ; 3001a500 <rtems_timer_server_fire_when+0xfc><== NOT EXECUTED 3001a48c: e1a01006 mov r1, r6 <== NOT EXECUTED 3001a490: e1a0200d mov r2, sp <== NOT EXECUTED 3001a494: eb000a64 bl 3001ce2c <_Objects_Get> <== NOT EXECUTED
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a498: e59d9000 ldr r9, [sp] <== NOT EXECUTED 3001a49c: e1a0b000 mov fp, r0 <== NOT EXECUTED 3001a4a0: e3590000 cmp r9, #0 <== NOT EXECUTED
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
3001a4a4: 13a00004 movne r0, #4 <== NOT EXECUTED
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch() )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
3001a4a8: 1affffed bne 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
3001a4ac: e28b0010 add r0, fp, #16 <== NOT EXECUTED 3001a4b0: eb001262 bl 3001ee40 <_Watchdog_Remove> <== NOT EXECUTED
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
3001a4b4: e59a3000 ldr r3, [sl] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4b8: e1a00004 mov r0, r4 <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
3001a4bc: e0637007 rsb r7, r3, r7 <== NOT EXECUTED
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
3001a4c0: e3a03003 mov r3, #3 <== NOT EXECUTED 3001a4c4: e58b3038 str r3, [fp, #56] ; 0x38 <== NOT EXECUTED
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4c8: e1a0100b mov r1, fp <== NOT EXECUTED
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
3001a4cc: e58b9018 str r9, [fp, #24] <== NOT EXECUTED
the_watchdog->routine = routine;
3001a4d0: e58b502c str r5, [fp, #44] ; 0x2c <== NOT EXECUTED
the_watchdog->id = id;
3001a4d4: e58b6030 str r6, [fp, #48] ; 0x30 <== NOT EXECUTED
the_watchdog->user_data = user_data;
3001a4d8: e58b8034 str r8, [fp, #52] ; 0x34 <== NOT EXECUTED
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
3001a4dc: e58b701c str r7, [fp, #28] <== NOT EXECUTED
(*timer_server->schedule_operation)( timer_server, the_timer );
3001a4e0: e1a0e00f mov lr, pc <== NOT EXECUTED 3001a4e4: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
_Thread_Enable_dispatch();
3001a4e8: eb000d9e bl 3001db68 <_Thread_Enable_dispatch> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
3001a4ec: e1a00009 mov r0, r9 <== NOT EXECUTED 3001a4f0: eaffffdb b 3001a464 <rtems_timer_server_fire_when+0x60> <== NOT EXECUTED
3000af44 <rtems_verror>:
{
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000af44: e3100202 tst r0, #536870912 ; 0x20000000 <== NOT EXECUTED
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
3000af48: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3000af4c: e1a04000 mov r4, r0 <== NOT EXECUTED
3000af50: e1a08001 mov r8, r1 <== NOT EXECUTED
3000af54: e1a06002 mov r6, r2 <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
3000af58: 0a00000d beq 3000af94 <rtems_verror+0x50> <== NOT EXECUTED
if (rtems_panic_in_progress++)
3000af5c: e59f212c ldr r2, [pc, #300] ; 3000b090 <rtems_verror+0x14c><== NOT EXECUTED 3000af60: e5921000 ldr r1, [r2] <== NOT EXECUTED 3000af64: e2813001 add r3, r1, #1 <== NOT EXECUTED 3000af68: e3510000 cmp r1, #0 <== NOT EXECUTED 3000af6c: e5823000 str r3, [r2] <== NOT EXECUTED 3000af70: 0a000004 beq 3000af88 <rtems_verror+0x44> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
3000af74: e59f3118 ldr r3, [pc, #280] ; 3000b094 <rtems_verror+0x150><== NOT EXECUTED 3000af78: e5931000 ldr r1, [r3] <== NOT EXECUTED 3000af7c: e2811001 add r1, r1, #1 <== NOT EXECUTED 3000af80: e5831000 str r1, [r3] <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
3000af84: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
3000af88: e3530002 cmp r3, #2 <== NOT EXECUTED
return 0;
3000af8c: c3a06000 movgt r6, #0 <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
3000af90: ca000024 bgt 3000b028 <rtems_verror+0xe4> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000af94: e59f50fc ldr r5, [pc, #252] ; 3000b098 <rtems_verror+0x154><== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
3000af98: e3c47207 bic r7, r4, #1879048192 ; 0x70000000 <== NOT EXECUTED
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
3000af9c: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000afa0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 3000afa4: eb002f1d bl 30016c20 <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
3000afa8: e2144101 ands r4, r4, #1073741824 ; 0x40000000 <== NOT EXECUTED 3000afac: 1a00002a bne 3000b05c <rtems_verror+0x118> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
3000afb0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000afb4: e1a02006 mov r2, r6 <== NOT EXECUTED 3000afb8: e1a01008 mov r1, r8 <== NOT EXECUTED 3000afbc: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000afc0: eb004a53 bl 3001d914 <vfprintf> <== NOT EXECUTED
if (status)
3000afc4: e3570000 cmp r7, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
3000afc8: e1a06000 mov r6, r0 <== NOT EXECUTED
if (status)
3000afcc: 1a000017 bne 3000b030 <rtems_verror+0xec> <== NOT EXECUTED
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
3000afd0: e3540000 cmp r4, #0 <== NOT EXECUTED 3000afd4: 0a00000b beq 3000b008 <rtems_verror+0xc4> <== NOT EXECUTED
if ((local_errno > 0) && *strerror(local_errno))
3000afd8: da000004 ble 3000aff0 <rtems_verror+0xac> <== NOT EXECUTED 3000afdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3000afe0: eb0032f7 bl 30017bc4 <strerror> <== NOT EXECUTED 3000afe4: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 3000afe8: e3530000 cmp r3, #0 <== NOT EXECUTED 3000afec: 1a00001d bne 3000b068 <rtems_verror+0x124> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
3000aff0: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000aff4: e59f10a0 ldr r1, [pc, #160] ; 3000b09c <rtems_verror+0x158><== NOT EXECUTED 3000aff8: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000affc: e1a02004 mov r2, r4 <== NOT EXECUTED 3000b000: eb002fec bl 30016fb8 <fprintf> <== NOT EXECUTED 3000b004: e0866000 add r6, r6, r0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
3000b008: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b00c: e59f108c ldr r1, [pc, #140] ; 3000b0a0 <rtems_verror+0x15c><== NOT EXECUTED 3000b010: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b014: eb002fe7 bl 30016fb8 <fprintf> <== NOT EXECUTED
(void) fflush(stderr);
3000b018: e5953000 ldr r3, [r5] <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
3000b01c: e0806006 add r6, r0, r6 <== NOT EXECUTED
(void) fflush(stderr);
3000b020: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3000b024: eb002efd bl 30016c20 <fflush> <== NOT EXECUTED
return chars_written;
}
3000b028: e1a00006 mov r0, r6 <== NOT EXECUTED
3000b02c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
3000b030: e59f3060 ldr r3, [pc, #96] ; 3000b098 <rtems_verror+0x154> <== NOT EXECUTED 3000b034: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b038: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000b03c: e593700c ldr r7, [r3, #12] <== NOT EXECUTED 3000b040: ebffffbb bl 3000af34 <rtems_status_text> <== NOT EXECUTED 3000b044: e59f1058 ldr r1, [pc, #88] ; 3000b0a4 <rtems_verror+0x160> <== NOT EXECUTED 3000b048: e1a02000 mov r2, r0 <== NOT EXECUTED 3000b04c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000b050: eb002fd8 bl 30016fb8 <fprintf> <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
3000b054: e0866000 add r6, r6, r0 <== NOT EXECUTED 3000b058: eaffffdc b 3000afd0 <rtems_verror+0x8c> <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
3000b05c: eb002df8 bl 30016844 <__errno> <== NOT EXECUTED 3000b060: e5904000 ldr r4, [r0] <== NOT EXECUTED 3000b064: eaffffd1 b 3000afb0 <rtems_verror+0x6c> <== NOT EXECUTED
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
3000b068: e5953000 ldr r3, [r5] <== NOT EXECUTED 3000b06c: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b070: e593400c ldr r4, [r3, #12] <== NOT EXECUTED 3000b074: eb0032d2 bl 30017bc4 <strerror> <== NOT EXECUTED 3000b078: e59f1028 ldr r1, [pc, #40] ; 3000b0a8 <rtems_verror+0x164> <== NOT EXECUTED 3000b07c: e1a02000 mov r2, r0 <== NOT EXECUTED 3000b080: e1a00004 mov r0, r4 <== NOT EXECUTED 3000b084: eb002fcb bl 30016fb8 <fprintf> <== NOT EXECUTED 3000b088: e0866000 add r6, r6, r0 <== NOT EXECUTED 3000b08c: eaffffdd b 3000b008 <rtems_verror+0xc4> <== NOT EXECUTED
30006bc4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30006bc4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0;
30006bc8: e3a06000 mov r6, #0 <== NOT EXECUTED
int d;
for (;;) {
c = getc(fp);
30006bcc: e59f90f8 ldr r9, [pc, #248] ; 30006ccc <scanInt+0x108> <== NOT EXECUTED
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
30006bd0: e59f80f8 ldr r8, [pc, #248] ; 30006cd0 <scanInt+0x10c> <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
30006bd4: e59fa0f8 ldr sl, [pc, #248] ; 30006cd4 <scanInt+0x110> <== NOT EXECUTED
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
30006bd8: e1a04000 mov r4, r0 <== NOT EXECUTED 30006bdc: e1a0b001 mov fp, r1 <== NOT EXECUTED
int c; unsigned int i = 0; unsigned int limit = INT_MAX;
30006be0: e3e07102 mvn r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
30006be4: e1a05006 mov r5, r6 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006be8: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30006bec: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006bf0: e3530000 cmp r3, #0 <== NOT EXECUTED 30006bf4: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006bf8: ba00001d blt 30006c74 <scanInt+0xb0> <== NOT EXECUTED 30006bfc: e5943000 ldr r3, [r4] <== NOT EXECUTED 30006c00: e4d30001 ldrb r0, [r3], #1 <== NOT EXECUTED
if (c == ':')
30006c04: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c08: e5843000 str r3, [r4] <== NOT EXECUTED
if (c == ':')
30006c0c: 0a00001d beq 30006c88 <scanInt+0xc4> <== NOT EXECUTED
break;
if (sign == 0) {
30006c10: e3560000 cmp r6, #0 <== NOT EXECUTED 30006c14: 1a000004 bne 30006c2c <scanInt+0x68> <== NOT EXECUTED
if (c == '-') {
30006c18: e350002d cmp r0, #45 ; 0x2d <== NOT EXECUTED
sign = -1;
limit++;
30006c1c: 02877001 addeq r7, r7, #1 <== NOT EXECUTED
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
30006c20: 03e06000 mvneq r6, #0 <== NOT EXECUTED
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
30006c24: 0affffef beq 30006be8 <scanInt+0x24> <== NOT EXECUTED
sign = -1;
limit++;
continue;
}
sign = 1;
30006c28: e3a06001 mov r6, #1 <== NOT EXECUTED
}
if (!isdigit(c))
30006c2c: e5983000 ldr r3, [r8] <== NOT EXECUTED 30006c30: e0833000 add r3, r3, r0 <== NOT EXECUTED 30006c34: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED 30006c38: e2133004 ands r3, r3, #4 <== NOT EXECUTED 30006c3c: 0a00001e beq 30006cbc <scanInt+0xf8> <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
30006c40: e083279a umull r2, r3, sl, r7 <== NOT EXECUTED 30006c44: e15501a3 cmp r5, r3, lsr #3 <== NOT EXECUTED 30006c48: 8a000019 bhi 30006cb4 <scanInt+0xf0> <== NOT EXECUTED
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
30006c4c: e2400030 sub r0, r0, #48 ; 0x30 <== NOT EXECUTED 30006c50: 11a03105 lslne r3, r5, #2 <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
30006c54: 0a000011 beq 30006ca0 <scanInt+0xdc> <== NOT EXECUTED
return 0;
i = i * 10 + d;
30006c58: e0835005 add r5, r3, r5 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c5c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
30006c60: e0805085 add r5, r0, r5, lsl #1 <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
30006c64: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006c68: e3530000 cmp r3, #0 <== NOT EXECUTED 30006c6c: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006c70: aaffffe1 bge 30006bfc <scanInt+0x38> <== NOT EXECUTED 30006c74: e5990000 ldr r0, [r9] <== NOT EXECUTED 30006c78: e1a01004 mov r1, r4 <== NOT EXECUTED 30006c7c: eb0032ac bl 30013734 <__srget_r> <== NOT EXECUTED
if (c == ':')
30006c80: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 30006c84: 1affffe1 bne 30006c10 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
30006c88: e3560000 cmp r6, #0 <== NOT EXECUTED 30006c8c: 0a00000c beq 30006cc4 <scanInt+0x100> <== NOT EXECUTED
return 0;
*val = i * sign;
30006c90: e0050596 mul r5, r6, r5 <== NOT EXECUTED
return 1;
30006c94: e3a00001 mov r0, #1 <== NOT EXECUTED
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
30006c98: e58b5000 str r5, [fp] <== NOT EXECUTED
return 1;
30006c9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
30006ca0: e1a03105 lsl r3, r5, #2 <== NOT EXECUTED 30006ca4: e0832005 add r2, r3, r5 <== NOT EXECUTED 30006ca8: e0472082 sub r2, r7, r2, lsl #1 <== NOT EXECUTED 30006cac: e1500002 cmp r0, r2 <== NOT EXECUTED 30006cb0: 9affffe8 bls 30006c58 <scanInt+0x94> <== NOT EXECUTED
return 0;
30006cb4: e3a00000 mov r0, #0 <== NOT EXECUTED
30006cb8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
30006cbc: e1a00003 mov r0, r3 <== NOT EXECUTED
30006cc0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
30006cc4: e1a00006 mov r0, r6 <== NOT EXECUTED
*val = i * sign; return 1; }
30006cc8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
30006cd8 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006cd8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006cdc: e1a05002 mov r5, r2 <== NOT EXECUTED
int c;
*name = *bufp;
30006ce0: e5922000 ldr r2, [r2] <== NOT EXECUTED
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006ce4: e59d7018 ldr r7, [sp, #24] <== NOT EXECUTED
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006ce8: e59f60d8 ldr r6, [pc, #216] ; 30006dc8 <scanString+0xf0> <== NOT EXECUTED
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
30006cec: e1a04000 mov r4, r0 <== NOT EXECUTED 30006cf0: e1a08003 mov r8, r3 <== NOT EXECUTED
int c;
*name = *bufp;
30006cf4: e5812000 str r2, [r1] <== NOT EXECUTED 30006cf8: ea000013 b 30006d4c <scanString+0x74> <== NOT EXECUTED
for (;;) {
c = getc(fp);
30006cfc: e5943000 ldr r3, [r4] <== NOT EXECUTED 30006d00: e4d30001 ldrb r0, [r3], #1 <== NOT EXECUTED
if (c == ':') {
30006d04: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006d08: e5843000 str r3, [r4] <== NOT EXECUTED
if (c == ':') {
30006d0c: 0a000018 beq 30006d74 <scanString+0x9c> <== NOT EXECUTED
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
30006d10: e350000a cmp r0, #10 <== NOT EXECUTED 30006d14: 0a000025 beq 30006db0 <scanString+0xd8> <== NOT EXECUTED
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
30006d18: e3700001 cmn r0, #1 <== NOT EXECUTED 30006d1c: 0a000021 beq 30006da8 <scanString+0xd0> <== NOT EXECUTED
return 0;
if (*nleft < 2)
30006d20: e5983000 ldr r3, [r8] <== NOT EXECUTED 30006d24: e3530001 cmp r3, #1 <== NOT EXECUTED 30006d28: 9a000024 bls 30006dc0 <scanString+0xe8> <== NOT EXECUTED
return 0;
**bufp = c;
30006d2c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006d30: e5c30000 strb r0, [r3] <== NOT EXECUTED
++(*bufp);
30006d34: e5952000 ldr r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d38: e5983000 ldr r3, [r8] <== NOT EXECUTED
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
30006d3c: e2822001 add r2, r2, #1 <== NOT EXECUTED
--(*nleft);
30006d40: e2433001 sub r3, r3, #1 <== NOT EXECUTED
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
30006d44: e5852000 str r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d48: e5883000 str r3, [r8] <== NOT EXECUTED
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
30006d4c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 30006d50: e2433001 sub r3, r3, #1 <== NOT EXECUTED 30006d54: e3530000 cmp r3, #0 <== NOT EXECUTED 30006d58: e5843004 str r3, [r4, #4] <== NOT EXECUTED 30006d5c: aaffffe6 bge 30006cfc <scanString+0x24> <== NOT EXECUTED 30006d60: e5960000 ldr r0, [r6] <== NOT EXECUTED 30006d64: e1a01004 mov r1, r4 <== NOT EXECUTED 30006d68: eb003271 bl 30013734 <__srget_r> <== NOT EXECUTED
if (c == ':') {
30006d6c: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 30006d70: 1affffe6 bne 30006d10 <scanString+0x38> <== NOT EXECUTED
if (nlFlag)
30006d74: e3570000 cmp r7, #0 <== NOT EXECUTED 30006d78: 1a00000a bne 30006da8 <scanString+0xd0> <== NOT EXECUTED
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
30006d7c: e5953000 ldr r3, [r5] <== NOT EXECUTED 30006d80: e3a02000 mov r2, #0 <== NOT EXECUTED 30006d84: e5c32000 strb r2, [r3] <== NOT EXECUTED
++(*bufp);
30006d88: e5952000 ldr r2, [r5] <== NOT EXECUTED
--(*nleft);
30006d8c: e5983000 ldr r3, [r8] <== NOT EXECUTED
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
30006d90: e2822001 add r2, r2, #1 <== NOT EXECUTED
--(*nleft);
30006d94: e2433001 sub r3, r3, #1 <== NOT EXECUTED
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
30006d98: e5852000 str r2, [r5] <== NOT EXECUTED
--(*nleft); return 1;
30006d9c: e3a00001 mov r0, #1 <== NOT EXECUTED
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
--(*nleft);
30006da0: e5883000 str r3, [r8] <== NOT EXECUTED
return 1;
30006da4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
return 0;
30006da8: e3a00000 mov r0, #0 <== NOT EXECUTED
30006dac: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
30006db0: e3570000 cmp r7, #0 <== NOT EXECUTED 30006db4: 1afffff0 bne 30006d7c <scanString+0xa4> <== NOT EXECUTED
return 0;
30006db8: e1a00007 mov r0, r7 <== NOT EXECUTED
30006dbc: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
break;
}
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
30006dc0: e3a00000 mov r0, #0 <== NOT EXECUTED
} **bufp = '\0'; ++(*bufp); --(*nleft); return 1; }
30006dc4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
30006dcc <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006dcc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006dd0: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006dd4: e28d5008 add r5, sp, #8 <== NOT EXECUTED 30006dd8: e28d4004 add r4, sp, #4 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006ddc: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006de0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006de4: e3a06000 mov r6, #0 <== NOT EXECUTED 30006de8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006dec: e1a03004 mov r3, r4 <== NOT EXECUTED
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
30006df0: e1a07000 mov r7, r0 <== NOT EXECUTED 30006df4: e1a08001 mov r8, r1 <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
30006df8: e58d6000 str r6, [sp] <== NOT EXECUTED 30006dfc: ebffffb5 bl 30006cd8 <scanString> <== NOT EXECUTED 30006e00: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e04: 1a000001 bne 30006e10 <scangr+0x44> <== NOT EXECUTED
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
}
30006e08: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006e0c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
30006e10: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e14: e2881004 add r1, r8, #4 <== NOT EXECUTED 30006e18: e1a02005 mov r2, r5 <== NOT EXECUTED 30006e1c: e1a03004 mov r3, r4 <== NOT EXECUTED 30006e20: e58d6000 str r6, [sp] <== NOT EXECUTED 30006e24: ebffffab bl 30006cd8 <scanString> <== NOT EXECUTED 30006e28: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e2c: 0afffff5 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &grgid)
30006e30: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e34: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006e38: ebffff61 bl 30006bc4 <scanInt> <== NOT EXECUTED 30006e3c: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e40: 0afffff0 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
30006e44: e3a06001 mov r6, #1 <== NOT EXECUTED 30006e48: e1a00007 mov r0, r7 <== NOT EXECUTED 30006e4c: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006e50: e1a02005 mov r2, r5 <== NOT EXECUTED 30006e54: e1a03004 mov r3, r4 <== NOT EXECUTED 30006e58: e58d6000 str r6, [sp] <== NOT EXECUTED 30006e5c: ebffff9d bl 30006cd8 <scanString> <== NOT EXECUTED 30006e60: e3500000 cmp r0, #0 <== NOT EXECUTED 30006e64: 0affffe7 beq 30006e08 <scangr+0x3c> <== NOT EXECUTED
return 0;
grp->gr_gid = grgid;
30006e68: e1dd31b0 ldrh r3, [sp, #16] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e6c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
30006e70: e1c830b8 strh r3, [r8, #8] <== NOT EXECUTED
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e74: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 30006e78: e3530000 cmp r3, #0 <== NOT EXECUTED 30006e7c: 03a06017 moveq r6, #23 <== NOT EXECUTED 30006e80: 0a000007 beq 30006ea4 <scangr+0xd8> <== NOT EXECUTED 30006e84: e1a02001 mov r2, r1 <== NOT EXECUTED
if(*cp == ',')
30006e88: e353002c cmp r3, #44 ; 0x2c <== NOT EXECUTED
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e8c: e5f23001 ldrb r3, [r2, #1]! <== NOT EXECUTED
if(*cp == ',')
memcount++;
30006e90: 02866001 addeq r6, r6, #1 <== NOT EXECUTED
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006e94: e3530000 cmp r3, #0 <== NOT EXECUTED 30006e98: 1afffffa bne 30006e88 <scangr+0xbc> <== NOT EXECUTED 30006e9c: e1a06106 lsl r6, r6, #2 <== NOT EXECUTED 30006ea0: e2866013 add r6, r6, #19 <== NOT EXECUTED
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30006ea4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 30006ea8: e1530006 cmp r3, r6 <== NOT EXECUTED
return 0;
30006eac: 33a00000 movcc r0, #0 <== NOT EXECUTED
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
30006eb0: 3affffd4 bcc 30006e08 <scangr+0x3c> <== NOT EXECUTED
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
30006eb4: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 30006eb8: e280000f add r0, r0, #15 <== NOT EXECUTED 30006ebc: e3c0000f bic r0, r0, #15 <== NOT EXECUTED 30006ec0: e588000c str r0, [r8, #12] <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
30006ec4: e5801000 str r1, [r0] <== NOT EXECUTED
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006ec8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 30006ecc: e5d23000 ldrb r3, [r2] <== NOT EXECUTED 30006ed0: e3530000 cmp r3, #0 <== NOT EXECUTED 30006ed4: 0a000010 beq 30006f1c <scangr+0x150> <== NOT EXECUTED
}
/*
* Extract a single group record from the database
*/
static int scangr(
30006ed8: e2822001 add r2, r2, #1 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006edc: e3a01001 mov r1, #1 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
30006ee0: e3a00000 mov r0, #0 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
30006ee4: e353002c cmp r3, #44 ; 0x2c <== NOT EXECUTED
*cp = '\0';
30006ee8: 05420001 strbeq r0, [r2, #-1] <== NOT EXECUTED
grp->gr_mem[memcount++] = cp + 1;
30006eec: 0598300c ldreq r3, [r8, #12] <== NOT EXECUTED 30006ef0: 07832101 streq r2, [r3, r1, lsl #2] <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006ef4: e4d23001 ldrb r3, [r2], #1 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
30006ef8: 02811001 addeq r1, r1, #1 <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006efc: e3530000 cmp r3, #0 <== NOT EXECUTED 30006f00: 1afffff7 bne 30006ee4 <scangr+0x118> <== NOT EXECUTED 30006f04: e598000c ldr r0, [r8, #12] <== NOT EXECUTED 30006f08: e1a01101 lsl r1, r1, #2 <== NOT EXECUTED
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
30006f0c: e3a03000 mov r3, #0 <== NOT EXECUTED 30006f10: e7803001 str r3, [r0, r1] <== NOT EXECUTED
return 1;
30006f14: e3a00001 mov r0, #1 <== NOT EXECUTED 30006f18: eaffffba b 30006e08 <scangr+0x3c> <== NOT EXECUTED
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
30006f1c: e3a01004 mov r1, #4 <== NOT EXECUTED 30006f20: eafffff9 b 30006f0c <scangr+0x140> <== NOT EXECUTED
30006f24 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f24: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
30006f28: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f2c: e28d5008 add r5, sp, #8 <== NOT EXECUTED 30006f30: e28d4004 add r4, sp, #4 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f34: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 30006f38: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f3c: e3a06000 mov r6, #0 <== NOT EXECUTED 30006f40: e1a02005 mov r2, r5 <== NOT EXECUTED 30006f44: e1a03004 mov r3, r4 <== NOT EXECUTED
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
30006f48: e1a07000 mov r7, r0 <== NOT EXECUTED 30006f4c: e1a08001 mov r8, r1 <== NOT EXECUTED
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
30006f50: e58d6000 str r6, [sp] <== NOT EXECUTED 30006f54: ebffff5f bl 30006cd8 <scanString> <== NOT EXECUTED 30006f58: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f5c: 1a000001 bne 30006f68 <scanpw+0x44> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
}
30006f60: e28dd014 add sp, sp, #20 <== NOT EXECUTED
30006f64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
30006f68: e1a00007 mov r0, r7 <== NOT EXECUTED 30006f6c: e2881004 add r1, r8, #4 <== NOT EXECUTED 30006f70: e1a02005 mov r2, r5 <== NOT EXECUTED 30006f74: e1a03004 mov r3, r4 <== NOT EXECUTED 30006f78: e58d6000 str r6, [sp] <== NOT EXECUTED 30006f7c: ebffff55 bl 30006cd8 <scanString> <== NOT EXECUTED 30006f80: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f84: 0afffff5 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &pwuid)
30006f88: e1a00007 mov r0, r7 <== NOT EXECUTED 30006f8c: e28d1010 add r1, sp, #16 <== NOT EXECUTED 30006f90: ebffff0b bl 30006bc4 <scanInt> <== NOT EXECUTED 30006f94: e3500000 cmp r0, #0 <== NOT EXECUTED 30006f98: 0afffff0 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanInt(fp, &pwgid)
30006f9c: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fa0: e28d100c add r1, sp, #12 <== NOT EXECUTED 30006fa4: ebffff06 bl 30006bc4 <scanInt> <== NOT EXECUTED 30006fa8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fac: 0affffeb beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
30006fb0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fb4: e288100c add r1, r8, #12 <== NOT EXECUTED 30006fb8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006fbc: e1a03004 mov r3, r4 <== NOT EXECUTED 30006fc0: e58d6000 str r6, [sp] <== NOT EXECUTED 30006fc4: ebffff43 bl 30006cd8 <scanString> <== NOT EXECUTED 30006fc8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fcc: 0affffe3 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
30006fd0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006fd4: e2881010 add r1, r8, #16 <== NOT EXECUTED 30006fd8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006fdc: e1a03004 mov r3, r4 <== NOT EXECUTED 30006fe0: e58d6000 str r6, [sp] <== NOT EXECUTED 30006fe4: ebffff3b bl 30006cd8 <scanString> <== NOT EXECUTED 30006fe8: e3500000 cmp r0, #0 <== NOT EXECUTED 30006fec: 0affffdb beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
30006ff0: e1a00007 mov r0, r7 <== NOT EXECUTED 30006ff4: e2881014 add r1, r8, #20 <== NOT EXECUTED 30006ff8: e1a02005 mov r2, r5 <== NOT EXECUTED 30006ffc: e1a03004 mov r3, r4 <== NOT EXECUTED 30007000: e58d6000 str r6, [sp] <== NOT EXECUTED 30007004: ebffff33 bl 30006cd8 <scanString> <== NOT EXECUTED 30007008: e3500000 cmp r0, #0 <== NOT EXECUTED 3000700c: 0affffd3 beq 30006f60 <scanpw+0x3c> <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
30007010: e1a03004 mov r3, r4 <== NOT EXECUTED 30007014: e3a06001 mov r6, #1 <== NOT EXECUTED 30007018: e1a00007 mov r0, r7 <== NOT EXECUTED 3000701c: e2881018 add r1, r8, #24 <== NOT EXECUTED 30007020: e1a02005 mov r2, r5 <== NOT EXECUTED 30007024: e58d6000 str r6, [sp] <== NOT EXECUTED 30007028: ebffff2a bl 30006cd8 <scanString> <== NOT EXECUTED 3000702c: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
pwd->pw_uid = pwuid;
30007030: 11dd31b0 ldrhne r3, [sp, #16] <== NOT EXECUTED
pwd->pw_gid = pwgid; return 1;
30007034: 11a00006 movne r0, r6 <== NOT EXECUTED
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
30007038: 11c830b8 strhne r3, [r8, #8] <== NOT EXECUTED
pwd->pw_gid = pwgid;
3000703c: 11dd30bc ldrhne r3, [sp, #12] <== NOT EXECUTED 30007040: 11c830ba strhne r3, [r8, #10] <== NOT EXECUTED
return 1;
30007044: eaffffc5 b 30006f60 <scanpw+0x3c> <== NOT EXECUTED
30009418 <seteuid>:
#include <rtems/userenv.h>
int seteuid( uid_t euid )
{
_POSIX_types_Euid = euid;
30009418: e59f300c ldr r3, [pc, #12] ; 3000942c <seteuid+0x14> <== NOT EXECUTED 3000941c: e5933000 ldr r3, [r3] <== NOT EXECUTED 30009420: e1c303b6 strh r0, [r3, #54] ; 0x36 <== NOT EXECUTED
return 0; }
30009424: e3a00000 mov r0, #0 <== NOT EXECUTED 30009428: e12fff1e bx lr <== NOT EXECUTED
300083c8 <setgid>:
*/
int setgid(
gid_t gid
)
{
_POSIX_types_Gid = gid;
300083c8: e59f300c ldr r3, [pc, #12] ; 300083dc <setgid+0x14> <== NOT EXECUTED 300083cc: e5933000 ldr r3, [r3] <== NOT EXECUTED 300083d0: e1c303b4 strh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
return 0; }
300083d4: e3a00000 mov r0, #0 <== NOT EXECUTED 300083d8: e12fff1e bx lr <== NOT EXECUTED
30007568 <setgrent>:
void setgrent(void)
{
30007568: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (group_fp != NULL)
3000756c: e59f4020 ldr r4, [pc, #32] ; 30007594 <setgrent+0x2c> <== NOT EXECUTED
return &grent;
}
void setgrent(void)
{
init_etc_passwd_group();
30007570: ebfffeb4 bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if (group_fp != NULL)
30007574: e59401c4 ldr r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED 30007578: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(group_fp);
3000757c: 1b002b3c blne 30012274 <fclose> <== NOT EXECUTED
group_fp = fopen("/etc/group", "r");
30007580: e59f0010 ldr r0, [pc, #16] ; 30007598 <setgrent+0x30> <== NOT EXECUTED 30007584: e59f1010 ldr r1, [pc, #16] ; 3000759c <setgrent+0x34> <== NOT EXECUTED 30007588: eb002d10 bl 300129d0 <fopen> <== NOT EXECUTED 3000758c: e58401c4 str r0, [r4, #452] ; 0x1c4 <== NOT EXECUTED
}
30007590: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300083e0 <setpgid>:
int setpgid(
pid_t pid __attribute__((unused)),
pid_t pgid __attribute__((unused))
)
{
300083e0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSYS );
300083e4: eb002754 bl 3001213c <__errno> <== NOT EXECUTED 300083e8: e3a03058 mov r3, #88 ; 0x58 <== NOT EXECUTED 300083ec: e5803000 str r3, [r0] <== NOT EXECUTED
}
300083f0: e3e00000 mvn r0, #0 <== NOT EXECUTED
300083f4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
300073fc <setpwent>:
void setpwent(void)
{
300073fc: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (passwd_fp != NULL)
30007400: e59f4020 ldr r4, [pc, #32] ; 30007428 <setpwent+0x2c> <== NOT EXECUTED
return &pwent;
}
void setpwent(void)
{
init_etc_passwd_group();
30007404: ebffff0f bl 30007048 <init_etc_passwd_group> <== NOT EXECUTED
if (passwd_fp != NULL)
30007408: e59400e8 ldr r0, [r4, #232] ; 0xe8 <== NOT EXECUTED 3000740c: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(passwd_fp);
30007410: 1b002b97 blne 30012274 <fclose> <== NOT EXECUTED
passwd_fp = fopen("/etc/passwd", "r");
30007414: e59f0010 ldr r0, [pc, #16] ; 3000742c <setpwent+0x30> <== NOT EXECUTED 30007418: e59f1010 ldr r1, [pc, #16] ; 30007430 <setpwent+0x34> <== NOT EXECUTED 3000741c: eb002d6b bl 300129d0 <fopen> <== NOT EXECUTED 30007420: e58400e8 str r0, [r4, #232] ; 0xe8 <== NOT EXECUTED
}
30007424: e8bd8010 pop {r4, pc} <== NOT EXECUTED
300083f8 <setsid>:
*
* 4.3.2 Create Session and Set Process Group ID, P1003.1b-1993, p. 88
*/
pid_t setsid( void )
{
300083f8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
300083fc: eb00274e bl 3001213c <__errno> <== NOT EXECUTED 30008400: e3a03001 mov r3, #1 <== NOT EXECUTED 30008404: e5803000 str r3, [r0] <== NOT EXECUTED
}
30008408: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000840c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
30008410 <setuid>:
*/
int setuid(
uid_t uid
)
{
_POSIX_types_Uid = uid;
30008410: e59f300c ldr r3, [pc, #12] ; 30008424 <setuid+0x14> <== NOT EXECUTED 30008414: e5933000 ldr r3, [r3] <== NOT EXECUTED 30008418: e1c303b2 strh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
return 0; }
3000841c: e3a00000 mov r0, #0 <== NOT EXECUTED 30008420: e12fff1e bx lr <== NOT EXECUTED
300085ec <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
300085ec: e591203c ldr r2, [r1, #60] ; 0x3c <== NOT EXECUTED 300085f0: e59f304c ldr r3, [pc, #76] ; 30008644 <siproc+0x58> <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
300085f4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
300085f8: e0023003 and r3, r2, r3 <== NOT EXECUTED 300085fc: e3530000 cmp r3, #0 <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
30008600: e1a04001 mov r4, r1 <== NOT EXECUTED 30008604: e1a05000 mov r5, r0 <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
30008608: 1a000001 bne 30008614 <siproc+0x28> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
3000860c: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
30008610: eaffff81 b 3000841c <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
30008614: e3a01000 mov r1, #0 <== NOT EXECUTED 30008618: e1a02001 mov r2, r1 <== NOT EXECUTED 3000861c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 30008620: eb00054b bl 30009b54 <rtems_semaphore_obtain> <== NOT EXECUTED
i = iproc (c, tty);
30008624: e1a01004 mov r1, r4 <== NOT EXECUTED 30008628: e1a00005 mov r0, r5 <== NOT EXECUTED 3000862c: ebffff7a bl 3000841c <iproc> <== NOT EXECUTED 30008630: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
30008634: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 30008638: eb00058e bl 30009c78 <rtems_semaphore_release> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
3000863c: e1a00005 mov r0, r5 <== NOT EXECUTED
30008640: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3000741c <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
3000741c: e92d4070 push {r4, r5, r6, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
30007420: e2515000 subs r5, r1, #0
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
30007424: e24dd018 sub sp, sp, #24 30007428: e1a06000 mov r6, r0
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
3000742c: 0a000019 beq 30007498 <stat+0x7c>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
30007430: eb00238c bl 30010268 <strlen> 30007434: e28d4004 add r4, sp, #4 30007438: e3a03001 mov r3, #1 3000743c: e1a01000 mov r1, r0 30007440: e58d3000 str r3, [sp] 30007444: e3a02000 mov r2, #0 30007448: e1a00006 mov r0, r6 3000744c: e1a03004 mov r3, r4 30007450: ebfffc26 bl 300064f0 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
30007454: e2501000 subs r1, r0, #0
return -1;
30007458: 13e05000 mvnne r5, #0
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
3000745c: 1a00000a bne 3000748c <stat+0x70>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
30007460: e1a00005 mov r0, r5 30007464: e3a02048 mov r2, #72 ; 0x48 30007468: eb002274 bl 3000fe40 <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
3000746c: e1a01005 mov r1, r5 30007470: e1a00004 mov r0, r4 30007474: e59d300c ldr r3, [sp, #12] 30007478: e1a0e00f mov lr, pc 3000747c: e593f018 ldr pc, [r3, #24] 30007480: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
30007484: e1a00004 mov r0, r4 30007488: ebfffc52 bl 300065d8 <rtems_filesystem_freenode>
return status;
}
3000748c: e1a00005 mov r0, r5
30007490: e28dd018 add sp, sp, #24
30007494: e8bd8070 pop {r4, r5, r6, pc}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
30007498: eb002003 bl 3000f4ac <__errno> <== NOT EXECUTED 3000749c: e3a0300e mov r3, #14 <== NOT EXECUTED 300074a0: e5803000 str r3, [r0] <== NOT EXECUTED 300074a4: e3e05000 mvn r5, #0 <== NOT EXECUTED 300074a8: eafffff7 b 3000748c <stat+0x70> <== NOT EXECUTED
30009f64 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
30009f64: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30009f68: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
30009f6c: e1a05001 mov r5, r1 <== NOT EXECUTED
30009f70: e1a06000 mov r6, r0 <== NOT EXECUTED
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
30009f74: eb003091 bl 300161c0 <strlen> <== NOT EXECUTED 30009f78: e28d4004 add r4, sp, #4 <== NOT EXECUTED 30009f7c: e3a03001 mov r3, #1 <== NOT EXECUTED 30009f80: e1a01000 mov r1, r0 <== NOT EXECUTED 30009f84: e58d3000 str r3, [sp] <== NOT EXECUTED 30009f88: e3a02000 mov r2, #0 <== NOT EXECUTED 30009f8c: e1a00006 mov r0, r6 <== NOT EXECUTED 30009f90: e1a03004 mov r3, r4 <== NOT EXECUTED 30009f94: ebfffac0 bl 30008a9c <rtems_filesystem_evaluate_path> <== NOT EXECUTED 30009f98: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
30009f9c: 13e05000 mvnne r5, #0 <== NOT EXECUTED
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
30009fa0: 1a000018 bne 3000a008 <statvfs+0xa4> <== NOT EXECUTED
return -1;
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
30009fa4: e1a03005 mov r3, r5 <== NOT EXECUTED 30009fa8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fac: e2833004 add r3, r3, #4 <== NOT EXECUTED 30009fb0: e5850004 str r0, [r5, #4] <== NOT EXECUTED 30009fb4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fb8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fbc: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fc8: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fcc: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd4: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fd8: e4830004 str r0, [r3], #4 <== NOT EXECUTED
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
30009fdc: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
30009fe0: e4830004 str r0, [r3], #4 <== NOT EXECUTED 30009fe4: e5830000 str r0, [r3] <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
30009fe8: e1a01005 mov r1, r5 <== NOT EXECUTED 30009fec: e5923028 ldr r3, [r2, #40] ; 0x28 <== NOT EXECUTED 30009ff0: e282001c add r0, r2, #28 <== NOT EXECUTED 30009ff4: e1a0e00f mov lr, pc <== NOT EXECUTED 30009ff8: e593f044 ldr pc, [r3, #68] ; 0x44 <== NOT EXECUTED 30009ffc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
3000a000: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a004: ebfffade bl 30008b84 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000a008: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a00c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a010: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000876c <sync>:
{
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
3000876c: e59f3018 ldr r3, [pc, #24] ; 3000878c <sync+0x20> <== NOT EXECUTED
* We have to extern it here.
*/
extern struct _reent * const _global_impure_ptr __ATTRIBUTE_IMPURE_PTR__;
void sync(void)
{
30008770: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
/*
* Walk the one used initially by RTEMS.
*/
_fwalk(_global_impure_ptr, sync_wrapper);
30008774: e5930000 ldr r0, [r3] <== NOT EXECUTED 30008778: e59f1010 ldr r1, [pc, #16] ; 30008790 <sync+0x24> <== NOT EXECUTED 3000877c: eb002a78 bl 30013164 <_fwalk> <== NOT EXECUTED
*/
/*
* Now walk all the per-thread reentrancy structures.
*/
rtems_iterate_over_all_threads(sync_per_thread);
30008780: e59f000c ldr r0, [pc, #12] ; 30008794 <sync+0x28> <== NOT EXECUTED
}
30008784: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
*/
/*
* Now walk all the per-thread reentrancy structures.
*/
rtems_iterate_over_all_threads(sync_per_thread);
30008788: ea000ecf b 3000c2cc <rtems_iterate_over_all_threads> <== NOT EXECUTED
30008710 <sync_per_thread>:
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
30008710: e59030f0 ldr r3, [r0, #240] ; 0xf0 <== NOT EXECUTED
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
30008714: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
30008718: e3530000 cmp r3, #0 <== NOT EXECUTED
3000871c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
current_reent = _Thread_Executing->libc_reent;
30008720: e59f4020 ldr r4, [pc, #32] ; 30008748 <sync_per_thread+0x38><== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
30008724: e59f1020 ldr r1, [pc, #32] ; 3000874c <sync_per_thread+0x3c><== NOT EXECUTED
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
if ( this_reent ) {
current_reent = _Thread_Executing->libc_reent;
30008728: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000872c: e59250f0 ldr r5, [r2, #240] ; 0xf0 <== NOT EXECUTED
_Thread_Executing->libc_reent = this_reent;
30008730: e58230f0 str r3, [r2, #240] ; 0xf0 <== NOT EXECUTED
_fwalk (t->libc_reent, sync_wrapper);
30008734: e59000f0 ldr r0, [r0, #240] ; 0xf0 <== NOT EXECUTED 30008738: eb002a89 bl 30013164 <_fwalk> <== NOT EXECUTED
_Thread_Executing->libc_reent = current_reent;
3000873c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
30008740: e58350f0 str r5, [r3, #240] ; 0xf0 <== NOT EXECUTED
30008744: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
30008750 <sync_wrapper>:
/* XXX check standards -- Linux version appears to be void */
void _fwalk(struct _reent *, void *);
static void sync_wrapper(FILE *f)
{
30008750: e92d4010 push {r4, lr} <== NOT EXECUTED
int fn = fileno(f);
30008754: eb00279e bl 300125d4 <fileno> <== NOT EXECUTED 30008758: e1a04000 mov r4, r0 <== NOT EXECUTED
/* * We are explicitly NOT checking the return values as it does not * matter if they succeed. We are just making a best faith attempt * at both and trusting that we were passed a good FILE pointer. */ fsync(fn);
3000875c: ebfffae9 bl 30007308 <fsync> <== NOT EXECUTED
fdatasync(fn);
30008760: e1a00004 mov r0, r4 <== NOT EXECUTED
}
30008764: e8bd4010 pop {r4, lr} <== NOT EXECUTED
* We are explicitly NOT checking the return values as it does not * matter if they succeed. We are just making a best faith attempt * at both and trusting that we were passed a good FILE pointer. */ fsync(fn); fdatasync(fn);
30008768: eafffa2c b 30007020 <fdatasync> <== NOT EXECUTED
300093e4 <tcgetattr>:
int tcgetattr(
int fd,
struct termios *tp
)
{
300093e4: e1a02001 mov r2, r1 <== NOT EXECUTED
return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp );
300093e8: e3a01001 mov r1, #1 <== NOT EXECUTED 300093ec: ea001d7d b 300109e8 <ioctl> <== NOT EXECUTED
300093f0 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
300093f0: e3510000 cmp r1, #0 <== NOT EXECUTED
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
300093f4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
300093f8: e1a05000 mov r5, r0 <== NOT EXECUTED
300093fc: e1a04002 mov r4, r2 <== NOT EXECUTED
switch (opt) {
30009400: 0a00000b beq 30009434 <tcsetattr+0x44> <== NOT EXECUTED 30009404: e3510001 cmp r1, #1 <== NOT EXECUTED 30009408: 0a000004 beq 30009420 <tcsetattr+0x30> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
3000940c: eb002795 bl 30013268 <__errno> <== NOT EXECUTED 30009410: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 30009414: e5803000 str r3, [r0] <== NOT EXECUTED
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
30009418: e3e00000 mvn r0, #0 <== NOT EXECUTED
3000941c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
30009420: e3a01003 mov r1, #3 <== NOT EXECUTED 30009424: e3a02000 mov r2, #0 <== NOT EXECUTED 30009428: eb001d6e bl 300109e8 <ioctl> <== NOT EXECUTED 3000942c: e3500000 cmp r0, #0 <== NOT EXECUTED 30009430: bafffff8 blt 30009418 <tcsetattr+0x28> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
30009434: e1a00005 mov r0, r5 <== NOT EXECUTED 30009438: e3a01002 mov r1, #2 <== NOT EXECUTED 3000943c: e1a02004 mov r2, r4 <== NOT EXECUTED
} }
30009440: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
30009444: ea001d67 b 300109e8 <ioctl> <== NOT EXECUTED
300094c4 <times>:
clock_t times(
struct tms *ptms
)
{
return _times( ptms );
300094c4: eaffffcb b 300093f8 <_times> <== NOT EXECUTED
3000cd14 <truncate>:
int truncate(
const char *path,
off_t length
)
{
3000cd14: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000cd18: e1a05001 mov r5, r1 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd1c: e3a01001 mov r1, #1 <== NOT EXECUTED
int truncate(
const char *path,
off_t length
)
{
3000cd20: e1a06002 mov r6, r2 <== NOT EXECUTED
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd24: ebfff6a0 bl 3000a7ac <open> <== NOT EXECUTED
if ( fd == -1 )
3000cd28: e3700001 cmn r0, #1 <== NOT EXECUTED
)
{
int status;
int fd;
fd = open( path, O_WRONLY );
3000cd2c: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( fd == -1 )
return -1;
3000cd30: 01a05000 moveq r5, r0 <== NOT EXECUTED
{
int status;
int fd;
fd = open( path, O_WRONLY );
if ( fd == -1 )
3000cd34: 0a000005 beq 3000cd50 <truncate+0x3c> <== NOT EXECUTED
return -1;
status = ftruncate( fd, length );
3000cd38: e1a01005 mov r1, r5 <== NOT EXECUTED 3000cd3c: e1a02006 mov r2, r6 <== NOT EXECUTED 3000cd40: eb00161c bl 300125b8 <ftruncate> <== NOT EXECUTED 3000cd44: e1a05000 mov r5, r0 <== NOT EXECUTED
(void) close( fd );
3000cd48: e1a00004 mov r0, r4 <== NOT EXECUTED 3000cd4c: ebfff150 bl 30009294 <close> <== NOT EXECUTED
return status;
}
3000cd50: e1a00005 mov r0, r5 <== NOT EXECUTED
3000cd54: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
3000a500 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
3000a500: e92d40f0 push {r4, r5, r6, r7, lr}
3000a504: e24dd030 sub sp, sp, #48 ; 0x30
3000a508: e1a07000 mov r7, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
3000a50c: ebfff459 bl 30007678 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
3000a510: e2505000 subs r5, r0, #0
3000a514: 1a000039 bne 3000a600 <unlink+0x100>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
3000a518: e28d4018 add r4, sp, #24 <== NOT EXECUTED 3000a51c: e1a00007 mov r0, r7 <== NOT EXECUTED 3000a520: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 3000a524: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a528: ebfff86f bl 300086ec <rtems_filesystem_get_start_loc> <== NOT EXECUTED
const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false;
3000a52c: e1a06005 mov r6, r5 <== NOT EXECUTED
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a530: e28dc004 add ip, sp, #4
3000a534: e1a0e004 mov lr, r4
3000a538: e8be000f ldm lr!, {r0, r1, r2, r3}
3000a53c: e8ac000f stmia ip!, {r0, r1, r2, r3}
name = path + parentpathlen;
3000a540: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a544: e59e3000 ldr r3, [lr]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a548: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
3000a54c: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
3000a550: eb002ffd bl 3001654c <strlen> 3000a554: e1a01000 mov r1, r0 3000a558: e1a00005 mov r0, r5 3000a55c: ebfff454 bl 300076b4 <rtems_filesystem_prefix_separators> 3000a560: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
3000a564: e1a00007 mov r0, r7 3000a568: eb002ff7 bl 3001654c <strlen> 3000a56c: e28d5004 add r5, sp, #4 3000a570: e1a01000 mov r1, r0 3000a574: e3a02000 mov r2, #0 3000a578: e1a00007 mov r0, r7 3000a57c: e1a03005 mov r3, r5 3000a580: e58d2000 str r2, [sp] 3000a584: ebfff409 bl 300075b0 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
3000a588: e3500000 cmp r0, #0
3000a58c: 1a000013 bne 3000a5e0 <unlink+0xe0>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
3000a590: e1a00005 mov r0, r5 3000a594: e59d3010 ldr r3, [sp, #16] 3000a598: e1a0e00f mov lr, pc 3000a59c: e593f010 ldr pc, [r3, #16] 3000a5a0: e3500001 cmp r0, #1
3000a5a4: 0a000021 beq 3000a630 <unlink+0x130>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
3000a5a8: e1a01005 mov r1, r5 3000a5ac: e59d3010 ldr r3, [sp, #16] 3000a5b0: e1a00004 mov r0, r4 3000a5b4: e1a0e00f mov lr, pc 3000a5b8: e593f00c ldr pc, [r3, #12] 3000a5bc: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
3000a5c0: e1a00005 mov r0, r5 3000a5c4: ebfff44f bl 30007708 <rtems_filesystem_freenode>
if ( free_parentloc )
3000a5c8: e3560000 cmp r6, #0
rtems_filesystem_freenode( &parentloc );
3000a5cc: 11a00004 movne r0, r4 3000a5d0: 1bfff44c blne 30007708 <rtems_filesystem_freenode>
return result;
}
3000a5d4: e1a00007 mov r0, r7
3000a5d8: e28dd030 add sp, sp, #48 ; 0x30
3000a5dc: e8bd80f0 pop {r4, r5, r6, r7, pc}
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
3000a5e0: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a5e4: 1a000001 bne 3000a5f0 <unlink+0xf0> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
return -1;
3000a5e8: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a5ec: eafffff8 b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
3000a5f0: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a5f4: ebfff443 bl 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
return -1;
3000a5f8: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a5fc: eafffff4 b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
3000a600: e3a03000 mov r3, #0 3000a604: e28d4018 add r4, sp, #24 3000a608: e58d3000 str r3, [sp] 3000a60c: e3a02002 mov r2, #2 3000a610: e1a00007 mov r0, r7 3000a614: e1a01005 mov r1, r5 3000a618: e1a03004 mov r3, r4 3000a61c: ebfff3ff bl 30007620 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
3000a620: e3500000 cmp r0, #0
3000a624: 1affffef bne 3000a5e8 <unlink+0xe8>
return -1;
free_parentloc = true;
3000a628: e3a06001 mov r6, #1 3000a62c: eaffffbf b 3000a530 <unlink+0x30>
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
3000a630: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a634: ebfff433 bl 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
if ( free_parentloc )
3000a638: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
3000a63c: 11a00004 movne r0, r4 <== NOT EXECUTED 3000a640: 1bfff430 blne 30007708 <rtems_filesystem_freenode> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
3000a644: eb002c01 bl 30015650 <__errno> <== NOT EXECUTED 3000a648: e3a03015 mov r3, #21 <== NOT EXECUTED 3000a64c: e5803000 str r3, [r0] <== NOT EXECUTED 3000a650: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000a654: eaffffde b 3000a5d4 <unlink+0xd4> <== NOT EXECUTED
3000a820 <unmount>:
*/
int unmount(
const char *path
)
{
3000a820: e92d4070 push {r4, r5, r6, lr}
3000a824: e24dd018 sub sp, sp, #24
3000a828: e1a05000 mov r5, r0
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
3000a82c: eb0024bb bl 30013b20 <strlen> 3000a830: e28d4004 add r4, sp, #4 3000a834: e1a01000 mov r1, r0 3000a838: e3a0c001 mov ip, #1 3000a83c: e1a00005 mov r0, r5 3000a840: e3a02000 mov r2, #0 3000a844: e1a03004 mov r3, r4 3000a848: e58dc000 str ip, [sp] 3000a84c: ebfff338 bl 30007534 <rtems_filesystem_evaluate_path> 3000a850: e3500000 cmp r0, #0
3000a854: 1a00001a bne 3000a8c4 <unmount+0xa4>
return -1;
mt_entry = loc.mt_entry;
3000a858: e59d5014 ldr r5, [sp, #20]
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
3000a85c: e59d3004 ldr r3, [sp, #4] 3000a860: e595201c ldr r2, [r5, #28] 3000a864: e1520003 cmp r2, r3
3000a868: 1a00002d bne 3000a924 <unmount+0x104>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
3000a86c: e1a00004 mov r0, r4 3000a870: ebfff369 bl 3000761c <rtems_filesystem_freenode>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
3000a874: e59f30f8 ldr r3, [pc, #248] ; 3000a974 <unmount+0x154> 3000a878: e5933000 ldr r3, [r3] 3000a87c: e5933014 ldr r3, [r3, #20] 3000a880: e1530005 cmp r3, r5
3000a884: 0a00002d beq 3000a940 <unmount+0x120>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
3000a888: e59f00e8 ldr r0, [pc, #232] ; 3000a978 <unmount+0x158> 3000a88c: e595102c ldr r1, [r5, #44] ; 0x2c 3000a890: ebfff5c0 bl 30007f98 <rtems_filesystem_mount_iterate> 3000a894: e3500000 cmp r0, #0
3000a898: 1a000028 bne 3000a940 <unmount+0x120>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
3000a89c: e1a00005 mov r0, r5 3000a8a0: ebfff457 bl 30007a04 <rtems_libio_is_open_files_in_fs> 3000a8a4: e3500001 cmp r0, #1
3000a8a8: 0a000024 beq 3000a940 <unmount+0x120>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
3000a8ac: e5953014 ldr r3, [r5, #20] 3000a8b0: e1a00005 mov r0, r5 3000a8b4: e1a0e00f mov lr, pc 3000a8b8: e593f028 ldr pc, [r3, #40] ; 0x28 3000a8bc: e2506000 subs r6, r0, #0
3000a8c0: 0a000002 beq 3000a8d0 <unmount+0xb0>
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
rtems_fatal_error_occurred( 0 );
return -1;
3000a8c4: e3e00000 mvn r0, #0
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
3000a8c8: e28dd018 add sp, sp, #24
3000a8cc: e8bd8070 pop {r4, r5, r6, pc}
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
3000a8d0: e5953028 ldr r3, [r5, #40] ; 0x28 3000a8d4: e1a00005 mov r0, r5 3000a8d8: e1a0e00f mov lr, pc 3000a8dc: e593f02c ldr pc, [r3, #44] ; 0x2c 3000a8e0: e2504000 subs r4, r0, #0
3000a8e4: 1a00001a bne 3000a954 <unmount+0x134>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
3000a8e8: e59f608c ldr r6, [pc, #140] ; 3000a97c <unmount+0x15c> 3000a8ec: e1a01004 mov r1, r4 3000a8f0: e1a02004 mov r2, r4 3000a8f4: e5960000 ldr r0, [r6] 3000a8f8: eb0002a4 bl 3000b390 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
3000a8fc: e1a00005 mov r0, r5 3000a900: eb0004f6 bl 3000bce0 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
3000a904: e5960000 ldr r0, [r6] 3000a908: eb0002e9 bl 3000b4b4 <rtems_semaphore_release>
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
3000a90c: e2850008 add r0, r5, #8 3000a910: ebfff341 bl 3000761c <rtems_filesystem_freenode>
free( mt_entry );
3000a914: e1a00005 mov r0, r5 3000a918: ebfff344 bl 30007630 <free>
return 0;
3000a91c: e1a00004 mov r0, r4 3000a920: eaffffe8 b 3000a8c8 <unmount+0xa8>
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
3000a924: e1a00004 mov r0, r4 3000a928: ebfff33b bl 3000761c <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
3000a92c: eb001f03 bl 30012540 <__errno> 3000a930: e3a0300d mov r3, #13 3000a934: e5803000 str r3, [r0] 3000a938: e3e00000 mvn r0, #0 3000a93c: eaffffe1 b 3000a8c8 <unmount+0xa8>
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
rtems_set_errno_and_return_minus_one( EBUSY );
3000a940: eb001efe bl 30012540 <__errno> 3000a944: e3a03010 mov r3, #16 3000a948: e5803000 str r3, [r0] 3000a94c: e3e00000 mvn r0, #0 3000a950: eaffffdc b 3000a8c8 <unmount+0xa8>
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
3000a954: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 3000a958: e1a00005 mov r0, r5 <== NOT EXECUTED 3000a95c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a960: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED 3000a964: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a968: 0affffd5 beq 3000a8c4 <unmount+0xa4> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
3000a96c: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a970: eb000416 bl 3000b9d0 <rtems_fatal_error_occurred> <== NOT EXECUTED
3000a538 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
3000a538: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3000a53c: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
3000a540: e1a05001 mov r5, r1 <== NOT EXECUTED
3000a544: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
3000a548: eb002631 bl 30013e14 <strlen> <== NOT EXECUTED 3000a54c: e28d4004 add r4, sp, #4 <== NOT EXECUTED 3000a550: e3a03001 mov r3, #1 <== NOT EXECUTED 3000a554: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a558: e58d3000 str r3, [sp] <== NOT EXECUTED 3000a55c: e3a02000 mov r2, #0 <== NOT EXECUTED 3000a560: e1a00006 mov r0, r6 <== NOT EXECUTED 3000a564: e1a03004 mov r3, r4 <== NOT EXECUTED 3000a568: ebfff1f4 bl 30006d40 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 3000a56c: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
3000a570: 13e05000 mvnne r5, #0 <== NOT EXECUTED
{
rtems_filesystem_location_info_t temp_loc;
int result;
struct utimbuf now;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
3000a574: 1a000009 bne 3000a5a0 <utime+0x68> <== NOT EXECUTED
return -1;
if ( times == NULL ) {
3000a578: e3550000 cmp r5, #0 <== NOT EXECUTED
3000a57c: 0a00000a beq 3000a5ac <utime+0x74> <== NOT EXECUTED
3000a580: e8950006 ldm r5, {r1, r2} <== NOT EXECUTED
now.actime = now.modtime = time( NULL );
times = &now;
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
3000a584: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a588: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3000a58c: e1a0e00f mov lr, pc <== NOT EXECUTED 3000a590: e593f030 ldr pc, [r3, #48] ; 0x30 <== NOT EXECUTED 3000a594: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &temp_loc );
3000a598: e1a00004 mov r0, r4 <== NOT EXECUTED 3000a59c: ebfff304 bl 300071b4 <rtems_filesystem_freenode> <== NOT EXECUTED
return result;
}
3000a5a0: e1a00005 mov r0, r5 <== NOT EXECUTED
3000a5a4: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3000a5a8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
return -1;
if ( times == NULL ) {
now.actime = now.modtime = time( NULL );
3000a5ac: eb00266b bl 30013f60 <time> <== NOT EXECUTED 3000a5b0: e1a02000 mov r2, r0 <== NOT EXECUTED 3000a5b4: e1a01000 mov r1, r0 <== NOT EXECUTED 3000a5b8: eafffff1 b 3000a584 <utime+0x4c> <== NOT EXECUTED
3000a5bc <utimes>:
int utimes(
const char *path,
const struct timeval times[2]
)
{
3000a5bc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
3000a5c0: e2513000 subs r3, r1, #0 <== NOT EXECUTED
int utimes(
const char *path,
const struct timeval times[2]
)
{
3000a5c4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
3000a5c8: 15932000 ldrne r2, [r3] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
3000a5cc: 15933008 ldrne r3, [r3, #8] <== NOT EXECUTED
return utime( path, &timeinsecs );
3000a5d0: 11a0100d movne r1, sp <== NOT EXECUTED
struct utimbuf timeinsecs;
if ( times == NULL )
return utime( path, NULL );
timeinsecs.actime = (time_t) times[0].tv_sec;
3000a5d4: 158d2000 strne r2, [sp] <== NOT EXECUTED
timeinsecs.modtime = (time_t) times[1].tv_sec;
3000a5d8: 158d3004 strne r3, [sp, #4] <== NOT EXECUTED
return utime( path, &timeinsecs );
3000a5dc: ebffffd5 bl 3000a538 <utime> <== NOT EXECUTED
}
3000a5e0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3000a5e4: e8bd8000 pop {pc} <== NOT EXECUTED
30009144 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009144: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
30009148: e1a0a000 mov sl, r0
for (; *fmt != '\0'; fmt++) {
3000914c: e5d00000 ldrb r0, [r0]
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009150: e24dd01c sub sp, sp, #28
for (; *fmt != '\0'; fmt++) {
30009154: e3500000 cmp r0, #0
*/
void vprintk(
const char *fmt,
va_list ap
)
{
30009158: e58d1000 str r1, [sp]
for (; *fmt != '\0'; fmt++) {
3000915c: 0a00006e beq 3000931c <vprintk+0x1d8>
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
BSP_output_char(*fmt);
30009160: e59f8340 ldr r8, [pc, #832] ; 300094a8 <vprintk+0x364>
* console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
30009164: e28db008 add fp, sp, #8
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
30009168: e3500025 cmp r0, #37 ; 0x25
3000916c: 1a00006d bne 30009328 <vprintk+0x1e4>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
30009170: e5fa3001 ldrb r3, [sl, #1]! 30009174: e3530030 cmp r3, #48 ; 0x30
lead = '0';
fmt++;
30009178: 05fa3001 ldrbeq r3, [sl, #1]!
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
3000917c: 03a02030 moveq r2, #48 ; 0x30
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30009180: 13a02020 movne r2, #32
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
30009184: 058d2004 streq r2, [sp, #4]
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
bool sign = false;
char lead = ' ';
30009188: 158d2004 strne r2, [sp, #4]
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
3000918c: e353002d cmp r3, #45 ; 0x2d
minus = true;
fmt++;
30009190: 05fa3001 ldrbeq r3, [sl, #1]!
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
30009194: 03a09001 moveq r9, #1
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
30009198: e2432030 sub r2, r3, #48 ; 0x30
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
3000919c: 13a09000 movne r9, #0
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091a0: e3520009 cmp r2, #9 300091a4: 83a06000 movhi r6, #0
300091a8: 8a000009 bhi 300091d4 <vprintk+0x90> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
300091ac: e28a2001 add r2, sl, #1 300091b0: e3a06000 mov r6, #0
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
300091b4: e0866106 add r6, r6, r6, lsl #2
width += ((unsigned) *fmt - '0');
300091b8: e0836086 add r6, r3, r6, lsl #1 300091bc: e1a0a002 mov sl, r2
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091c0: e4d23001 ldrb r3, [r2], #1
width *= 10;
width += ((unsigned) *fmt - '0');
300091c4: e2466030 sub r6, r6, #48 ; 0x30
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
300091c8: e2431030 sub r1, r3, #48 ; 0x30 300091cc: e3510009 cmp r1, #9
300091d0: 9afffff7 bls 300091b4 <vprintk+0x70>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
300091d4: e353006c cmp r3, #108 ; 0x6c
lflag = true;
c = *++fmt;
300091d8: 05fa3001 ldrbeq r3, [sl, #1]!
}
if ( c == 'c' ) {
300091dc: e3530063 cmp r3, #99 ; 0x63
300091e0: 0a00008c beq 30009418 <vprintk+0x2d4>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
BSP_output_char(chr);
continue;
}
if ( c == 's' ) {
300091e4: e3530073 cmp r3, #115 ; 0x73
300091e8: 0a000054 beq 30009340 <vprintk+0x1fc>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
300091ec: e353006f cmp r3, #111 ; 0x6f 300091f0: 1353004f cmpne r3, #79 ; 0x4f
base = 8; sign = false;
300091f4: 03a03000 moveq r3, #0 300091f8: 03a09008 moveq r9, #8
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
300091fc: 0a000009 beq 30009228 <vprintk+0xe4>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
30009200: e3530069 cmp r3, #105 ; 0x69 30009204: 13530049 cmpne r3, #73 ; 0x49
30009208: 0a000004 beq 30009220 <vprintk+0xdc>
c == 'd' || c == 'D' ) {
3000920c: e3530064 cmp r3, #100 ; 0x64 30009210: 13530044 cmpne r3, #68 ; 0x44 30009214: 13a01000 movne r1, #0 30009218: 03a01001 moveq r1, #1
3000921c: 1a000087 bne 30009440 <vprintk+0x2fc>
base = 10; sign = true;
30009220: e3a03001 mov r3, #1 30009224: e3a0900a mov r9, #10
} else {
BSP_output_char(c);
continue;
}
printNum(
30009228: e59d2000 ldr r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
3000922c: e3530000 cmp r3, #0
} else {
BSP_output_char(c);
continue;
}
printNum(
30009230: e5927000 ldr r7, [r2]
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
30009234: e2822004 add r2, r2, #4 30009238: e58d2000 str r2, [sp]
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
3000923c: 0a000001 beq 30009248 <vprintk+0x104>
30009240: e3570000 cmp r7, #0
30009244: ba000090 blt 3000948c <vprintk+0x348>
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30009248: e1a00007 mov r0, r7 3000924c: e1a01009 mov r1, r9 30009250: eb002d77 bl 30014834 <__aeabi_uidiv> 30009254: e3500000 cmp r0, #0 30009258: e1a04000 mov r4, r0 3000925c: e1a05000 mov r5, r0 30009260: 01a04007 moveq r4, r7 30009264: 03a07001 moveq r7, #1
30009268: 0a000010 beq 300092b0 <vprintk+0x16c>
3000926c: e20930ff and r3, r9, #255 ; 0xff 30009270: e1a02007 mov r2, r7
if (maxwidth) maxwidth--;
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
30009274: e3a05000 mov r5, #0 30009278: e1a07003 mov r7, r3 3000927c: ea000001 b 30009288 <vprintk+0x144>
while ((n = unsigned_num / base) > 0) {
30009280: e1a02004 mov r2, r4 30009284: e1a04000 mov r4, r0
toPrint[count++] = (char) (unsigned_num - (n * base));
30009288: e0030794 mul r3, r4, r7 3000928c: e0633002 rsb r3, r3, r2 30009290: e7cb3005 strb r3, [fp, r5]
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
30009294: e1a00004 mov r0, r4 30009298: e1a01009 mov r1, r9 3000929c: eb002d64 bl 30014834 <__aeabi_uidiv> 300092a0: e3500000 cmp r0, #0
toPrint[count++] = (char) (unsigned_num - (n * base));
300092a4: e2855001 add r5, r5, #1
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
300092a8: 1afffff4 bne 30009280 <vprintk+0x13c>
300092ac: e2857001 add r7, r5, #1
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
300092b0: e28d301c add r3, sp, #28 300092b4: e0835005 add r5, r3, r5
for (n=maxwidth ; n > count; n-- )
300092b8: e1570006 cmp r7, r6
count = 0;
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
300092bc: e5454014 strb r4, [r5, #-20]
for (n=maxwidth ; n > count; n-- )
300092c0: 2a000006 bcs 300092e0 <vprintk+0x19c>
300092c4: e59d4004 ldr r4, [sp, #4]
BSP_output_char(lead);
300092c8: e1a00004 mov r0, r4
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
300092cc: e2466001 sub r6, r6, #1
BSP_output_char(lead);
300092d0: e1a0e00f mov lr, pc 300092d4: e598f000 ldr pc, [r8]
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
300092d8: e1570006 cmp r7, r6
300092dc: 3afffff9 bcc 300092c8 <vprintk+0x184>
BSP_output_char(lead);
for (n = 0; n < count; n++) {
300092e0: e3570000 cmp r7, #0
300092e4: 0a000009 beq 30009310 <vprintk+0x1cc> * console is not yet initialized or in ISR's. * * Arguments: * as in printf: fmt - format string, ... - unnamed arguments. */ void vprintk(
300092e8: e08b5007 add r5, fp, r7 300092ec: e3a04000 mov r4, #0
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
300092f0: e5753001 ldrb r3, [r5, #-1]! 300092f4: e59f21b0 ldr r2, [pc, #432] ; 300094ac <vprintk+0x368>
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
300092f8: e2844001 add r4, r4, #1
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
300092fc: e7d20003 ldrb r0, [r2, r3] 30009300: e1a0e00f mov lr, pc 30009304: e598f000 ldr pc, [r8]
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
30009308: e1570004 cmp r7, r4
3000930c: 8afffff7 bhi 300092f0 <vprintk+0x1ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009310: e5fa0001 ldrb r0, [sl, #1]! 30009314: e3500000 cmp r0, #0
30009318: 1affff92 bne 30009168 <vprintk+0x24>
sign,
width,
lead
);
}
}
3000931c: e28dd01c add sp, sp, #28
30009320: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
30009324: e1a00003 mov r0, r3 30009328: e1a0e00f mov lr, pc 3000932c: e598f000 ldr pc, [r8]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009330: e5fa0001 ldrb r0, [sl, #1]! 30009334: e3500000 cmp r0, #0
30009338: 1affff8a bne 30009168 <vprintk+0x24>
3000933c: eafffff6 b 3000931c <vprintk+0x1d8>
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30009340: e59d2000 ldr r2, [sp] 30009344: e5925000 ldr r5, [r2] 30009348: e2823004 add r3, r2, #4
if ( str == NULL ) {
str = "";
3000934c: e59f215c ldr r2, [pc, #348] ; 300094b0 <vprintk+0x36c> 30009350: e3550000 cmp r5, #0 30009354: 01a05002 moveq r5, r2
}
if ( c == 's' ) {
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
30009358: e58d3000 str r3, [sp]
if ( str == NULL ) {
str = "";
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
3000935c: e5d54000 ldrb r4, [r5] 30009360: e3540000 cmp r4, #0
30009364: 0a000005 beq 30009380 <vprintk+0x23c>
30009368: e1a03005 mov r3, r5 3000936c: e3a04000 mov r4, #0 30009370: e5f32001 ldrb r2, [r3, #1]! 30009374: e2844001 add r4, r4, #1 30009378: e3520000 cmp r2, #0
3000937c: 1afffffb bne 30009370 <vprintk+0x22c>
;
/* leading spaces */
if ( !minus )
30009380: e3590000 cmp r9, #0
30009384: 1a000008 bne 300093ac <vprintk+0x268>
for ( i=len ; i<width ; i++ )
30009388: e1540006 cmp r4, r6
3000938c: 2a000006 bcs 300093ac <vprintk+0x268>
30009390: e1a07004 mov r7, r4
BSP_output_char(' ');
30009394: e3a00020 mov r0, #32
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
30009398: e2877001 add r7, r7, #1
BSP_output_char(' ');
3000939c: e1a0e00f mov lr, pc 300093a0: e598f000 ldr pc, [r8]
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
300093a4: e1570006 cmp r7, r6
300093a8: 3afffff9 bcc 30009394 <vprintk+0x250>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
300093ac: e3560000 cmp r6, #0
300093b0: 1a000002 bne 300093c0 <vprintk+0x27c>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
300093b4: e3540000 cmp r4, #0
300093b8: 0a000008 beq 300093e0 <vprintk+0x29c>
300093bc: e1a06004 mov r6, r4 300093c0: e5d50000 ldrb r0, [r5] 300093c4: e3500000 cmp r0, #0
300093c8: 0a000004 beq 300093e0 <vprintk+0x29c>
BSP_output_char(*str);
300093cc: e1a0e00f mov lr, pc 300093d0: e598f000 ldr pc, [r8]
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
300093d4: e5f50001 ldrb r0, [r5, #1]! 300093d8: e3500000 cmp r0, #0
300093dc: 1afffffa bne 300093cc <vprintk+0x288>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
300093e0: e3590000 cmp r9, #0
300093e4: 0affffc9 beq 30009310 <vprintk+0x1cc>
for ( i=len ; i<width ; i++ )
300093e8: e1540006 cmp r4, r6
300093ec: 2affffc7 bcs 30009310 <vprintk+0x1cc>
BSP_output_char(' ');
300093f0: e3a00020 mov r0, #32
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
300093f4: e2844001 add r4, r4, #1
BSP_output_char(' ');
300093f8: e1a0e00f mov lr, pc 300093fc: e598f000 ldr pc, [r8]
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
30009400: e1540006 cmp r4, r6
30009404: 3afffff9 bcc 300093f0 <vprintk+0x2ac>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009408: e5fa0001 ldrb r0, [sl, #1]! 3000940c: e3500000 cmp r0, #0
30009410: 1affff54 bne 30009168 <vprintk+0x24>
30009414: eaffffc0 b 3000931c <vprintk+0x1d8> <== NOT EXECUTED
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
30009418: e59d3000 ldr r3, [sp] 3000941c: e2834004 add r4, r3, #4
BSP_output_char(chr);
30009420: e5d30000 ldrb r0, [r3] 30009424: e1a0e00f mov lr, pc 30009428: e598f000 ldr pc, [r8]
lflag = true;
c = *++fmt;
}
if ( c == 'c' ) {
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
3000942c: e58d4000 str r4, [sp]
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
30009430: e5fa0001 ldrb r0, [sl, #1]! 30009434: e3500000 cmp r0, #0
30009438: 1affff4a bne 30009168 <vprintk+0x24>
3000943c: eaffffb6 b 3000931c <vprintk+0x1d8> <== NOT EXECUTED
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
30009440: e3530075 cmp r3, #117 ; 0x75 30009444: 13530055 cmpne r3, #85 ; 0x55 30009448: 13a00000 movne r0, #0 3000944c: 03a00001 moveq r0, #1
base = 10; sign = false;
30009450: 01a03001 moveq r3, r1 30009454: 03a0900a moveq r9, #10
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
30009458: 0affff72 beq 30009228 <vprintk+0xe4>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
3000945c: e3530078 cmp r3, #120 ; 0x78 30009460: 13530058 cmpne r3, #88 ; 0x58 30009464: 13a01000 movne r1, #0 30009468: 03a01001 moveq r1, #1
base = 16; sign = false;
3000946c: 01a03000 moveq r3, r0 30009470: 03a09010 moveq r9, #16
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
30009474: 0affff6b beq 30009228 <vprintk+0xe4>
base = 16; sign = false;
} else if ( c == 'p' ) {
30009478: e3530070 cmp r3, #112 ; 0x70
3000947c: 1affffa8 bne 30009324 <vprintk+0x1e0>
base = 16; sign = false; lflag = true;
30009480: e1a03001 mov r3, r1 30009484: e3a09010 mov r9, #16 30009488: eaffff66 b 30009228 <vprintk+0xe4>
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
3000948c: e3a0002d mov r0, #45 ; 0x2d 30009490: e1a0e00f mov lr, pc 30009494: e598f000 ldr pc, [r8]
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
30009498: e3560000 cmp r6, #0
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
unsigned_num = (unsigned long) -num;
3000949c: e2677000 rsb r7, r7, #0
if (maxwidth) maxwidth--;
300094a0: 12466001 subne r6, r6, #1 300094a4: eaffff67 b 30009248 <vprintk+0x104>
30016bf4 <write>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30016bf4: e59f30a4 ldr r3, [pc, #164] ; 30016ca0 <write+0xac>
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
30016bf8: e92d4010 push {r4, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
30016bfc: e5933000 ldr r3, [r3] 30016c00: e1500003 cmp r0, r3
30016c04: 2a00001b bcs 30016c78 <write+0x84> iop = rtems_libio_iop( fd );
30016c08: e59f4094 ldr r4, [pc, #148] ; 30016ca4 <write+0xb0> 30016c0c: e0600180 rsb r0, r0, r0, lsl #3 30016c10: e5944000 ldr r4, [r4] 30016c14: e0844180 add r4, r4, r0, lsl #3
rtems_libio_check_is_open( iop );
30016c18: e5940014 ldr r0, [r4, #20] 30016c1c: e3100c01 tst r0, #256 ; 0x100
30016c20: 0a000014 beq 30016c78 <write+0x84> rtems_libio_check_buffer( buffer );
30016c24: e3510000 cmp r1, #0
30016c28: 0a000017 beq 30016c8c <write+0x98> rtems_libio_check_count( count );
30016c2c: e3520000 cmp r2, #0
30016c30: 0a00000e beq 30016c70 <write+0x7c> rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30016c34: e3100004 tst r0, #4
30016c38: 0a000013 beq 30016c8c <write+0x98>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
30016c3c: e5943020 ldr r3, [r4, #32] 30016c40: e1a00004 mov r0, r4 30016c44: e1a0e00f mov lr, pc 30016c48: e593f00c ldr pc, [r3, #12]
if ( rc > 0 )
30016c4c: e3500000 cmp r0, #0
30016c50: d8bd8010 pople {r4, pc}
iop->offset += rc;
30016c54: e284300c add r3, r4, #12
30016c58: e893000c ldm r3, {r2, r3}
30016c5c: e0922000 adds r2, r2, r0
30016c60: e0a33fc0 adc r3, r3, r0, asr #31
30016c64: e584200c str r2, [r4, #12]
30016c68: e5843010 str r3, [r4, #16]
30016c6c: e8bd8010 pop {r4, pc}
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
30016c70: e1a00002 mov r0, r2 <== NOT EXECUTED
if ( rc > 0 )
iop->offset += rc;
return rc;
}
30016c74: e8bd8010 pop {r4, pc} <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
30016c78: ebffe92a bl 30011128 <__errno> <== NOT EXECUTED
30016c7c: e3a03009 mov r3, #9 <== NOT EXECUTED
30016c80: e5803000 str r3, [r0] <== NOT EXECUTED
30016c84: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016c88: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
30016c8c: ebffe925 bl 30011128 <__errno> <== NOT EXECUTED
30016c90: e3a03016 mov r3, #22 <== NOT EXECUTED
30016c94: e5803000 str r3, [r0] <== NOT EXECUTED
30016c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
30016c9c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
3000a944 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a944: e59f3158 ldr r3, [pc, #344] ; 3000aaa4 <writev+0x160> <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a948: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a94c: e5933000 ldr r3, [r3] <== NOT EXECUTED
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3000a950: e1a05002 mov r5, r2 <== NOT EXECUTED
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
3000a954: e1500003 cmp r0, r3 <== NOT EXECUTED 3000a958: 2a00004a bcs 3000aa88 <writev+0x144> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3000a95c: e59f3144 ldr r3, [pc, #324] ; 3000aaa8 <writev+0x164> <== NOT EXECUTED 3000a960: e0600180 rsb r0, r0, r0, lsl #3 <== NOT EXECUTED 3000a964: e5933000 ldr r3, [r3] <== NOT EXECUTED 3000a968: e0838180 add r8, r3, r0, lsl #3 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
3000a96c: e5983014 ldr r3, [r8, #20] <== NOT EXECUTED 3000a970: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3000a974: 0a000043 beq 3000aa88 <writev+0x144> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
3000a978: e3130004 tst r3, #4 <== NOT EXECUTED 3000a97c: 0a00003b beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
/*
* Argument validation on IO vector
*/
if ( !iov )
3000a980: e3510000 cmp r1, #0 <== NOT EXECUTED 3000a984: 0a000039 beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
3000a988: e3520000 cmp r2, #0 <== NOT EXECUTED 3000a98c: da000037 ble 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000a990: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 3000a994: ca000035 bgt 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
3000a998: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3000a99c: e3a01000 mov r1, #0 <== NOT EXECUTED 3000a9a0: e1a02004 mov r2, r4 <== NOT EXECUTED 3000a9a4: e3a06001 mov r6, #1 <== NOT EXECUTED 3000a9a8: e1a07001 mov r7, r1 <== NOT EXECUTED
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a9ac: e59fc0f8 ldr ip, [pc, #248] ; 3000aaac <writev+0x168> <== NOT EXECUTED 3000a9b0: ea000000 b 3000a9b8 <writev+0x74> <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a9b4: e1a07003 mov r7, r3 <== NOT EXECUTED
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
3000a9b8: e5923000 ldr r3, [r2] <== NOT EXECUTED
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
3000a9bc: e2811001 add r1, r1, #1 <== NOT EXECUTED
/*
* iov[v].iov_len cannot be less than 0 because size_t is unsigned.
* So we only check for zero.
*/
if ( iov[v].iov_base == 0 )
3000a9c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3000a9c4: 0a000029 beq 3000aa70 <writev+0x12c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
3000a9c8: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
3000a9cc: e2822008 add r2, r2, #8 <== NOT EXECUTED
if ( iov[v].iov_len )
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
3000a9d0: e0873000 add r3, r7, r0 <== NOT EXECUTED
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
3000a9d4: e3500000 cmp r0, #0 <== NOT EXECUTED 3000a9d8: 13a06000 movne r6, #0 <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
3000a9dc: e1570003 cmp r7, r3 <== NOT EXECUTED 3000a9e0: d153000c cmple r3, ip <== NOT EXECUTED 3000a9e4: d3a07000 movle r7, #0 <== NOT EXECUTED 3000a9e8: c3a07001 movgt r7, #1 <== NOT EXECUTED 3000a9ec: ca00001f bgt 3000aa70 <writev+0x12c> <== NOT EXECUTED
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
3000a9f0: e1550001 cmp r5, r1 <== NOT EXECUTED 3000a9f4: caffffee bgt 3000a9b4 <writev+0x70> <== NOT EXECUTED
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
3000a9f8: e3560000 cmp r6, #0 <== NOT EXECUTED 3000a9fc: 1a00001f bne 3000aa80 <writev+0x13c> <== NOT EXECUTED 3000aa00: e1a07006 mov r7, r6 <== NOT EXECUTED 3000aa04: ea000003 b 3000aa18 <writev+0xd4> <== NOT EXECUTED
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3000aa08: e2866001 add r6, r6, #1 <== NOT EXECUTED 3000aa0c: e1550006 cmp r5, r6 <== NOT EXECUTED 3000aa10: e2844008 add r4, r4, #8 <== NOT EXECUTED 3000aa14: da000019 ble 3000aa80 <writev+0x13c> <== NOT EXECUTED
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
3000aa18: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 3000aa1c: e3520000 cmp r2, #0 <== NOT EXECUTED 3000aa20: 0afffff8 beq 3000aa08 <writev+0xc4> <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
3000aa24: e5941000 ldr r1, [r4] <== NOT EXECUTED 3000aa28: e5983020 ldr r3, [r8, #32] <== NOT EXECUTED 3000aa2c: e1a00008 mov r0, r8 <== NOT EXECUTED 3000aa30: e1a0e00f mov lr, pc <== NOT EXECUTED 3000aa34: e593f00c ldr pc, [r3, #12] <== NOT EXECUTED
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
3000aa38: e3500000 cmp r0, #0 <== NOT EXECUTED 3000aa3c: ba000016 blt 3000aa9c <writev+0x158> <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
3000aa40: 0a000006 beq 3000aa60 <writev+0x11c> <== NOT EXECUTED
iop->offset += bytes;
3000aa44: e288300c add r3, r8, #12 <== NOT EXECUTED
3000aa48: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3000aa4c: e0922000 adds r2, r2, r0 <== NOT EXECUTED
3000aa50: e0a33fc0 adc r3, r3, r0, asr #31 <== NOT EXECUTED
3000aa54: e588200c str r2, [r8, #12] <== NOT EXECUTED
3000aa58: e5883010 str r3, [r8, #16] <== NOT EXECUTED
total += bytes;
3000aa5c: e0877000 add r7, r7, r0 <== NOT EXECUTED
}
if (bytes != iov[ v ].iov_len)
3000aa60: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 3000aa64: e1500003 cmp r0, r3 <== NOT EXECUTED 3000aa68: 0affffe6 beq 3000aa08 <writev+0xc4> <== NOT EXECUTED 3000aa6c: ea000003 b 3000aa80 <writev+0x13c> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
3000aa70: eb001dd6 bl 300121d0 <__errno> <== NOT EXECUTED 3000aa74: e3a03016 mov r3, #22 <== NOT EXECUTED 3000aa78: e5803000 str r3, [r0] <== NOT EXECUTED 3000aa7c: e3e07000 mvn r7, #0 <== NOT EXECUTED
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3000aa80: e1a00007 mov r0, r7 <== NOT EXECUTED
3000aa84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
3000aa88: eb001dd0 bl 300121d0 <__errno> <== NOT EXECUTED 3000aa8c: e3a03009 mov r3, #9 <== NOT EXECUTED 3000aa90: e5803000 str r3, [r0] <== NOT EXECUTED 3000aa94: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000aa98: eafffff8 b 3000aa80 <writev+0x13c> <== NOT EXECUTED
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
3000aa9c: e3e07000 mvn r7, #0 <== NOT EXECUTED 3000aaa0: eafffff6 b 3000aa80 <writev+0x13c> <== NOT EXECUTED