RTEMS 4.9Annotated Report
Wed Feb 9 12:56:19 2011
40008fd8 <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 ) {
40008fd8: c2 02 00 00 ld [ %o0 ], %g1
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
40008fdc: c4 02 20 0c ld [ %o0 + 0xc ], %g2
switch( node->type ) {
40008fe0: c2 00 60 48 ld [ %g1 + 0x48 ], %g1
40008fe4: 82 00 7f ff add %g1, -1, %g1
40008fe8: 80 a0 60 05 cmp %g1, 5
40008fec: 18 80 00 12 bgu 40009034 <IMFS_Set_handlers+0x5c> <== NEVER TAKEN
40008ff0: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3
40008ff4: 83 28 60 02 sll %g1, 2, %g1
40008ff8: 05 10 00 23 sethi %hi(0x40008c00), %g2
40008ffc: 84 10 a3 c0 or %g2, 0x3c0, %g2 ! 40008fc0 <miniIMFS_initialize+0x24>
40009000: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40009004: 81 c0 40 00 jmp %g1
40009008: 01 00 00 00 nop
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
4000900c: 10 80 00 09 b 40009030 <IMFS_Set_handlers+0x58>
40009010: c2 00 e0 08 ld [ %g3 + 8 ], %g1
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
40009014: 03 10 00 59 sethi %hi(0x40016400), %g1
40009018: 10 80 00 06 b 40009030 <IMFS_Set_handlers+0x58>
4000901c: 82 10 63 44 or %g1, 0x344, %g1 ! 40016744 <IMFS_device_handlers>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
40009020: 03 10 00 59 sethi %hi(0x40016400), %g1 <== NOT EXECUTED
40009024: 10 80 00 03 b 40009030 <IMFS_Set_handlers+0x58> <== NOT EXECUTED
40009028: 82 10 63 7c or %g1, 0x37c, %g1 ! 4001677c <IMFS_link_handlers><== NOT EXECUTED
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
4000902c: c2 00 e0 04 ld [ %g3 + 4 ], %g1 <== NOT EXECUTED
40009030: c2 22 20 04 st %g1, [ %o0 + 4 ]
break;
}
return 0;
}
40009034: 81 c3 e0 08 retl
40009038: 90 10 20 00 clr %o0
4000b948 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
4000b948: 9d e3 bf 90 save %sp, -112, %sp
IMFS_jnode_t *node;
struct timeval tv;
IMFS_jnode_t *parent = NULL;
IMFS_fs_info_t *fs_info;
if ( parent_loc != NULL )
4000b94c: a2 96 20 00 orcc %i0, 0, %l1
4000b950: 02 80 00 03 be 4000b95c <IMFS_create_node+0x14>
4000b954: a0 10 20 00 clr %l0
parent = parent_loc->node_access;
4000b958: e0 04 40 00 ld [ %l1 ], %l0
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
4000b95c: 90 10 20 01 mov 1, %o0
4000b960: 7f ff f9 08 call 40009d80 <calloc>
4000b964: 92 10 20 5c mov 0x5c, %o1
if ( !node )
4000b968: b0 92 20 00 orcc %o0, 0, %i0
4000b96c: 02 80 00 48 be 4000ba8c <IMFS_create_node+0x144> <== NEVER TAKEN
4000b970: 82 10 20 01 mov 1, %g1
* Fill in the basic information
*/
node->st_nlink = 1;
node->type = type;
strncpy( node->name, name, IMFS_NAME_MAX );
4000b974: 92 10 00 1a mov %i2, %o1
/*
* Fill in the basic information
*/
node->st_nlink = 1;
node->type = type;
4000b978: f2 26 20 48 st %i1, [ %i0 + 0x48 ]
strncpy( node->name, name, IMFS_NAME_MAX );
4000b97c: 94 10 20 20 mov 0x20, %o2
/*
* Fill in the basic information
*/
node->st_nlink = 1;
4000b980: c2 36 20 30 sth %g1, [ %i0 + 0x30 ]
node->type = type;
strncpy( node->name, name, IMFS_NAME_MAX );
4000b984: 40 00 07 34 call 4000d654 <strncpy>
4000b988: 90 06 20 0c add %i0, 0xc, %o0
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
4000b98c: 03 10 00 5d sethi %hi(0x40017400), %g1
4000b990: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 4001767c <rtems_current_user_env>
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
4000b994: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
4000b998: c2 10 60 24 lduh [ %g1 + 0x24 ], %g1
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
4000b99c: 92 10 20 00 clr %o1
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
4000b9a0: 82 2e c0 01 andn %i3, %g1, %g1
#if defined(RTEMS_POSIX_API)
node->st_uid = geteuid();
node->st_gid = getegid();
#else
node->st_uid = 0;
4000b9a4: c0 36 20 38 clrh [ %i0 + 0x38 ]
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
4000b9a8: c2 36 20 2e sth %g1, [ %i0 + 0x2e ]
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
4000b9ac: 7f ff f9 a6 call 4000a044 <gettimeofday>
4000b9b0: c0 36 20 3a clrh [ %i0 + 0x3a ]
node->stat_atime = (time_t) tv.tv_sec;
4000b9b4: c2 07 bf f0 ld [ %fp + -16 ], %g1
/*
* Set the type specific information
*/
switch (type) {
4000b9b8: b2 06 7f ff add %i1, -1, %i1
gettimeofday( &tv, 0 );
node->stat_atime = (time_t) tv.tv_sec;
node->stat_mtime = (time_t) tv.tv_sec;
node->stat_ctime = (time_t) tv.tv_sec;
4000b9bc: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
* Now set all the times.
*/
gettimeofday( &tv, 0 );
node->stat_atime = (time_t) tv.tv_sec;
4000b9c0: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
/*
* Set the type specific information
*/
switch (type) {
4000b9c4: 80 a6 60 05 cmp %i1, 5
4000b9c8: 18 80 00 1d bgu 4000ba3c <IMFS_create_node+0xf4> <== NEVER TAKEN
4000b9cc: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
4000b9d0: 83 2e 60 02 sll %i1, 2, %g1
4000b9d4: 05 10 00 2e sethi %hi(0x4000b800), %g2
4000b9d8: 84 10 a1 30 or %g2, 0x130, %g2 ! 4000b930 <device_open+0x4c>
4000b9dc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
4000b9e0: 81 c0 40 00 jmp %g1
4000b9e4: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
4000b9e8: 82 06 20 50 add %i0, 0x50, %g1
the_chain->permanent_null = NULL;
4000b9ec: c0 26 20 50 clr [ %i0 + 0x50 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
4000b9f0: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
4000b9f4: 82 06 20 4c add %i0, 0x4c, %g1
4000b9f8: 10 80 00 19 b 4000ba5c <IMFS_create_node+0x114>
4000b9fc: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
case IMFS_HARD_LINK:
node->info.hard_link.link_node = info->hard_link.link_node;
break;
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
4000ba00: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
4000ba04: 10 80 00 16 b 4000ba5c <IMFS_create_node+0x114> <== NOT EXECUTED
4000ba08: c2 26 20 4c st %g1, [ %i0 + 0x4c ] <== NOT EXECUTED
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
4000ba0c: c2 07 20 04 ld [ %i4 + 4 ], %g1
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
4000ba10: c4 07 00 00 ld [ %i4 ], %g2
node->info.device.minor = info->device.minor;
4000ba14: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
4000ba18: 10 80 00 11 b 4000ba5c <IMFS_create_node+0x114>
4000ba1c: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
node->info.device.minor = info->device.minor;
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
4000ba20: c0 26 20 4c clr [ %i0 + 0x4c ] <== NOT EXECUTED
node->info.linearfile.direct = 0;
4000ba24: c0 26 20 50 clr [ %i0 + 0x50 ] <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
4000ba28: c0 26 20 4c clr [ %i0 + 0x4c ] <== NOT EXECUTED
node->info.file.indirect = 0;
4000ba2c: c0 26 20 50 clr [ %i0 + 0x50 ] <== NOT EXECUTED
node->info.file.doubly_indirect = 0;
4000ba30: c0 26 20 54 clr [ %i0 + 0x54 ] <== NOT EXECUTED
node->info.file.triply_indirect = 0;
4000ba34: 10 80 00 0a b 4000ba5c <IMFS_create_node+0x114> <== NOT EXECUTED
4000ba38: c0 26 20 58 clr [ %i0 + 0x58 ] <== NOT EXECUTED
break;
default:
assert(0);
4000ba3c: 11 10 00 5a sethi %hi(0x40016800), %o0 <== NOT EXECUTED
4000ba40: 15 10 00 5a sethi %hi(0x40016800), %o2 <== NOT EXECUTED
4000ba44: 17 10 00 58 sethi %hi(0x40016000), %o3 <== NOT EXECUTED
4000ba48: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
4000ba4c: 94 12 a2 30 or %o2, 0x230, %o2 <== NOT EXECUTED
4000ba50: 96 12 e1 80 or %o3, 0x180, %o3 <== NOT EXECUTED
4000ba54: 7f ff d8 f9 call 40001e38 <__assert_func> <== NOT EXECUTED
4000ba58: 92 10 20 74 mov 0x74, %o1 <== NOT EXECUTED
/*
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
4000ba5c: 80 a4 20 00 cmp %l0, 0
4000ba60: 02 80 00 0b be 4000ba8c <IMFS_create_node+0x144>
4000ba64: 90 04 20 4c add %l0, 0x4c, %o0
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
4000ba68: 7f ff e8 f9 call 40005e4c <_Chain_Append>
4000ba6c: 92 10 00 18 mov %i0, %o1
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
node->Parent = parent;
fs_info = parent_loc->mt_entry->fs_info;
4000ba70: c2 04 60 0c ld [ %l1 + 0xc ], %g1
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
node->Parent = parent;
4000ba74: e0 26 20 08 st %l0, [ %i0 + 8 ]
fs_info = parent_loc->mt_entry->fs_info;
4000ba78: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
node->st_ino = ++fs_info->ino_count;
4000ba7c: c2 00 80 00 ld [ %g2 ], %g1
4000ba80: 82 00 60 01 inc %g1
4000ba84: c2 20 80 00 st %g1, [ %g2 ]
4000ba88: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
}
return node;
}
4000ba8c: 81 c7 e0 08 ret
4000ba90: 81 e8 00 00 restore
400091a8 <IMFS_eval_path>:
int IMFS_eval_path(
const char *pathname, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
400091a8: 9d e3 bf 60 save %sp, -160, %sp
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 ) ) {
400091ac: 80 8e 7f f8 btst -8, %i1
400091b0: 02 80 00 0a be 400091d8 <IMFS_eval_path+0x30> <== ALWAYS TAKEN
400091b4: a8 10 00 18 mov %i0, %l4
assert( 0 );
400091b8: 11 10 00 59 sethi %hi(0x40016400), %o0 <== NOT EXECUTED
400091bc: 15 10 00 59 sethi %hi(0x40016400), %o2 <== NOT EXECUTED
400091c0: 17 10 00 58 sethi %hi(0x40016000), %o3 <== NOT EXECUTED
400091c4: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
400091c8: 94 12 a2 58 or %o2, 0x258, %o2 <== NOT EXECUTED
400091cc: 96 12 e1 80 or %o3, 0x180, %o3 <== NOT EXECUTED
400091d0: 7f ff e3 1a call 40001e38 <__assert_func> <== NOT EXECUTED
400091d4: 92 10 21 ea mov 0x1ea, %o1 <== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
400091d8: 03 10 00 5d sethi %hi(0x40017400), %g1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
400091dc: e0 06 80 00 ld [ %i2 ], %l0
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
400091e0: ae 10 62 7c or %g1, 0x27c, %l7
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
400091e4: a6 10 20 00 clr %l3
400091e8: a2 10 20 01 mov 1, %l1
* 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], token, &len );
400091ec: aa 07 bf c0 add %fp, -64, %l5
400091f0: 10 80 00 6a b 40009398 <IMFS_eval_path+0x1f0>
400091f4: ac 07 bf f4 add %fp, -12, %l6
400091f8: 90 05 00 13 add %l4, %l3, %o0
400091fc: 92 10 00 15 mov %l5, %o1
40009200: 40 00 01 a0 call 40009880 <IMFS_get_token>
40009204: 94 10 00 16 mov %l6, %o2
i += len;
if ( !pathloc->node_access )
40009208: c2 06 80 00 ld [ %i2 ], %g1
* 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], token, &len );
4000920c: a2 10 00 08 mov %o0, %l1
i += len;
if ( !pathloc->node_access )
40009210: 80 a0 60 00 cmp %g1, 0
40009214: 02 80 00 57 be 40009370 <IMFS_eval_path+0x1c8> <== NEVER TAKEN
40009218: e4 07 bf f4 ld [ %fp + -12 ], %l2
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
4000921c: 80 a2 20 00 cmp %o0, 0
40009220: 22 80 00 10 be,a 40009260 <IMFS_eval_path+0xb8>
40009224: a6 04 c0 12 add %l3, %l2, %l3
if ( node->type == IMFS_DIRECTORY )
40009228: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
4000922c: 80 a0 60 01 cmp %g1, 1
40009230: 32 80 00 0c bne,a 40009260 <IMFS_eval_path+0xb8> <== NEVER TAKEN
40009234: a6 04 c0 12 add %l3, %l2, %l3 <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
40009238: 90 10 00 1a mov %i2, %o0
4000923c: 7f ff ff 80 call 4000903c <IMFS_evaluate_permission>
40009240: 92 10 20 01 mov 1, %o1
40009244: 80 a2 20 00 cmp %o0, 0
40009248: 32 80 00 06 bne,a 40009260 <IMFS_eval_path+0xb8> <== ALWAYS TAKEN
4000924c: a6 04 c0 12 add %l3, %l2, %l3
rtems_set_errno_and_return_minus_one( EACCES );
40009250: 40 00 0b bf call 4000c14c <__errno> <== NOT EXECUTED
40009254: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009258: 10 80 00 4d b 4000938c <IMFS_eval_path+0x1e4> <== NOT EXECUTED
4000925c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
node = pathloc->node_access;
switch( type ) {
40009260: 80 a4 60 03 cmp %l1, 3
40009264: 02 80 00 1b be 400092d0 <IMFS_eval_path+0x128>
40009268: e0 06 80 00 ld [ %i2 ], %l0
4000926c: 80 a4 60 04 cmp %l1, 4
40009270: 02 80 00 44 be 40009380 <IMFS_eval_path+0x1d8> <== NEVER TAKEN
40009274: 80 a4 60 02 cmp %l1, 2
40009278: 12 80 00 49 bne 4000939c <IMFS_eval_path+0x1f4> <== ALWAYS TAKEN
4000927c: 80 a4 60 00 cmp %l1, 0
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
40009280: c2 05 c0 00 ld [ %l7 ], %g1 <== NOT EXECUTED
40009284: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
40009288: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
4000928c: 02 bf ff dc be 400091fc <IMFS_eval_path+0x54> <== NOT EXECUTED
40009290: 90 05 00 13 add %l4, %l3, %o0 <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
40009294: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 <== NOT EXECUTED
40009298: c2 02 60 18 ld [ %o1 + 0x18 ], %g1 <== NOT EXECUTED
4000929c: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
400092a0: 32 80 00 04 bne,a 400092b0 <IMFS_eval_path+0x108> <== NOT EXECUTED
400092a4: e0 04 20 08 ld [ %l0 + 8 ], %l0 <== 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;
400092a8: 10 80 00 4a b 400093d0 <IMFS_eval_path+0x228> <== NOT EXECUTED
400092ac: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
}
} else {
if ( !node->Parent )
400092b0: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
400092b4: 32 bf ff d1 bne,a 400091f8 <IMFS_eval_path+0x50> <== NOT EXECUTED
400092b8: e0 26 80 00 st %l0, [ %i2 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
400092bc: 40 00 0b a4 call 4000c14c <__errno> <== NOT EXECUTED
400092c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400092c4: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
400092c8: 81 c7 e0 08 ret <== NOT EXECUTED
400092cc: 81 e8 00 00 restore <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
400092d0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
400092d4: 80 a0 60 03 cmp %g1, 3
400092d8: 12 80 00 0a bne 40009300 <IMFS_eval_path+0x158> <== ALWAYS TAKEN
400092dc: 80 a0 60 04 cmp %g1, 4
IMFS_evaluate_hard_link( pathloc, 0 );
400092e0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400092e4: 7f ff ff 67 call 40009080 <IMFS_evaluate_hard_link> <== NOT EXECUTED
400092e8: 92 10 20 00 clr %o1 <== NOT EXECUTED
node = pathloc->node_access;
400092ec: e0 06 80 00 ld [ %i2 ], %l0 <== NOT EXECUTED
if ( !node )
400092f0: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
400092f4: 32 80 00 0e bne,a 4000932c <IMFS_eval_path+0x184> <== NOT EXECUTED
400092f8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
400092fc: 30 80 00 0f b,a 40009338 <IMFS_eval_path+0x190> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
40009300: 32 80 00 0b bne,a 4000932c <IMFS_eval_path+0x184> <== ALWAYS TAKEN
40009304: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
result = IMFS_evaluate_sym_link( pathloc, 0 );
40009308: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000930c: 7f ff ff 75 call 400090e0 <IMFS_evaluate_sym_link> <== NOT EXECUTED
40009310: 92 10 20 00 clr %o1 <== NOT EXECUTED
40009314: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
node = pathloc->node_access;
if ( result == -1 )
40009318: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
4000931c: 02 bf ff eb be 400092c8 <IMFS_eval_path+0x120> <== NOT EXECUTED
40009320: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
40009324: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
40009328: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
4000932c: 80 a0 60 01 cmp %g1, 1
40009330: 22 80 00 06 be,a 40009348 <IMFS_eval_path+0x1a0> <== ALWAYS TAKEN
40009334: d2 04 20 58 ld [ %l0 + 0x58 ], %o1
rtems_set_errno_and_return_minus_one( ENOTDIR );
40009338: 40 00 0b 85 call 4000c14c <__errno> <== NOT EXECUTED
4000933c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009340: 10 80 00 13 b 4000938c <IMFS_eval_path+0x1e4> <== NOT EXECUTED
40009344: 82 10 20 14 mov 0x14, %g1 <== 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 ) {
40009348: 80 a2 60 00 cmp %o1, 0
4000934c: 02 80 00 04 be 4000935c <IMFS_eval_path+0x1b4> <== ALWAYS TAKEN
40009350: 90 10 00 10 mov %l0, %o0
newloc = node->info.directory.mt_fs->mt_fs_root;
40009354: 10 80 00 1f b 400093d0 <IMFS_eval_path+0x228> <== NOT EXECUTED
40009358: 92 02 60 18 add %o1, 0x18, %o1 <== NOT EXECUTED
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
4000935c: 40 00 01 1e call 400097d4 <IMFS_find_match_in_dir>
40009360: 92 10 00 15 mov %l5, %o1
if ( !node )
40009364: a0 92 20 00 orcc %o0, 0, %l0
40009368: 32 bf ff a4 bne,a 400091f8 <IMFS_eval_path+0x50> <== ALWAYS TAKEN
4000936c: e0 26 80 00 st %l0, [ %i2 ]
rtems_set_errno_and_return_minus_one( ENOENT );
40009370: 40 00 0b 77 call 4000c14c <__errno> <== NOT EXECUTED
40009374: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009378: 10 80 00 05 b 4000938c <IMFS_eval_path+0x1e4> <== NOT EXECUTED
4000937c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40009380: 40 00 0b 73 call 4000c14c <__errno> <== NOT EXECUTED
40009384: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009388: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
4000938c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009390: 81 c7 e0 08 ret <== NOT EXECUTED
40009394: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
40009398: 80 a4 60 00 cmp %l1, 0
4000939c: 22 80 00 06 be,a 400093b4 <IMFS_eval_path+0x20c>
400093a0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
400093a4: 80 a4 60 04 cmp %l1, 4
400093a8: 12 bf ff 95 bne 400091fc <IMFS_eval_path+0x54> <== ALWAYS TAKEN
400093ac: 90 05 00 13 add %l4, %l3, %o0
* 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 ) {
400093b0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
400093b4: 80 a0 60 01 cmp %g1, 1
400093b8: 12 80 00 18 bne 40009418 <IMFS_eval_path+0x270>
400093bc: 01 00 00 00 nop
if ( node->info.directory.mt_fs != NULL ) {
400093c0: d0 04 20 58 ld [ %l0 + 0x58 ], %o0
400093c4: 80 a2 20 00 cmp %o0, 0
400093c8: 02 80 00 14 be 40009418 <IMFS_eval_path+0x270> <== ALWAYS TAKEN
400093cc: 92 02 20 18 add %o0, 0x18, %o1
newloc = node->info.directory.mt_fs->mt_fs_root;
400093d0: a0 07 bf e4 add %fp, -28, %l0 <== NOT EXECUTED
400093d4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
400093d8: 40 00 0d 4f call 4000c914 <memcpy> <== NOT EXECUTED
400093dc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*pathloc = newloc;
400093e0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400093e4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
400093e8: 40 00 0d 4b call 4000c914 <memcpy> <== NOT EXECUTED
400093ec: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
400093f0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED
400093f4: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
400093f8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
400093fc: 90 24 c0 08 sub %l3, %o0, %o0 <== NOT EXECUTED
40009400: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40009404: 90 05 00 08 add %l4, %o0, %o0 <== NOT EXECUTED
40009408: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000940c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40009410: 81 c7 e0 08 ret <== NOT EXECUTED
40009414: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
40009418: 7f ff fe f0 call 40008fd8 <IMFS_Set_handlers>
4000941c: 90 10 00 1a mov %i2, %o0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
40009420: 92 10 00 19 mov %i1, %o1
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
40009424: b0 10 00 08 mov %o0, %i0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
40009428: 7f ff ff 05 call 4000903c <IMFS_evaluate_permission>
4000942c: 90 10 00 1a mov %i2, %o0
40009430: 80 a2 20 00 cmp %o0, 0
40009434: 12 80 00 06 bne 4000944c <IMFS_eval_path+0x2a4> <== ALWAYS TAKEN
40009438: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EACCES );
4000943c: 40 00 0b 44 call 4000c14c <__errno> <== NOT EXECUTED
40009440: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40009444: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
40009448: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
4000944c: 81 c7 e0 08 ret
40009450: 81 e8 00 00 restore
4000950c <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 */
)
{
4000950c: 9d e3 bf 60 save %sp, -160, %sp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
40009510: e0 06 40 00 ld [ %i1 ], %l0
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
40009514: 03 10 00 5d sethi %hi(0x40017400), %g1
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
40009518: a8 10 00 18 mov %i0, %l4
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
4000951c: ae 10 62 7c or %g1, 0x27c, %l7
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
40009520: a4 10 20 00 clr %l2
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
40009524: aa 07 bf c0 add %fp, -64, %l5
40009528: ac 07 bf f4 add %fp, -12, %l6
4000952c: 90 05 00 12 add %l4, %l2, %o0
40009530: 92 10 00 15 mov %l5, %o1
40009534: 40 00 00 d3 call 40009880 <IMFS_get_token>
40009538: 94 10 00 16 mov %l6, %o2
i += len;
if ( !pathloc->node_access )
4000953c: c2 06 40 00 ld [ %i1 ], %g1
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
40009540: a2 10 00 08 mov %o0, %l1
i += len;
if ( !pathloc->node_access )
40009544: 80 a0 60 00 cmp %g1, 0
40009548: 02 80 00 82 be 40009750 <IMFS_evaluate_for_make+0x244> <== NEVER TAKEN
4000954c: e6 07 bf f4 ld [ %fp + -12 ], %l3
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
40009550: 80 a2 20 00 cmp %o0, 0
40009554: 22 80 00 10 be,a 40009594 <IMFS_evaluate_for_make+0x88> <== NEVER TAKEN
40009558: a4 04 80 13 add %l2, %l3, %l2 <== NOT EXECUTED
if ( node->type == IMFS_DIRECTORY )
4000955c: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
40009560: 80 a0 60 01 cmp %g1, 1
40009564: 32 80 00 0c bne,a 40009594 <IMFS_evaluate_for_make+0x88> <== NEVER TAKEN
40009568: a4 04 80 13 add %l2, %l3, %l2 <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
4000956c: 90 10 00 19 mov %i1, %o0
40009570: 7f ff fe b3 call 4000903c <IMFS_evaluate_permission>
40009574: 92 10 20 01 mov 1, %o1
40009578: 80 a2 20 00 cmp %o0, 0
4000957c: 32 80 00 06 bne,a 40009594 <IMFS_evaluate_for_make+0x88> <== ALWAYS TAKEN
40009580: a4 04 80 13 add %l2, %l3, %l2
rtems_set_errno_and_return_minus_one( EACCES );
40009584: 40 00 0a f2 call 4000c14c <__errno> <== NOT EXECUTED
40009588: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000958c: 10 80 00 83 b 40009798 <IMFS_evaluate_for_make+0x28c> <== NOT EXECUTED
40009590: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
node = pathloc->node_access;
switch( type ) {
40009594: 80 a4 60 02 cmp %l1, 2
40009598: 02 80 00 0f be 400095d4 <IMFS_evaluate_for_make+0xc8> <== NEVER TAKEN
4000959c: e0 06 40 00 ld [ %i1 ], %l0
400095a0: 80 a4 60 02 cmp %l1, 2
400095a4: 18 80 00 07 bgu 400095c0 <IMFS_evaluate_for_make+0xb4>
400095a8: 80 a4 60 03 cmp %l1, 3
400095ac: 80 a4 60 00 cmp %l1, 0
400095b0: 02 80 00 56 be 40009708 <IMFS_evaluate_for_make+0x1fc> <== NEVER TAKEN
400095b4: 01 00 00 00 nop
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
400095b8: 10 bf ff de b 40009530 <IMFS_evaluate_for_make+0x24>
400095bc: 90 05 00 12 add %l4, %l2, %o0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
400095c0: 02 80 00 19 be 40009624 <IMFS_evaluate_for_make+0x118> <== ALWAYS TAKEN
400095c4: 80 a4 60 04 cmp %l1, 4
400095c8: 32 bf ff da bne,a 40009530 <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
400095cc: 90 05 00 12 add %l4, %l2, %o0 <== NOT EXECUTED
400095d0: 30 80 00 52 b,a 40009718 <IMFS_evaluate_for_make+0x20c> <== NOT EXECUTED
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
400095d4: c2 05 c0 00 ld [ %l7 ], %g1 <== NOT EXECUTED
400095d8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
400095dc: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
400095e0: 02 bf ff d4 be 40009530 <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
400095e4: 90 05 00 12 add %l4, %l2, %o0 <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
400095e8: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
400095ec: c2 02 60 18 ld [ %o1 + 0x18 ], %g1 <== NOT EXECUTED
400095f0: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
400095f4: 32 80 00 04 bne,a 40009604 <IMFS_evaluate_for_make+0xf8> <== NOT EXECUTED
400095f8: e0 04 20 08 ld [ %l0 + 8 ], %l0 <== NOT EXECUTED
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
400095fc: 10 80 00 2a b 400096a4 <IMFS_evaluate_for_make+0x198> <== NOT EXECUTED
40009600: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
40009604: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
40009608: 32 bf ff c9 bne,a 4000952c <IMFS_evaluate_for_make+0x20> <== NOT EXECUTED
4000960c: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
40009610: 40 00 0a cf call 4000c14c <__errno> <== NOT EXECUTED
40009614: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009618: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
4000961c: 81 c7 e0 08 ret <== NOT EXECUTED
40009620: 81 e8 00 00 restore <== NOT EXECUTED
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
40009624: d0 04 20 48 ld [ %l0 + 0x48 ], %o0
40009628: 80 a2 20 03 cmp %o0, 3
4000962c: 12 80 00 0a bne 40009654 <IMFS_evaluate_for_make+0x148> <== ALWAYS TAKEN
40009630: 80 a2 20 04 cmp %o0, 4
result = IMFS_evaluate_link( pathloc, 0 );
40009634: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40009638: 7f ff ff 87 call 40009454 <IMFS_evaluate_link> <== NOT EXECUTED
4000963c: 92 10 20 00 clr %o1 <== NOT EXECUTED
if ( result == -1 )
40009640: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40009644: 12 80 00 0c bne 40009674 <IMFS_evaluate_for_make+0x168> <== NOT EXECUTED
40009648: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000964c: 81 c7 e0 08 ret <== NOT EXECUTED
40009650: 81 e8 00 00 restore <== NOT EXECUTED
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
40009654: 32 80 00 09 bne,a 40009678 <IMFS_evaluate_for_make+0x16c><== ALWAYS TAKEN
40009658: d0 06 40 00 ld [ %i1 ], %o0
result = IMFS_evaluate_link( pathloc, 0 );
4000965c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40009660: 7f ff ff 7d call 40009454 <IMFS_evaluate_link> <== NOT EXECUTED
40009664: 92 10 20 00 clr %o1 <== NOT EXECUTED
if ( result == -1 )
40009668: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
4000966c: 02 bf ff ec be 4000961c <IMFS_evaluate_for_make+0x110> <== NOT EXECUTED
40009670: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return -1;
}
node = pathloc->node_access;
40009674: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED
if ( !node )
40009678: 80 a2 20 00 cmp %o0, 0
4000967c: 02 80 00 44 be 4000978c <IMFS_evaluate_for_make+0x280> <== NEVER TAKEN
40009680: 01 00 00 00 nop
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
40009684: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
40009688: 80 a0 60 01 cmp %g1, 1
4000968c: 12 80 00 40 bne 4000978c <IMFS_evaluate_for_make+0x280> <== NEVER TAKEN
40009690: 01 00 00 00 nop
/*
* 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 ) {
40009694: d2 02 20 58 ld [ %o0 + 0x58 ], %o1
40009698: 80 a2 60 00 cmp %o1, 0
4000969c: 02 80 00 14 be 400096ec <IMFS_evaluate_for_make+0x1e0> <== ALWAYS TAKEN
400096a0: 92 02 60 18 add %o1, 0x18, %o1
newloc = node->info.directory.mt_fs->mt_fs_root;
400096a4: a0 07 bf e4 add %fp, -28, %l0 <== NOT EXECUTED
400096a8: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
400096ac: 40 00 0c 9a call 4000c914 <memcpy> <== NOT EXECUTED
400096b0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*pathloc = newloc;
400096b4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400096b8: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
400096bc: 40 00 0c 96 call 4000c914 <memcpy> <== NOT EXECUTED
400096c0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
400096c4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
400096c8: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
400096cc: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
400096d0: 90 24 80 08 sub %l2, %o0, %o0 <== NOT EXECUTED
400096d4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400096d8: 90 05 00 08 add %l4, %o0, %o0 <== NOT EXECUTED
400096dc: 9f c0 40 00 call %g1 <== NOT EXECUTED
400096e0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
400096e4: 81 c7 e0 08 ret <== NOT EXECUTED
400096e8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
400096ec: 40 00 00 3a call 400097d4 <IMFS_find_match_in_dir>
400096f0: 92 10 00 15 mov %l5, %o1
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
400096f4: a0 92 20 00 orcc %o0, 0, %l0
400096f8: 02 80 00 0c be 40009728 <IMFS_evaluate_for_make+0x21c>
400096fc: c2 07 bf f4 ld [ %fp + -12 ], %g1
done = true;
else
pathloc->node_access = node;
40009700: 10 bf ff 8b b 4000952c <IMFS_evaluate_for_make+0x20>
40009704: e0 26 40 00 st %l0, [ %i1 ]
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
40009708: 40 00 0a 91 call 4000c14c <__errno> <== NOT EXECUTED
4000970c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009710: 10 80 00 22 b 40009798 <IMFS_evaluate_for_make+0x28c> <== NOT EXECUTED
40009714: 82 10 20 11 mov 0x11, %g1 <== NOT EXECUTED
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40009718: 40 00 0a 8d call 4000c14c <__errno> <== NOT EXECUTED
4000971c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009720: 10 80 00 1e b 40009798 <IMFS_evaluate_for_make+0x28c> <== NOT EXECUTED
40009724: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
40009728: 84 05 00 12 add %l4, %l2, %g2
4000972c: 82 24 80 01 sub %l2, %g1, %g1
40009730: 82 05 00 01 add %l4, %g1, %g1
40009734: 10 80 00 0b b 40009760 <IMFS_evaluate_for_make+0x254>
40009738: c2 26 80 00 st %g1, [ %i2 ]
* 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++) {
if ( !IMFS_is_separator( path[ i ] ) )
4000973c: 80 a0 60 2f cmp %g1, 0x2f <== NOT EXECUTED
40009740: 02 80 00 08 be 40009760 <IMFS_evaluate_for_make+0x254> <== NOT EXECUTED
40009744: 80 a0 60 5c cmp %g1, 0x5c <== NOT EXECUTED
40009748: 22 80 00 07 be,a 40009764 <IMFS_evaluate_for_make+0x258> <== NOT EXECUTED
4000974c: c2 48 80 00 ldsb [ %g2 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
40009750: 40 00 0a 7f call 4000c14c <__errno> <== NOT EXECUTED
40009754: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009758: 10 80 00 10 b 40009798 <IMFS_evaluate_for_make+0x28c> <== NOT EXECUTED
4000975c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
/*
* 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++) {
40009760: c2 48 80 00 ldsb [ %g2 ], %g1
40009764: 80 a0 60 00 cmp %g1, 0
40009768: 12 bf ff f5 bne 4000973c <IMFS_evaluate_for_make+0x230> <== NEVER TAKEN
4000976c: 84 00 a0 01 inc %g2
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
40009770: 7f ff fe 1a call 40008fd8 <IMFS_Set_handlers>
40009774: 90 10 00 19 mov %i1, %o0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
40009778: c2 06 40 00 ld [ %i1 ], %g1
4000977c: c2 00 60 48 ld [ %g1 + 0x48 ], %g1
40009780: 80 a0 60 01 cmp %g1, 1
40009784: 02 80 00 08 be 400097a4 <IMFS_evaluate_for_make+0x298> <== ALWAYS TAKEN
40009788: b0 10 00 08 mov %o0, %i0
rtems_set_errno_and_return_minus_one( ENOTDIR );
4000978c: 40 00 0a 70 call 4000c14c <__errno> <== NOT EXECUTED
40009790: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009794: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
40009798: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000979c: 81 c7 e0 08 ret <== NOT EXECUTED
400097a0: 81 e8 00 00 restore <== NOT EXECUTED
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
400097a4: 90 10 00 19 mov %i1, %o0
400097a8: 7f ff fe 25 call 4000903c <IMFS_evaluate_permission>
400097ac: 92 10 20 03 mov 3, %o1
400097b0: 80 a2 20 00 cmp %o0, 0
400097b4: 12 80 00 06 bne 400097cc <IMFS_evaluate_for_make+0x2c0> <== ALWAYS TAKEN
400097b8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EACCES );
400097bc: 40 00 0a 64 call 4000c14c <__errno> <== NOT EXECUTED
400097c0: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400097c4: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
400097c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
400097cc: 81 c7 e0 08 ret
400097d0: 81 e8 00 00 restore
40009080 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
40009080: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
40009084: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
40009088: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 <== NOT EXECUTED
4000908c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
40009090: 22 80 00 04 be,a 400090a0 <IMFS_evaluate_hard_link+0x20> <== NOT EXECUTED
40009094: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
40009098: 7f ff f2 94 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000909c: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
IMFS_Set_handlers( node );
400090a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400090a4: 7f ff ff cd call 40008fd8 <IMFS_Set_handlers> <== NOT EXECUTED
400090a8: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
400090ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400090b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400090b4: 7f ff ff e2 call 4000903c <IMFS_evaluate_permission> <== NOT EXECUTED
400090b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
400090bc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400090c0: 12 80 00 06 bne 400090d8 <IMFS_evaluate_hard_link+0x58> <== NOT EXECUTED
400090c4: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
400090c8: 40 00 0c 21 call 4000c14c <__errno> <== NOT EXECUTED
400090cc: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
400090d0: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
400090d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
400090d8: 81 c7 e0 08 ret <== NOT EXECUTED
400090dc: 81 e8 00 00 restore <== NOT EXECUTED
40009454 <IMFS_evaluate_link>:
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
40009454: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
40009458: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
4000945c: a2 10 62 7c or %g1, 0x27c, %l1 ! 4001767c <rtems_current_user_env><== NOT EXECUTED
40009460: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
40009464: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
40009468: c2 10 a0 26 lduh [ %g2 + 0x26 ], %g1 <== NOT EXECUTED
4000946c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40009470: c2 30 a0 26 sth %g1, [ %g2 + 0x26 ] <== NOT EXECUTED
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
40009474: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
40009478: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
4000947c: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED
40009480: 28 80 00 08 bleu,a 400094a0 <IMFS_evaluate_link+0x4c> <== NOT EXECUTED
40009484: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
40009488: 40 00 0b 31 call 4000c14c <__errno> <== NOT EXECUTED
4000948c: c0 30 a0 26 clrh [ %g2 + 0x26 ] <== NOT EXECUTED
40009490: 82 10 20 5c mov 0x5c, %g1 <== NOT EXECUTED
40009494: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009498: 10 80 00 1b b 40009504 <IMFS_evaluate_link+0xb0> <== NOT EXECUTED
4000949c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
400094a0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
400094a4: 32 80 00 07 bne,a 400094c0 <IMFS_evaluate_link+0x6c> <== NOT EXECUTED
400094a8: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
result = IMFS_evaluate_hard_link( node, flags );
400094ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400094b0: 7f ff fe f4 call 40009080 <IMFS_evaluate_hard_link> <== NOT EXECUTED
400094b4: 92 10 00 19 mov %i1, %o1 <== 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 ) ) );
400094b8: 10 80 00 08 b 400094d8 <IMFS_evaluate_link+0x84> <== NOT EXECUTED
400094bc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
400094c0: 32 80 00 09 bne,a 400094e4 <IMFS_evaluate_link+0x90> <== NOT EXECUTED
400094c4: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
result = IMFS_evaluate_sym_link( node, flags );
400094c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400094cc: 7f ff ff 05 call 400090e0 <IMFS_evaluate_sym_link> <== NOT EXECUTED
400094d0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
400094d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400094d8: 12 80 00 09 bne 400094fc <IMFS_evaluate_link+0xa8> <== NOT EXECUTED
400094dc: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
400094e0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
400094e4: 82 00 7f fd add %g1, -3, %g1 <== NOT EXECUTED
400094e8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
400094ec: 28 bf ff de bleu,a 40009464 <IMFS_evaluate_link+0x10> <== NOT EXECUTED
400094f0: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED
400094f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
400094f8: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
400094fc: c2 00 62 7c ld [ %g1 + 0x27c ], %g1 ! 4001767c <rtems_current_user_env><== NOT EXECUTED
40009500: c0 30 60 26 clrh [ %g1 + 0x26 ] <== NOT EXECUTED
return result;
}
40009504: 81 c7 e0 08 ret <== NOT EXECUTED
40009508: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000903c <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
4000903c: 9d e3 bf 98 save %sp, -104, %sp
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
40009040: 80 8e 7f f8 btst -8, %i1
40009044: 22 80 00 08 be,a 40009064 <IMFS_evaluate_permission+0x28><== ALWAYS TAKEN
40009048: c2 06 00 00 ld [ %i0 ], %g1
rtems_set_errno_and_return_minus_one( EPERM );
4000904c: 40 00 0c 40 call 4000c14c <__errno> <== NOT EXECUTED
40009050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009054: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40009058: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000905c: 81 c7 e0 08 ret <== NOT EXECUTED
40009060: 81 e8 00 00 restore <== NOT EXECUTED
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
40009064: 85 2e 60 06 sll %i1, 6, %g2
40009068: c2 10 60 2e lduh [ %g1 + 0x2e ], %g1
4000906c: 82 28 80 01 andn %g2, %g1, %g1
40009070: 80 a0 00 01 cmp %g0, %g1
40009074: b0 60 3f ff subx %g0, -1, %i0
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
40009078: 81 c7 e0 08 ret
4000907c: 81 e8 00 00 restore
400090e0 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
400090e0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
400090e4: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
400090e8: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
400090ec: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
400090f0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
400090f4: 12 80 00 07 bne 40009110 <IMFS_evaluate_sym_link+0x30> <== NOT EXECUTED
400090f8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
400090fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
40009100: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009104: 32 80 00 05 bne,a 40009118 <IMFS_evaluate_sym_link+0x38> <== NOT EXECUTED
40009108: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
rtems_fatal_error_occurred( 0xBAD00000 );
4000910c: 11 2e b4 00 sethi %hi(0xbad00000), %o0 <== NOT EXECUTED
40009110: 7f ff f2 76 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40009114: 01 00 00 00 nop <== NOT EXECUTED
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
rtems_filesystem_get_sym_start_loc(
40009118: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 <== NOT EXECUTED
4000911c: c2 48 40 00 ldsb [ %g1 ], %g1 <== NOT EXECUTED
40009120: 80 a0 60 2f cmp %g1, 0x2f <== NOT EXECUTED
40009124: 02 80 00 06 be 4000913c <IMFS_evaluate_sym_link+0x5c> <== NOT EXECUTED
40009128: 80 a0 60 5c cmp %g1, 0x5c <== NOT EXECUTED
4000912c: 02 80 00 04 be 4000913c <IMFS_evaluate_sym_link+0x5c> <== NOT EXECUTED
40009130: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009134: 12 80 00 09 bne 40009158 <IMFS_evaluate_sym_link+0x78> <== NOT EXECUTED
40009138: 82 10 20 00 clr %g1 <== NOT EXECUTED
4000913c: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40009140: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 ! 4001767c <rtems_current_user_env><== NOT EXECUTED
40009144: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40009148: 92 02 60 14 add %o1, 0x14, %o1 <== NOT EXECUTED
4000914c: 40 00 0d f2 call 4000c914 <memcpy> <== NOT EXECUTED
40009150: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
40009154: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
40009158: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 <== NOT EXECUTED
4000915c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40009160: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
40009164: 40 00 00 11 call 400091a8 <IMFS_eval_path> <== NOT EXECUTED
40009168: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000916c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
&jnode->info.sym_link.name[i],
flags,
node
);
IMFS_Set_handlers( node );
40009170: 7f ff ff 9a call 40008fd8 <IMFS_Set_handlers> <== NOT EXECUTED
40009174: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
40009178: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4000917c: 7f ff ff b0 call 4000903c <IMFS_evaluate_permission> <== NOT EXECUTED
40009180: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40009184: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009188: 12 80 00 06 bne 400091a0 <IMFS_evaluate_sym_link+0xc0> <== NOT EXECUTED
4000918c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
40009190: 40 00 0b ef call 4000c14c <__errno> <== NOT EXECUTED
40009194: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40009198: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
4000919c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
400091a0: 81 c7 e0 08 ret <== NOT EXECUTED
400091a4: 81 e8 00 00 restore <== NOT EXECUTED
4000ba94 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
4000ba94: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
#endif
/*
* Change only the RWX permissions on the jnode to mode.
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
4000ba98: 83 2e 60 10 sll %i1, 0x10, %g1 <== NOT EXECUTED
4000ba9c: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
4000baa0: 82 08 7e 00 and %g1, -512, %g1 <== NOT EXECUTED
4000baa4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000baa8: 02 80 00 08 be 4000bac8 <IMFS_fchmod+0x34> <== NOT EXECUTED
4000baac: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
4000bab0: 40 00 01 a7 call 4000c14c <__errno> <== NOT EXECUTED
4000bab4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000bab8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000babc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000bac0: 81 c7 e0 08 ret <== NOT EXECUTED
4000bac4: 81 e8 00 00 restore <== NOT EXECUTED
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
4000bac8: c2 14 20 2e lduh [ %l0 + 0x2e ], %g1 <== NOT EXECUTED
IMFS_update_ctime( jnode );
4000bacc: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
rtems_set_errno_and_return_minus_one( EPERM );
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
4000bad0: 82 08 7e 00 and %g1, -512, %g1 <== NOT EXECUTED
4000bad4: 82 16 40 01 or %i1, %g1, %g1 <== NOT EXECUTED
IMFS_update_ctime( jnode );
4000bad8: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000badc: 7f ff f9 5a call 4000a044 <gettimeofday> <== NOT EXECUTED
4000bae0: c2 34 20 2e sth %g1, [ %l0 + 0x2e ] <== NOT EXECUTED
4000bae4: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
4000bae8: c2 24 20 44 st %g1, [ %l0 + 0x44 ] <== NOT EXECUTED
return 0;
}
4000baec: 81 c7 e0 08 ret <== NOT EXECUTED
4000baf0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
400097d4 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
400097d4: 9d e3 bf 98 save %sp, -104, %sp
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
400097d8: 80 a6 20 00 cmp %i0, 0
400097dc: 12 80 00 0a bne 40009804 <IMFS_find_match_in_dir+0x30> <== ALWAYS TAKEN
400097e0: 80 a6 60 00 cmp %i1, 0
400097e4: 11 10 00 59 sethi %hi(0x40016400), %o0 <== NOT EXECUTED
400097e8: 15 10 00 59 sethi %hi(0x40016400), %o2 <== NOT EXECUTED
400097ec: 17 10 00 59 sethi %hi(0x40016400), %o3 <== NOT EXECUTED
400097f0: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
400097f4: 94 12 a3 28 or %o2, 0x328, %o2 <== NOT EXECUTED
400097f8: 96 12 e3 08 or %o3, 0x308, %o3 <== NOT EXECUTED
400097fc: 7f ff e1 8f call 40001e38 <__assert_func> <== NOT EXECUTED
40009800: 92 10 20 2a mov 0x2a, %o1 <== NOT EXECUTED
if ( !name )
40009804: 02 80 00 1c be 40009874 <IMFS_find_match_in_dir+0xa0> <== NEVER TAKEN
40009808: 90 10 00 19 mov %i1, %o0
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
4000980c: 13 10 00 59 sethi %hi(0x40016400), %o1
40009810: 40 00 0f 1f call 4000d48c <strcmp>
40009814: 92 12 63 18 or %o1, 0x318, %o1 ! 40016718 <dotname>
40009818: 80 a2 20 00 cmp %o0, 0
4000981c: 02 80 00 09 be 40009840 <IMFS_find_match_in_dir+0x6c> <== NEVER TAKEN
40009820: 90 10 00 19 mov %i1, %o0
return directory;
if ( !strcmp( name, dotdotname ) )
40009824: 13 10 00 59 sethi %hi(0x40016400), %o1
40009828: 40 00 0f 19 call 4000d48c <strcmp>
4000982c: 92 12 63 20 or %o1, 0x320, %o1 ! 40016720 <dotdotname>
40009830: 80 a2 20 00 cmp %o0, 0
40009834: 12 80 00 05 bne 40009848 <IMFS_find_match_in_dir+0x74> <== ALWAYS TAKEN
40009838: a0 06 20 50 add %i0, 0x50, %l0
return directory->Parent;
4000983c: f0 06 20 08 ld [ %i0 + 8 ], %i0
40009840: 81 c7 e0 08 ret <== NOT EXECUTED
40009844: 81 e8 00 00 restore <== NOT EXECUTED
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
40009848: 10 80 00 08 b 40009868 <IMFS_find_match_in_dir+0x94>
4000984c: f0 06 20 4c ld [ %i0 + 0x4c ], %i0
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
40009850: 40 00 0f 0f call 4000d48c <strcmp>
40009854: 92 06 20 0c add %i0, 0xc, %o1
40009858: 80 a2 20 00 cmp %o0, 0
4000985c: 02 80 00 07 be 40009878 <IMFS_find_match_in_dir+0xa4>
40009860: 01 00 00 00 nop
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
40009864: f0 06 00 00 ld [ %i0 ], %i0
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
40009868: 80 a6 00 10 cmp %i0, %l0
4000986c: 12 bf ff f9 bne 40009850 <IMFS_find_match_in_dir+0x7c>
40009870: 90 10 00 19 mov %i1, %o0
40009874: b0 10 20 00 clr %i0
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
40009878: 81 c7 e0 08 ret
4000987c: 81 e8 00 00 restore
40009880 <IMFS_get_token>:
IMFS_token_types IMFS_get_token(
const char *path,
char *token,
int *token_len
)
{
40009880: 9d e3 bf 98 save %sp, -104, %sp
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
40009884: 84 10 20 00 clr %g2
40009888: 10 80 00 07 b 400098a4 <IMFS_get_token+0x24>
4000988c: c6 0e 00 00 ldub [ %i0 ], %g3
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
40009890: 12 80 00 04 bne 400098a0 <IMFS_get_token+0x20> <== ALWAYS TAKEN
40009894: 84 00 a0 01 inc %g2
40009898: 81 c7 e0 08 ret <== NOT EXECUTED
4000989c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
400098a0: c6 0e 00 02 ldub [ %i0 + %g2 ], %g3
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
400098a4: 83 28 e0 18 sll %g3, 0x18, %g1
400098a8: 83 38 60 18 sra %g1, 0x18, %g1
400098ac: 80 a0 60 2f cmp %g1, 0x2f
400098b0: 02 80 00 09 be 400098d4 <IMFS_get_token+0x54>
400098b4: 80 a0 60 5c cmp %g1, 0x5c
400098b8: 02 80 00 07 be 400098d4 <IMFS_get_token+0x54> <== NEVER TAKEN
400098bc: 80 a0 60 00 cmp %g1, 0
400098c0: 02 80 00 06 be 400098d8 <IMFS_get_token+0x58>
400098c4: 80 a0 a0 00 cmp %g2, 0
400098c8: 80 a0 a0 20 cmp %g2, 0x20
400098cc: 24 bf ff f1 ble,a 40009890 <IMFS_get_token+0x10> <== ALWAYS TAKEN
400098d0: c6 2e 40 02 stb %g3, [ %i1 + %g2 ]
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
400098d4: 80 a0 a0 00 cmp %g2, 0
400098d8: 12 80 00 0a bne 40009900 <IMFS_get_token+0x80>
400098dc: 82 06 40 02 add %i1, %g2, %g1
token[i] = c;
400098e0: c6 2e 40 00 stb %g3, [ %i1 ]
if ( token[i] != '\0' ) {
400098e4: 83 28 e0 18 sll %g3, 0x18, %g1
400098e8: 80 a0 60 00 cmp %g1, 0
400098ec: 02 80 00 0b be 40009918 <IMFS_get_token+0x98>
400098f0: b0 10 20 00 clr %i0
400098f4: 84 10 20 01 mov 1, %g2
400098f8: 10 80 00 08 b 40009918 <IMFS_get_token+0x98>
400098fc: b0 10 20 01 mov 1, %i0
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
40009900: c2 48 7f ff ldsb [ %g1 + -1 ], %g1
40009904: 80 a0 60 00 cmp %g1, 0
40009908: 02 80 00 04 be 40009918 <IMFS_get_token+0x98> <== NEVER TAKEN
4000990c: b0 10 20 03 mov 3, %i0
token[i] = '\0';
40009910: c0 2e 40 02 clrb [ %i1 + %g2 ]
40009914: b0 10 20 03 mov 3, %i0
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
40009918: 80 a6 20 03 cmp %i0, 3
4000991c: 12 80 00 11 bne 40009960 <IMFS_get_token+0xe0>
40009920: c4 26 80 00 st %g2, [ %i2 ]
if ( strcmp( token, "..") == 0 )
40009924: 90 10 00 19 mov %i1, %o0
40009928: 13 10 00 59 sethi %hi(0x40016400), %o1
4000992c: 40 00 0e d8 call 4000d48c <strcmp>
40009930: 92 12 60 08 or %o1, 8, %o1 ! 40016408 <__func__.4755+0x280>
40009934: 80 a2 20 00 cmp %o0, 0
40009938: 12 80 00 04 bne 40009948 <IMFS_get_token+0xc8> <== ALWAYS TAKEN
4000993c: 90 10 00 19 mov %i1, %o0
40009940: 81 c7 e0 08 ret <== NOT EXECUTED
40009944: 91 e8 20 02 restore %g0, 2, %o0 <== NOT EXECUTED
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
40009948: 13 10 00 59 sethi %hi(0x40016400), %o1
4000994c: 40 00 0e d0 call 4000d48c <strcmp>
40009950: 92 12 63 40 or %o1, 0x340, %o1 ! 40016740 <__func__.5177+0x18>
40009954: 80 a2 20 00 cmp %o0, 0
40009958: 22 80 00 02 be,a 40009960 <IMFS_get_token+0xe0> <== NEVER TAKEN
4000995c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
type = IMFS_CURRENT_DIR;
}
return type;
}
40009960: 81 c7 e0 08 ret
40009964: 81 e8 00 00 restore
40009968 <IMFS_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
40009968: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
4000996c: 03 10 00 5c sethi %hi(0x40017000), %g1
40009970: 84 10 20 10 mov 0x10, %g2
40009974: c6 00 61 5c ld [ %g1 + 0x15c ], %g3
40009978: 82 10 20 00 clr %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
4000997c: 80 a0 80 03 cmp %g2, %g3
40009980: 02 80 00 06 be 40009998 <IMFS_initialize_support+0x30>
40009984: 82 00 60 01 inc %g1
40009988: 80 a0 60 06 cmp %g1, 6
4000998c: 12 bf ff fc bne 4000997c <IMFS_initialize_support+0x14> <== ALWAYS TAKEN
40009990: 85 28 a0 01 sll %g2, 1, %g2
40009994: 84 10 20 80 mov 0x80, %g2 <== NOT EXECUTED
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
40009998: 03 10 00 5f sethi %hi(0x40017c00), %g1
* 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_node(
4000999c: 98 10 20 00 clr %o4
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
400099a0: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
* 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_node(
400099a4: 92 10 20 01 mov 1, %o1
400099a8: 90 10 20 00 clr %o0
400099ac: 15 10 00 58 sethi %hi(0x40016000), %o2
400099b0: 17 00 00 10 sethi %hi(0x4000), %o3
400099b4: 94 12 a2 d0 or %o2, 0x2d0, %o2
400099b8: 40 00 07 e4 call 4000b948 <IMFS_create_node>
400099bc: 96 12 e1 ed or %o3, 0x1ed, %o3
NULL
);
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;
400099c0: 94 10 20 30 mov 0x30, %o2
* 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_node(
400099c4: d0 26 20 18 st %o0, [ %i0 + 0x18 ]
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
400099c8: f2 26 20 20 st %i1, [ %i0 + 0x20 ]
"",
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
400099cc: f6 26 20 1c st %i3, [ %i0 + 0x1c ]
temp_mt_entry->mt_fs_root.ops = op_table;
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
400099d0: 13 10 00 5a sethi %hi(0x40016800), %o1
400099d4: 90 06 20 30 add %i0, 0x30, %o0
400099d8: 40 00 0b cf call 4000c914 <memcpy>
400099dc: 92 12 61 b0 or %o1, 0x1b0, %o1
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
400099e0: 90 10 20 01 mov 1, %o0
400099e4: 40 00 00 e7 call 40009d80 <calloc>
400099e8: 92 10 20 0c mov 0xc, %o1
if ( !fs_info ){
400099ec: 80 a2 20 00 cmp %o0, 0
400099f0: 12 80 00 0a bne 40009a18 <IMFS_initialize_support+0xb0> <== ALWAYS TAKEN
400099f4: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
free(temp_mt_entry->mt_fs_root.node_access);
400099f8: 40 00 01 2c call 40009ea8 <free> <== NOT EXECUTED
400099fc: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
40009a00: 40 00 09 d3 call 4000c14c <__errno> <== NOT EXECUTED
40009a04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009a08: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40009a0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009a10: 81 c7 e0 08 ret <== NOT EXECUTED
40009a14: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
40009a18: 82 10 20 01 mov 1, %g1
40009a1c: c2 22 00 00 st %g1, [ %o0 ]
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;
40009a20: d0 26 20 2c st %o0, [ %i0 + 0x2c ]
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
40009a24: f6 22 20 08 st %i3, [ %o0 + 8 ]
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
40009a28: c2 20 a0 34 st %g1, [ %g2 + 0x34 ]
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
40009a2c: f4 22 20 04 st %i2, [ %o0 + 4 ]
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
return 0;
}
40009a30: 81 c7 e0 08 ret
40009a34: 91 e8 20 00 restore %g0, 0, %o0
40009a38 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
40009a38: 9d e3 bf 60 save %sp, -160, %sp
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, new_name, &result );
40009a3c: 90 10 00 18 mov %i0, %o0
40009a40: 92 07 bf c0 add %fp, -64, %o1
40009a44: 7f ff ff 8f call 40009880 <IMFS_get_token>
40009a48: 94 07 bf f4 add %fp, -12, %o2
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
40009a4c: 03 00 00 3c sethi %hi(0xf000), %g1
40009a50: b3 2e 60 10 sll %i1, 0x10, %i1
40009a54: 97 36 60 10 srl %i1, 0x10, %o3
40009a58: 84 0a c0 01 and %o3, %g1, %g2
40009a5c: 03 00 00 10 sethi %hi(0x4000), %g1
40009a60: 80 a0 80 01 cmp %g2, %g1
40009a64: 02 80 00 17 be 40009ac0 <IMFS_mknod+0x88>
40009a68: 90 10 00 1c mov %i4, %o0
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
40009a6c: 03 00 00 20 sethi %hi(0x8000), %g1
40009a70: 80 a0 80 01 cmp %g2, %g1
40009a74: 02 80 00 14 be 40009ac4 <IMFS_mknod+0x8c> <== NEVER TAKEN
40009a78: 92 10 20 05 mov 5, %o1
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
40009a7c: 03 00 00 18 sethi %hi(0x6000), %g1
40009a80: 80 a0 80 01 cmp %g2, %g1
40009a84: 02 80 00 05 be 40009a98 <IMFS_mknod+0x60> <== NEVER TAKEN
40009a88: 03 00 00 08 sethi %hi(0x2000), %g1
40009a8c: 80 a0 80 01 cmp %g2, %g1
40009a90: 12 80 00 06 bne 40009aa8 <IMFS_mknod+0x70> <== NEVER TAKEN
40009a94: 01 00 00 00 nop
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
40009a98: f4 27 bf e4 st %i2, [ %fp + -28 ]
40009a9c: f6 27 bf e8 st %i3, [ %fp + -24 ]
40009aa0: 10 80 00 09 b 40009ac4 <IMFS_mknod+0x8c>
40009aa4: 92 10 20 02 mov 2, %o1
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
40009aa8: 40 00 09 a9 call 4000c14c <__errno> <== NOT EXECUTED
40009aac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009ab0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40009ab4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009ab8: 81 c7 e0 08 ret <== NOT EXECUTED
40009abc: 81 e8 00 00 restore <== NOT EXECUTED
40009ac0: 92 10 20 01 mov 1, %o1
/*
* Allocate and fill in an IMFS jnode
*/
new_node = IMFS_create_node(
40009ac4: 94 07 bf c0 add %fp, -64, %o2
40009ac8: 98 07 bf e4 add %fp, -28, %o4
40009acc: 40 00 07 9f call 4000b948 <IMFS_create_node>
40009ad0: b0 10 20 00 clr %i0
new_name,
mode,
&info
);
if ( !new_node )
40009ad4: 80 a2 20 00 cmp %o0, 0
40009ad8: 12 80 00 06 bne 40009af0 <IMFS_mknod+0xb8> <== ALWAYS TAKEN
40009adc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOMEM );
40009ae0: 40 00 09 9b call 4000c14c <__errno> <== NOT EXECUTED
40009ae4: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
40009ae8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40009aec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return 0;
}
40009af0: 81 c7 e0 08 ret
40009af4: 81 e8 00 00 restore
40009b04 <IMFS_rmnod>:
*/
int IMFS_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
40009b04: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
40009b08: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED
/*
* Take the node out of the parent's chain that contains this node
*/
if ( the_jnode->Parent != NULL ) {
40009b0c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
40009b10: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009b14: 22 80 00 06 be,a 40009b2c <IMFS_rmnod+0x28> <== NOT EXECUTED
40009b18: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
40009b1c: 40 00 04 6f call 4000acd8 <_Chain_Extract> <== NOT EXECUTED
40009b20: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
40009b24: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
40009b28: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
40009b2c: 92 10 20 00 clr %o1 <== NOT EXECUTED
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
40009b30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
40009b34: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
40009b38: 40 00 01 43 call 4000a044 <gettimeofday> <== NOT EXECUTED
40009b3c: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] <== NOT EXECUTED
40009b40: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
/*
* The file cannot be open and the link must be less than 1 to free.
*/
if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) {
40009b44: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40009b48: 40 00 01 78 call 4000a128 <rtems_libio_is_file_open> <== NOT EXECUTED
40009b4c: c2 24 20 44 st %g1, [ %l0 + 0x44 ] <== NOT EXECUTED
40009b50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009b54: 12 80 00 18 bne 40009bb4 <IMFS_rmnod+0xb0> <== NOT EXECUTED
40009b58: 01 00 00 00 nop <== NOT EXECUTED
40009b5c: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
40009b60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009b64: 12 80 00 14 bne 40009bb4 <IMFS_rmnod+0xb0> <== NOT EXECUTED
40009b68: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
40009b6c: c6 00 62 7c ld [ %g1 + 0x27c ], %g3 ! 4001767c <rtems_current_user_env><== NOT EXECUTED
40009b70: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
40009b74: c2 00 e0 04 ld [ %g3 + 4 ], %g1 <== NOT EXECUTED
40009b78: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40009b7c: 22 80 00 02 be,a 40009b84 <IMFS_rmnod+0x80> <== NOT EXECUTED
40009b80: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
40009b84: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
40009b88: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
40009b8c: 12 80 00 08 bne 40009bac <IMFS_rmnod+0xa8> <== NOT EXECUTED
40009b90: 01 00 00 00 nop <== NOT EXECUTED
if ( the_jnode->info.sym_link.name )
40009b94: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 <== NOT EXECUTED
40009b98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009b9c: 02 80 00 04 be 40009bac <IMFS_rmnod+0xa8> <== NOT EXECUTED
40009ba0: 01 00 00 00 nop <== NOT EXECUTED
free( (void*) the_jnode->info.sym_link.name );
40009ba4: 40 00 00 c1 call 40009ea8 <free> <== NOT EXECUTED
40009ba8: 01 00 00 00 nop <== NOT EXECUTED
}
free( the_jnode );
40009bac: 40 00 00 bf call 40009ea8 <free> <== NOT EXECUTED
40009bb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
}
return 0;
}
40009bb4: 81 c7 e0 08 ret <== NOT EXECUTED
40009bb8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
40009bbc <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
40009bbc: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
40009bc0: f0 06 00 00 ld [ %i0 ], %i0
switch ( the_jnode->type ) {
40009bc4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
40009bc8: 80 a0 60 04 cmp %g1, 4
40009bcc: 22 80 00 19 be,a 40009c30 <IMFS_stat+0x74> <== NEVER TAKEN
40009bd0: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
40009bd4: 14 80 00 07 bg 40009bf0 <IMFS_stat+0x34> <== NEVER TAKEN
40009bd8: 80 a0 60 06 cmp %g1, 6
40009bdc: 80 a0 60 02 cmp %g1, 2
40009be0: 12 80 00 0e bne 40009c18 <IMFS_stat+0x5c> <== NEVER TAKEN
40009be4: 01 00 00 00 nop
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
40009be8: 10 80 00 06 b 40009c00 <IMFS_stat+0x44>
40009bec: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
40009bf0: 14 80 00 0a bg 40009c18 <IMFS_stat+0x5c> <== NOT EXECUTED
40009bf4: 01 00 00 00 nop <== NOT EXECUTED
buf->st_dev = 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;
40009bf8: 10 80 00 06 b 40009c10 <IMFS_stat+0x54> <== NOT EXECUTED
40009bfc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
40009c00: c4 06 20 4c ld [ %i0 + 0x4c ], %g2
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor );
40009c04: c2 26 60 04 st %g1, [ %i1 + 4 ]
40009c08: 10 80 00 0a b 40009c30 <IMFS_stat+0x74>
40009c0c: c4 26 40 00 st %g2, [ %i1 ]
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
40009c10: 10 80 00 08 b 40009c30 <IMFS_stat+0x74> <== NOT EXECUTED
40009c14: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
40009c18: 40 00 09 4d call 4000c14c <__errno> <== NOT EXECUTED
40009c1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40009c20: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
40009c24: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009c28: 81 c7 e0 08 ret <== NOT EXECUTED
40009c2c: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
buf->st_mode = the_jnode->st_mode;
40009c30: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
40009c34: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
40009c38: c2 36 60 0c sth %g1, [ %i1 + 0xc ]
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
40009c3c: c4 26 60 08 st %g2, [ %i1 + 8 ]
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
40009c40: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1
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;
40009c44: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
40009c48: c2 36 60 0e sth %g1, [ %i1 + 0xe ]
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;
40009c4c: c4 26 60 24 st %g2, [ %i1 + 0x24 ]
}
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;
40009c50: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
40009c54: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
}
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;
40009c58: c2 36 60 10 sth %g1, [ %i1 + 0x10 ]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
40009c5c: c4 26 60 2c st %g2, [ %i1 + 0x2c ]
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;
40009c60: c4 16 20 3a lduh [ %i0 + 0x3a ], %g2
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
40009c64: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
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;
40009c68: c4 36 60 12 sth %g2, [ %i1 + 0x12 ]
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
40009c6c: c2 26 60 34 st %g1, [ %i1 + 0x34 ]
return 0;
}
40009c70: 81 c7 e0 08 ret
40009c74: 91 e8 20 00 restore %g0, 0, %o0
40002154 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *start,
size_t length,
size_t sbrk_amount
)
{
40002154: 9d e3 bf 98 save %sp, -104, %sp
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers )
40002158: 03 10 00 5e sethi %hi(0x40017800), %g1
4000215c: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 40017b74 <rtems_malloc_statistics_helpers>
40002160: 80 a0 60 00 cmp %g1, 0
40002164: 02 80 00 05 be 40002178 <RTEMS_Malloc_Initialize+0x24> <== ALWAYS TAKEN
40002168: 01 00 00 00 nop
(*rtems_malloc_statistics_helpers->initialize)();
4000216c: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40002170: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002174: 01 00 00 00 nop <== NOT EXECUTED
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
40002178: 40 00 20 91 call 4000a3bc <malloc_deferred_frees_initialize>
4000217c: a0 10 00 18 mov %i0, %l0
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
40002180: 03 10 00 5e sethi %hi(0x40017800), %g1
40002184: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40017b78 <rtems_malloc_sbrk_helpers>
40002188: 80 a0 60 00 cmp %g1, 0
4000218c: 02 80 00 06 be 400021a4 <RTEMS_Malloc_Initialize+0x50> <== ALWAYS TAKEN
40002190: 90 10 00 18 mov %i0, %o0
starting_address = (*rtems_malloc_sbrk_helpers->initialize)(
40002194: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40002198: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000219c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
400021a0: a0 10 00 08 mov %o0, %l0 <== 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 ( rtems_configuration_get_do_zero_of_workspace() )
400021a4: 03 10 00 5f sethi %hi(0x40017c00), %g1
400021a8: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
400021ac: c2 08 60 28 ldub [ %g1 + 0x28 ], %g1
400021b0: 80 a0 60 00 cmp %g1, 0
400021b4: 02 80 00 07 be 400021d0 <RTEMS_Malloc_Initialize+0x7c> <== ALWAYS TAKEN
400021b8: 92 10 00 10 mov %l0, %o1
memset( starting_address, 0, length );
400021bc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400021c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
400021c4: 40 00 2a 0d call 4000c9f8 <memset> <== NOT EXECUTED
400021c8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
void *starting_address,
size_t size,
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
400021cc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400021d0: 11 10 00 5f sethi %hi(0x40017c00), %o0
400021d4: 94 10 00 19 mov %i1, %o2
400021d8: 90 12 21 00 or %o0, 0x100, %o0
400021dc: 40 00 10 72 call 400063a4 <_Heap_Initialize>
400021e0: 96 10 20 08 mov 8, %o3
&RTEMS_Malloc_Heap,
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
400021e4: 80 a2 20 00 cmp %o0, 0
400021e8: 12 80 00 04 bne 400021f8 <RTEMS_Malloc_Initialize+0xa4> <== ALWAYS TAKEN
400021ec: 05 10 00 5f sethi %hi(0x40017c00), %g2
rtems_fatal_error_occurred( status );
400021f0: 40 00 0e 3e call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
400021f4: 01 00 00 00 nop <== NOT EXECUTED
rtems_print_buffer( (start + length) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
MSBUMP(space_available, length);
400021f8: c2 00 a1 58 ld [ %g2 + 0x158 ], %g1
400021fc: 82 06 40 01 add %i1, %g1, %g1
40002200: c2 20 a1 58 st %g1, [ %g2 + 0x158 ]
}
40002204: 81 c7 e0 08 ret
40002208: 81 e8 00 00 restore
40002658 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
40002658: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
4000265c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40002660: 02 80 00 4a be 40002788 <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
40002664: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
return;
if ( !print_handler )
40002668: e8 00 62 28 ld [ %g1 + 0x228 ], %l4 ! 4001ba28 <print_handler><== NOT EXECUTED
4000266c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
40002670: 02 80 00 46 be 40002788 <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
40002674: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
40002678: 32 80 00 0b bne,a 400026a4 <Stack_check_Dump_threads_usage+0x4c><== NOT EXECUTED
4000267c: ec 06 21 48 ld [ %i0 + 0x148 ], %l6 <== NOT EXECUTED
if (Stack_check_Interrupt_stack.area) {
40002680: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
40002684: 96 10 63 cc or %g1, 0x3cc, %o3 ! 4001bbcc <Stack_check_Interrupt_stack><== NOT EXECUTED
40002688: c2 02 e0 04 ld [ %o3 + 4 ], %g1 <== NOT EXECUTED
4000268c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002690: 02 80 00 3e be 40002788 <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
40002694: a4 10 00 0b mov %o3, %l2 <== NOT EXECUTED
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
}
else
return;
40002698: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000269c: 10 80 00 03 b 400026a8 <Stack_check_Dump_threads_usage+0x50><== NOT EXECUTED
400026a0: ac 10 20 00 clr %l6 <== NOT EXECUTED
} else {
stack = &the_thread->Start.Initial_stack;
400026a4: a4 06 20 c4 add %i0, 0xc4, %l2 <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
400026a8: e0 04 a0 04 ld [ %l2 + 4 ], %l0 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
400026ac: c2 04 80 00 ld [ %l2 ], %g1 <== NOT EXECUTED
} else {
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
400026b0: a0 04 20 10 add %l0, 0x10, %l0 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
400026b4: a6 00 7f f0 add %g1, -16, %l3 <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
400026b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400026bc: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
400026c0: 7f ff ff d6 call 40002618 <Stack_check_find_high_water_mark><== NOT EXECUTED
400026c4: a0 04 00 13 add %l0, %l3, %l0 <== NOT EXECUTED
if ( high_water_mark )
400026c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400026cc: 12 80 00 03 bne 400026d8 <Stack_check_Dump_threads_usage+0x80><== NOT EXECUTED
400026d0: aa 24 00 08 sub %l0, %o0, %l5 <== NOT EXECUTED
400026d4: aa 10 20 00 clr %l5 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
if ( the_thread ) {
400026d8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
400026dc: 02 80 00 10 be 4000271c <Stack_check_Dump_threads_usage+0xc4><== NOT EXECUTED
400026e0: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
(*print_handler)(
400026e4: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
400026e8: e2 00 62 24 ld [ %g1 + 0x224 ], %l1 <== NOT EXECUTED
400026ec: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
400026f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400026f4: 40 00 0f 36 call 400063cc <rtems_object_get_name> <== NOT EXECUTED
400026f8: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
400026fc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40002700: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
40002704: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
40002708: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4000270c: 9f c5 00 00 call %l4 <== NOT EXECUTED
40002710: 92 12 62 d0 or %o1, 0x2d0, %o1 <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
40002714: 10 80 00 08 b 40002734 <Stack_check_Dump_threads_usage+0xdc><== NOT EXECUTED
40002718: d6 04 80 00 ld [ %l2 ], %o3 <== NOT EXECUTED
"0x%08" PRIx32 " %4s",
the_thread->Object.id,
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
4000271c: d0 00 62 24 ld [ %g1 + 0x224 ], %o0 <== NOT EXECUTED
40002720: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
40002724: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
40002728: 9f c5 00 00 call %l4 <== NOT EXECUTED
4000272c: 92 12 62 e0 or %o1, 0x2e0, %o1 <== NOT EXECUTED
}
(*print_handler)(
40002730: d6 04 80 00 ld [ %l2 ], %o3 <== NOT EXECUTED
40002734: d4 04 a0 04 ld [ %l2 + 4 ], %o2 <== NOT EXECUTED
40002738: 21 10 00 6e sethi %hi(0x4001b800), %l0 <== NOT EXECUTED
4000273c: 23 10 00 6e sethi %hi(0x4001b800), %l1 <== NOT EXECUTED
40002740: c2 04 22 28 ld [ %l0 + 0x228 ], %g1 <== NOT EXECUTED
40002744: d0 04 62 24 ld [ %l1 + 0x224 ], %o0 <== NOT EXECUTED
40002748: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
4000274c: 98 10 00 16 mov %l6, %o4 <== NOT EXECUTED
40002750: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
40002754: 9a 10 00 13 mov %l3, %o5 <== NOT EXECUTED
40002758: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
4000275c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002760: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 400192f0 <__func__.4755+0x260><== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
40002764: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
40002768: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 4001ba20 <Stack_check_Initialized><== NOT EXECUTED
4000276c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002770: 12 80 00 08 bne 40002790 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
40002774: c2 04 22 28 ld [ %l0 + 0x228 ], %g1 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
40002778: d0 04 62 24 ld [ %l1 + 0x224 ], %o0 <== NOT EXECUTED
4000277c: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
40002780: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002784: 92 12 63 10 or %o1, 0x310, %o1 ! 40019310 <__func__.4755+0x280><== NOT EXECUTED
40002788: 81 c7 e0 08 ret <== NOT EXECUTED
4000278c: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
40002790: d0 04 62 24 ld [ %l1 + 0x224 ], %o0 <== NOT EXECUTED
40002794: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
40002798: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
4000279c: 9f c0 40 00 call %g1 <== NOT EXECUTED
400027a0: 92 12 63 20 or %o1, 0x320, %o1 <== NOT EXECUTED
400027a4: 81 c7 e0 08 ret <== NOT EXECUTED
400027a8: 81 e8 00 00 restore <== NOT EXECUTED
40002984 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
40002984: 9d e3 bf 98 save %sp, -104, %sp
uint32_t *p;
if (Stack_check_Initialized)
40002988: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000298c: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 4001ba20 <Stack_check_Initialized>
40002990: 80 a0 60 00 cmp %g1, 0
40002994: 12 80 00 23 bne 40002a20 <Stack_check_Initialize+0x9c>
40002998: 03 10 00 6f sethi %hi(0x4001bc00), %g1
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
4000299c: c6 00 61 c0 ld [ %g1 + 0x1c0 ], %g3 ! 4001bdc0 <_CPU_Interrupt_stack_low>
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
400029a0: 03 3f bb 7c sethi %hi(0xfeedf000), %g1
400029a4: 82 10 60 0d or %g1, 0xd, %g1 ! feedf00d <LEON_REG+0x7eedf00d>
400029a8: 05 10 00 6e sethi %hi(0x4001b800), %g2
400029ac: c2 20 a3 bc st %g1, [ %g2 + 0x3bc ] ! 4001bbbc <Stack_check_Pattern>
p[1] = 0x0BAD0D06;
400029b0: 03 02 eb 43 sethi %hi(0xbad0c00), %g1
400029b4: 82 10 61 06 or %g1, 0x106, %g1 ! bad0d06 <RAM_SIZE+0xb6d0d06>
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
400029b8: 84 10 a3 bc or %g2, 0x3bc, %g2
p[1] = 0x0BAD0D06;
400029bc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
400029c0: 03 37 ab 7c sethi %hi(0xdeadf000), %g1
400029c4: 82 10 60 0d or %g1, 0xd, %g1 ! deadf00d <LEON_REG+0x5eadf00d>
400029c8: c2 20 a0 08 st %g1, [ %g2 + 8 ]
p[3] = 0x600D0D06;
400029cc: 03 18 03 43 sethi %hi(0x600d0c00), %g1
400029d0: 82 10 61 06 or %g1, 0x106, %g1 ! 600d0d06 <RAM_END+0x1fcd0d06>
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
400029d4: 80 a0 e0 00 cmp %g3, 0
400029d8: 02 80 00 0f be 40002a14 <Stack_check_Initialize+0x90> <== NEVER TAKEN
400029dc: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
400029e0: 03 10 00 6f sethi %hi(0x4001bc00), %g1
400029e4: c4 00 61 0c ld [ %g1 + 0x10c ], %g2 ! 4001bd0c <_CPU_Interrupt_stack_high>
400029e8: 80 a0 a0 00 cmp %g2, 0
400029ec: 02 80 00 0a be 40002a14 <Stack_check_Initialize+0x90> <== NEVER TAKEN
400029f0: 84 20 80 03 sub %g2, %g3, %g2
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
400029f4: 03 10 00 6e sethi %hi(0x4001b800), %g1
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
400029f8: c4 20 63 cc st %g2, [ %g1 + 0x3cc ] ! 4001bbcc <Stack_check_Interrupt_stack>
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
400029fc: 82 10 63 cc or %g1, 0x3cc, %g1
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
40002a00: 90 10 00 03 mov %g3, %o0
40002a04: 94 10 00 02 mov %g2, %o2
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
40002a08: c6 20 60 04 st %g3, [ %g1 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
40002a0c: 40 00 2d d1 call 4000e150 <memset>
40002a10: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
40002a14: 84 10 20 01 mov 1, %g2
40002a18: 03 10 00 6e sethi %hi(0x4001b800), %g1
40002a1c: c4 20 62 20 st %g2, [ %g1 + 0x220 ] ! 4001ba20 <Stack_check_Initialized>
40002a20: 81 c7 e0 08 ret
40002a24: 81 e8 00 00 restore
40002618 <Stack_check_find_high_water_mark>:
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
40002618: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
4000261c: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
if (*base != U32_PATTERN)
40002620: 03 29 69 69 sethi %hi(0xa5a5a400), %g1 <== 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++)
40002624: 84 02 00 09 add %o0, %o1, %g2 <== NOT EXECUTED
if (*base != U32_PATTERN)
40002628: 10 80 00 06 b 40002640 <Stack_check_find_high_water_mark+0x28><== NOT EXECUTED
4000262c: 86 10 61 a5 or %g1, 0x1a5, %g3 <== NOT EXECUTED
40002630: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40002634: 12 80 00 07 bne 40002650 <Stack_check_find_high_water_mark+0x38><== NOT EXECUTED
40002638: 01 00 00 00 nop <== 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++)
4000263c: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED
40002640: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED
40002644: 2a bf ff fb bcs,a 40002630 <Stack_check_find_high_water_mark+0x18><== NOT EXECUTED
40002648: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
4000264c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
40002650: 81 c3 e0 08 retl <== NOT EXECUTED
40002820 <Stack_check_report_blown_task>:
*/
void Stack_check_report_blown_task(
Thread_Control *running,
bool pattern_ok
)
{
40002820: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
Stack_Control *stack = &running->Start.Initial_stack;
printk(
40002824: d4 1e 20 08 ldd [ %i0 + 8 ], %o2 <== NOT EXECUTED
40002828: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000282c: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED
40002830: 40 00 05 20 call 40003cb0 <printk> <== NOT EXECUTED
40002834: 90 12 23 90 or %o0, 0x390, %o0 ! 40019390 <__func__.4755+0x300><== NOT EXECUTED
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
printk(
40002838: d4 06 20 c4 ld [ %i0 + 0xc4 ], %o2 <== NOT EXECUTED
4000283c: d2 06 20 c8 ld [ %i0 + 0xc8 ], %o1 <== NOT EXECUTED
40002840: 96 10 00 0a mov %o2, %o3 <== NOT EXECUTED
40002844: 11 10 00 64 sethi %hi(0x40019000), %o0 <== NOT EXECUTED
40002848: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
4000284c: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
40002850: 40 00 05 18 call 40003cb0 <printk> <== NOT EXECUTED
40002854: 94 02 40 0a add %o1, %o2, %o2 <== NOT EXECUTED
stack->area,
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
40002858: 80 8e 60 ff btst 0xff, %i1 <== NOT EXECUTED
4000285c: 12 80 00 07 bne 40002878 <Stack_check_report_blown_task+0x58><== NOT EXECUTED
40002860: 11 10 00 65 sethi %hi(0x40019400), %o0 <== NOT EXECUTED
printk(
40002864: d2 06 20 c8 ld [ %i0 + 0xc8 ], %o1 <== NOT EXECUTED
40002868: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED
4000286c: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
40002870: 40 00 05 10 call 40003cb0 <printk> <== NOT EXECUTED
40002874: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
" Damaged pattern begins at 0x%08lx and is %d bytes long\n",
(unsigned long) Stack_check_Get_pattern_area(stack),
PATTERN_SIZE_BYTES);
}
rtems_fatal_error_occurred( 0x81 );
40002878: 40 00 11 4c call 40006da8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000287c: 90 10 20 81 mov 0x81, %o0 <== NOT EXECUTED
40005ca8 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
40005ca8: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
40005cac: 03 10 00 60 sethi %hi(0x40018000), %g1
40005cb0: e0 00 61 14 ld [ %g1 + 0x114 ], %l0 ! 40018114 <_API_extensions_List>
40005cb4: 82 10 61 14 or %g1, 0x114, %g1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005cb8: 10 80 00 08 b 40005cd8 <_API_extensions_Run_postdriver+0x30>
40005cbc: a2 00 60 04 add %g1, 4, %l1
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
40005cc0: 80 a0 60 00 cmp %g1, 0
40005cc4: 22 80 00 05 be,a 40005cd8 <_API_extensions_Run_postdriver+0x30><== NEVER TAKEN
40005cc8: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
(*the_extension->postdriver_hook)();
40005ccc: 9f c0 40 00 call %g1
40005cd0: 01 00 00 00 nop
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
40005cd4: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005cd8: 80 a4 00 11 cmp %l0, %l1
40005cdc: 32 bf ff f9 bne,a 40005cc0 <_API_extensions_Run_postdriver+0x18>
40005ce0: c2 04 20 0c ld [ %l0 + 0xc ], %g1
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
(*the_extension->postdriver_hook)();
}
}
40005ce4: 81 c7 e0 08 ret
40005ce8: 81 e8 00 00 restore
40005cec <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
40005cec: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
40005cf0: 03 10 00 60 sethi %hi(0x40018000), %g1
40005cf4: e0 00 61 14 ld [ %g1 + 0x114 ], %l0 ! 40018114 <_API_extensions_List>
40005cf8: 82 10 61 14 or %g1, 0x114, %g1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005cfc: a4 00 60 04 add %g1, 4, %l2
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
40005d00: 03 10 00 5f sethi %hi(0x40017c00), %g1
40005d04: 10 80 00 08 b 40005d24 <_API_extensions_Run_postswitch+0x38>
40005d08: a2 10 63 90 or %g1, 0x390, %l1 ! 40017f90 <_Thread_Executing>
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
40005d0c: 80 a0 60 00 cmp %g1, 0
40005d10: 22 80 00 05 be,a 40005d24 <_API_extensions_Run_postswitch+0x38><== NEVER TAKEN
40005d14: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
(*the_extension->postswitch_hook)( _Thread_Executing );
40005d18: 9f c0 40 00 call %g1
40005d1c: d0 04 40 00 ld [ %l1 ], %o0
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
40005d20: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005d24: 80 a4 00 12 cmp %l0, %l2
40005d28: 32 bf ff f9 bne,a 40005d0c <_API_extensions_Run_postswitch+0x20>
40005d2c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
}
}
40005d30: 81 c7 e0 08 ret
40005d34: 81 e8 00 00 restore
40005c64 <_API_extensions_Run_predriver>:
*
* _API_extensions_Run_predriver
*/
void _API_extensions_Run_predriver( void )
{
40005c64: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
40005c68: 03 10 00 60 sethi %hi(0x40018000), %g1
40005c6c: e0 00 61 14 ld [ %g1 + 0x114 ], %l0 ! 40018114 <_API_extensions_List>
40005c70: 82 10 61 14 or %g1, 0x114, %g1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005c74: 10 80 00 08 b 40005c94 <_API_extensions_Run_predriver+0x30>
40005c78: a2 00 60 04 add %g1, 4, %l1
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
40005c7c: 80 a0 60 00 cmp %g1, 0
40005c80: 22 80 00 05 be,a 40005c94 <_API_extensions_Run_predriver+0x30><== ALWAYS TAKEN
40005c84: e0 04 00 00 ld [ %l0 ], %l0
(*the_extension->predriver_hook)();
40005c88: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005c8c: 01 00 00 00 nop <== NOT EXECUTED
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
the_node = the_node->next ) {
40005c90: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
{
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
40005c94: 80 a4 00 11 cmp %l0, %l1
40005c98: 32 bf ff f9 bne,a 40005c7c <_API_extensions_Run_predriver+0x18>
40005c9c: c2 04 20 08 ld [ %l0 + 8 ], %g1
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
(*the_extension->predriver_hook)();
}
}
40005ca0: 81 c7 e0 08 ret
40005ca4: 81 e8 00 00 restore
4000703c <_CORE_barrier_Wait>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
4000703c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
40007040: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40007044: e2 00 61 80 ld [ %g1 + 0x180 ], %l1 ! 4001bd80 <_Thread_Executing>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
40007048: b4 10 00 1c mov %i4, %i2
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
4000704c: c0 24 60 34 clr [ %l1 + 0x34 ]
_ISR_Disable( level );
40007050: 7f ff ee 4c call 40002980 <sparc_disable_interrupts>
40007054: a0 10 00 18 mov %i0, %l0
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
40007058: a4 10 00 19 mov %i1, %l2
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
4000705c: 86 10 00 08 mov %o0, %g3
the_barrier->number_of_waiting_threads++;
40007060: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
if ( the_barrier->number_of_waiting_threads ==
40007064: c4 06 20 44 ld [ %i0 + 0x44 ], %g2
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
40007068: 82 00 60 01 inc %g1
if ( the_barrier->number_of_waiting_threads ==
4000706c: 80 a0 40 02 cmp %g1, %g2
40007070: 12 80 00 0b bne 4000709c <_CORE_barrier_Wait+0x60>
40007074: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
40007078: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000707c: 80 a0 60 00 cmp %g1, 0
40007080: 12 80 00 08 bne 400070a0 <_CORE_barrier_Wait+0x64> <== NEVER TAKEN
40007084: 82 10 20 01 mov 1, %g1
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
40007088: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
_ISR_Enable( level );
4000708c: 7f ff ee 41 call 40002990 <sparc_enable_interrupts>
40007090: 01 00 00 00 nop
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
40007094: 7f ff ff df call 40007010 <_CORE_barrier_Release>
40007098: 81 e8 00 00 restore
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;
4000709c: 82 10 20 01 mov 1, %g1
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
executing->Wait.id = id;
400070a0: e4 24 60 20 st %l2, [ %l1 + 0x20 ]
return;
}
}
_Thread_queue_Enter_critical_section( &the_barrier->Wait_queue );
executing->Wait.queue = &the_barrier->Wait_queue;
400070a4: e0 24 60 44 st %l0, [ %l1 + 0x44 ]
400070a8: c2 24 20 30 st %g1, [ %l0 + 0x30 ]
executing->Wait.id = id;
_ISR_Enable( level );
400070ac: 90 10 00 03 mov %g3, %o0
400070b0: 7f ff ee 38 call 40002990 <sparc_enable_interrupts>
400070b4: 35 10 00 24 sethi %hi(0x40009000), %i2
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
400070b8: b0 10 00 10 mov %l0, %i0
400070bc: b2 10 00 1b mov %i3, %i1
400070c0: 40 00 06 f3 call 40008c8c <_Thread_queue_Enqueue_with_handler>
400070c4: 95 ee a0 58 restore %i2, 0x58, %o2
40012490 <_CORE_message_queue_Broadcast>:
size_t size,
Objects_Id id,
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
uint32_t *count
)
{
40012490: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
40012494: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
size_t size,
Objects_Id id,
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
uint32_t *count
)
{
40012498: a4 10 00 18 mov %i0, %l2
Thread_Control *the_thread;
uint32_t number_broadcasted;
Thread_Wait_information *waitp;
if ( size > the_message_queue->maximum_message_size ) {
4001249c: 80 a6 80 01 cmp %i2, %g1
400124a0: 18 80 00 17 bgu 400124fc <_CORE_message_queue_Broadcast+0x6c><== NEVER TAKEN
400124a4: b0 10 20 01 mov 1, %i0
* 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 ) {
400124a8: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1
400124ac: 80 a0 60 00 cmp %g1, 0
400124b0: 02 80 00 0a be 400124d8 <_CORE_message_queue_Broadcast+0x48><== ALWAYS TAKEN
400124b4: a2 10 20 00 clr %l1
*count = 0;
400124b8: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
400124bc: 81 c7 e0 08 ret <== NOT EXECUTED
400124c0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
400124c4: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
400124c8: 40 00 1e b7 call 40019fa4 <memcpy>
400124cc: a2 04 60 01 inc %l1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
400124d0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
400124d4: f4 20 40 00 st %i2, [ %g1 ]
* There must be no pending messages if there is a thread waiting to
* receive a message.
*/
number_broadcasted = 0;
while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
400124d8: 40 00 09 a0 call 40014b58 <_Thread_queue_Dequeue>
400124dc: 90 10 00 12 mov %l2, %o0
400124e0: 92 10 00 19 mov %i1, %o1
400124e4: a0 10 00 08 mov %o0, %l0
400124e8: 80 a2 20 00 cmp %o0, 0
400124ec: 12 bf ff f6 bne 400124c4 <_CORE_message_queue_Broadcast+0x34>
400124f0: 94 10 00 1a mov %i2, %o2
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_message_queue_mp_support) ( the_thread, id );
#endif
}
*count = number_broadcasted;
400124f4: e2 27 40 00 st %l1, [ %i5 ]
400124f8: b0 10 20 00 clr %i0
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
400124fc: 81 c7 e0 08 ret
40012500: 81 e8 00 00 restore
400125c0 <_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
)
{
400125c0: 9d e3 bf 98 save %sp, -104, %sp
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;
400125c4: c0 26 20 48 clr [ %i0 + 0x48 ]
)
{
size_t message_buffering_required;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
400125c8: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
the_message_queue->number_of_pending_messages = 0;
the_message_queue->maximum_message_size = maximum_message_size;
400125cc: f6 26 20 4c st %i3, [ %i0 + 0x4c ]
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
400125d0: c0 26 20 60 clr [ %i0 + 0x60 ]
the_message_queue->notify_argument = the_argument;
400125d4: c0 26 20 64 clr [ %i0 + 0x64 ]
* 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)) {
400125d8: 80 8e e0 03 btst 3, %i3
400125dc: 02 80 00 07 be 400125f8 <_CORE_message_queue_Initialize+0x38>
400125e0: a0 10 00 1b mov %i3, %l0
allocated_message_size += sizeof(uint32_t);
400125e4: 82 06 e0 04 add %i3, 4, %g1
allocated_message_size &= ~(sizeof(uint32_t) - 1);
400125e8: a0 08 7f fc and %g1, -4, %l0
}
if (allocated_message_size < maximum_message_size)
400125ec: 80 a4 00 1b cmp %l0, %i3
400125f0: 0a 80 00 23 bcs 4001267c <_CORE_message_queue_Initialize+0xbc><== NEVER TAKEN
400125f4: 01 00 00 00 nop
/*
* 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 *
400125f8: b6 04 20 14 add %l0, 0x14, %i3
400125fc: 92 10 00 1a mov %i2, %o1
40012600: 40 00 3e d8 call 40022160 <.umul>
40012604: 90 10 00 1b mov %i3, %o0
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
40012608: 80 a2 00 10 cmp %o0, %l0
4001260c: 0a 80 00 1c bcs 4001267c <_CORE_message_queue_Initialize+0xbc><== NEVER TAKEN
40012610: 01 00 00 00 nop
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
40012614: 40 00 0e d6 call 4001616c <_Workspace_Allocate>
40012618: 01 00 00 00 nop
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
4001261c: 80 a2 20 00 cmp %o0, 0
40012620: 02 80 00 17 be 4001267c <_CORE_message_queue_Initialize+0xbc>
40012624: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
40012628: 92 10 00 08 mov %o0, %o1
4001262c: 94 10 00 1a mov %i2, %o2
40012630: 90 06 20 68 add %i0, 0x68, %o0
40012634: 7f ff ff 89 call 40012458 <_Chain_Initialize>
40012638: 96 10 00 1b mov %i3, %o3
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
4001263c: c2 06 40 00 ld [ %i1 ], %g1
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
40012640: c0 26 20 54 clr [ %i0 + 0x54 ]
40012644: 82 18 60 01 xor %g1, 1, %g1
40012648: 80 a0 00 01 cmp %g0, %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
4001264c: 82 06 20 54 add %i0, 0x54, %g1
40012650: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
40012654: 82 06 20 50 add %i0, 0x50, %g1
40012658: 90 10 00 18 mov %i0, %o0
4001265c: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
40012660: 92 60 3f ff subx %g0, -1, %o1
40012664: 94 10 20 80 mov 0x80, %o2
40012668: 96 10 20 06 mov 6, %o3
4001266c: 40 00 0a 58 call 40014fcc <_Thread_queue_Initialize>
40012670: b0 10 20 01 mov 1, %i0
40012674: 81 c7 e0 08 ret
40012678: 81 e8 00 00 restore
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
4001267c: 81 c7 e0 08 ret
40012680: 91 e8 20 00 restore %g0, 0, %o0
4001858c <_CORE_message_queue_Insert_message>:
void _CORE_message_queue_Insert_message(
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message,
CORE_message_queue_Submit_types submit_type
)
{
4001858c: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
bool notify = false;
the_message->priority = submit_type;
switch ( submit_type ) {
40018590: 03 20 00 00 sethi %hi(0x80000000), %g1
40018594: 80 a6 80 01 cmp %i2, %g1
40018598: 02 80 00 15 be 400185ec <_CORE_message_queue_Insert_message+0x60>
4001859c: f4 26 60 08 st %i2, [ %i1 + 8 ]
400185a0: 82 00 7c 00 add %g1, -1024, %g1
400185a4: 82 10 63 ff or %g1, 0x3ff, %g1
400185a8: 80 a6 80 01 cmp %i2, %g1
400185ac: 12 80 00 1f bne 40018628 <_CORE_message_queue_Insert_message+0x9c><== NEVER TAKEN
400185b0: a2 06 20 54 add %i0, 0x54, %l1
case CORE_MESSAGE_QUEUE_SEND_REQUEST:
_ISR_Disable( level );
400185b4: 7f ff cb b8 call 4000b494 <sparc_disable_interrupts>
400185b8: 01 00 00 00 nop
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
400185bc: e2 26 40 00 st %l1, [ %i1 ]
if ( the_message_queue->number_of_pending_messages++ == 0 )
400185c0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
old_last_node = the_chain->last;
400185c4: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
the_chain->last = the_node;
400185c8: f2 26 20 58 st %i1, [ %i0 + 0x58 ]
400185cc: 80 a0 00 01 cmp %g0, %g1
old_last_node->next = the_node;
the_node->previous = old_last_node;
400185d0: c4 26 60 04 st %g2, [ %i1 + 4 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
400185d4: f2 20 80 00 st %i1, [ %g2 ]
400185d8: 82 00 60 01 inc %g1
400185dc: 84 60 3f ff subx %g0, -1, %g2
400185e0: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
400185e4: a0 10 00 02 mov %g2, %l0
notify = true;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
400185e8: 30 80 00 27 b,a 40018684 <_CORE_message_queue_Insert_message+0xf8>
break;
case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
_ISR_Disable( level );
400185ec: 7f ff cb aa call 4000b494 <sparc_disable_interrupts>
400185f0: 01 00 00 00 nop
if ( the_message_queue->number_of_pending_messages++ == 0 )
400185f4: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
400185f8: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
400185fc: 82 06 20 50 add %i0, 0x50, %g1
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
40018600: f2 26 20 50 st %i1, [ %i0 + 0x50 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40018604: c2 26 60 04 st %g1, [ %i1 + 4 ]
40018608: 80 a0 00 02 cmp %g0, %g2
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
before_node->previous = the_node;
4001860c: f2 20 e0 04 st %i1, [ %g3 + 4 ]
40018610: 82 60 3f ff subx %g0, -1, %g1
40018614: 84 00 a0 01 inc %g2
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
40018618: c6 26 40 00 st %g3, [ %i1 ]
4001861c: a0 10 00 01 mov %g1, %l0
40018620: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
notify = true;
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
40018624: 30 80 00 18 b,a 40018684 <_CORE_message_queue_Insert_message+0xf8>
CORE_message_queue_Buffer_control *this_message;
Chain_Node *the_node;
Chain_Control *the_header;
the_header = &the_message_queue->Pending_messages;
the_node = the_header->first;
40018628: 10 80 00 06 b 40018640 <_CORE_message_queue_Insert_message+0xb4><== NOT EXECUTED
4001862c: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED
while ( !_Chain_Is_tail( the_header, the_node ) ) {
this_message = (CORE_message_queue_Buffer_control *) the_node;
if ( this_message->priority <= the_message->priority ) {
40018630: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
40018634: 14 80 00 06 bg 4001864c <_CORE_message_queue_Insert_message+0xc0><== NOT EXECUTED
40018638: 01 00 00 00 nop <== NOT EXECUTED
the_node = the_node->next;
4001863c: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
Chain_Node *the_node;
Chain_Control *the_header;
the_header = &the_message_queue->Pending_messages;
the_node = the_header->first;
while ( !_Chain_Is_tail( the_header, the_node ) ) {
40018640: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
40018644: 32 bf ff fb bne,a 40018630 <_CORE_message_queue_Insert_message+0xa4><== NOT EXECUTED
40018648: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
continue;
}
break;
}
_ISR_Disable( level );
4001864c: 7f ff cb 92 call 4000b494 <sparc_disable_interrupts> <== NOT EXECUTED
40018650: 01 00 00 00 nop <== NOT EXECUTED
if ( the_message_queue->number_of_pending_messages++ == 0 )
notify = true;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
40018654: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
}
break;
}
_ISR_Disable( level );
if ( the_message_queue->number_of_pending_messages++ == 0 )
40018658: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
4001865c: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40018660: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
40018664: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED
40018668: 80 a0 00 02 cmp %g0, %g2 <== NOT EXECUTED
the_node->next = before_node;
before_node->previous = the_node;
4001866c: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED
40018670: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
40018674: 84 00 a0 01 inc %g2 <== 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;
40018678: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
4001867c: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
40018680: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED
notify = true;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
_ISR_Enable( level );
40018684: 7f ff cb 88 call 4000b4a4 <sparc_enable_interrupts>
40018688: 01 00 00 00 nop
* According to POSIX, does this happen before or after the message
* is actually enqueued. It is logical to think afterwards, because
* the message is actually in the queue at this point.
*/
if ( notify && the_message_queue->notify_handler )
4001868c: 80 8c 20 ff btst 0xff, %l0
40018690: 02 80 00 08 be 400186b0 <_CORE_message_queue_Insert_message+0x124>
40018694: 01 00 00 00 nop
40018698: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
4001869c: 80 a0 60 00 cmp %g1, 0
400186a0: 02 80 00 04 be 400186b0 <_CORE_message_queue_Insert_message+0x124><== ALWAYS TAKEN
400186a4: 01 00 00 00 nop
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
400186a8: 9f c0 40 00 call %g1 <== NOT EXECUTED
400186ac: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED
400186b0: 81 c7 e0 08 ret
400186b4: 81 e8 00 00 restore
40012684 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
40012684: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
40012688: 27 10 00 c6 sethi %hi(0x40031800), %l3
4001268c: e2 04 e2 f0 ld [ %l3 + 0x2f0 ], %l1 ! 40031af0 <_Thread_Executing>
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
40012690: a4 10 00 19 mov %i1, %l2
CORE_message_queue_Buffer_control *the_message;
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
40012694: c0 24 60 34 clr [ %l1 + 0x34 ]
_ISR_Disable( level );
40012698: 7f ff e3 7f call 4000b494 <sparc_disable_interrupts>
4001269c: a0 10 00 18 mov %i0, %l0
400126a0: 86 10 00 08 mov %o0, %g3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
400126a4: f2 06 20 50 ld [ %i0 + 0x50 ], %i1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
400126a8: 82 06 20 54 add %i0, 0x54, %g1
400126ac: 80 a6 40 01 cmp %i1, %g1
400126b0: 02 80 00 24 be 40012740 <_CORE_message_queue_Seize+0xbc>
400126b4: 84 06 20 50 add %i0, 0x50, %g2
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
400126b8: c2 06 40 00 ld [ %i1 ], %g1
the_chain->first = new_first;
400126bc: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
400126c0: 80 a6 60 00 cmp %i1, 0
400126c4: 02 80 00 1f be 40012740 <_CORE_message_queue_Seize+0xbc> <== NEVER TAKEN
400126c8: c4 20 60 04 st %g2, [ %g1 + 4 ]
the_message_queue->number_of_pending_messages -= 1;
400126cc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
400126d0: 82 00 7f ff add %g1, -1, %g1
400126d4: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
_ISR_Enable( level );
400126d8: 7f ff e3 73 call 4000b4a4 <sparc_enable_interrupts>
400126dc: a2 06 60 10 add %i1, 0x10, %l1
*size_p = the_message->Contents.size;
400126e0: d4 06 60 0c ld [ %i1 + 0xc ], %o2
_Thread_Executing->Wait.count = the_message->priority;
400126e4: c4 04 e2 f0 ld [ %l3 + 0x2f0 ], %g2
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
_ISR_Enable( level );
*size_p = the_message->Contents.size;
400126e8: d4 26 c0 00 st %o2, [ %i3 ]
_Thread_Executing->Wait.count = the_message->priority;
400126ec: c2 06 60 08 ld [ %i1 + 8 ], %g1
400126f0: c2 20 a0 24 st %g1, [ %g2 + 0x24 ]
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
400126f4: 92 10 00 11 mov %l1, %o1
400126f8: 40 00 1e 2b call 40019fa4 <memcpy>
400126fc: 90 10 00 1a mov %i2, %o0
*
* NOTE: If we note that the queue was not full before this receive,
* then we can avoid this dequeue.
*/
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
40012700: 40 00 09 16 call 40014b58 <_Thread_queue_Dequeue>
40012704: 90 10 00 18 mov %i0, %o0
if ( !the_thread ) {
40012708: 80 a2 20 00 cmp %o0, 0
4001270c: 32 80 00 04 bne,a 4001271c <_CORE_message_queue_Seize+0x98><== NEVER TAKEN
40012710: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer (
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Buffer_control *the_message
)
{
_Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
40012714: 7f ff ff 35 call 400123e8 <_Chain_Append>
40012718: 91 ee 20 68 restore %i0, 0x68, %o0
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
the_message->priority = the_thread->Wait.count;
4001271c: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
the_message->Contents.size = (size_t) the_thread->Wait.option;
40012720: d4 26 60 0c st %o2, [ %i1 + 0xc ] <== NOT EXECUTED
* There was a thread waiting to send a message. This code
* puts the messages in the message queue on behalf of the
* waiting task.
*/
the_message->priority = the_thread->Wait.count;
40012724: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
40012728: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
4001272c: 40 00 1e 1e call 40019fa4 <memcpy> <== NOT EXECUTED
40012730: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
the_thread->Wait.return_argument_second.immutable_object,
the_message->Contents.buffer,
the_message->Contents.size
);
_CORE_message_queue_Insert_message(
40012734: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED
40012738: 40 00 17 95 call 4001858c <_CORE_message_queue_Insert_message><== NOT EXECUTED
4001273c: 81 e8 00 00 restore <== NOT EXECUTED
the_message->priority
);
return;
}
if ( !wait ) {
40012740: 80 8f 20 ff btst 0xff, %i4
40012744: 12 80 00 08 bne 40012764 <_CORE_message_queue_Seize+0xe0>
40012748: 82 10 20 01 mov 1, %g1
_ISR_Enable( level );
4001274c: 7f ff e3 56 call 4000b4a4 <sparc_enable_interrupts>
40012750: 90 10 00 03 mov %g3, %o0
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
40012754: 82 10 20 04 mov 4, %g1
40012758: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
}
4001275c: 81 c7 e0 08 ret
40012760: 81 e8 00 00 restore
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;
40012764: c2 24 20 30 st %g1, [ %l0 + 0x30 ]
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
40012768: f6 24 60 28 st %i3, [ %l1 + 0x28 ]
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
4001276c: e4 24 60 20 st %l2, [ %l1 + 0x20 ]
executing->Wait.return_argument_second.mutable_object = buffer;
40012770: f4 24 60 2c st %i2, [ %l1 + 0x2c ]
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
return;
}
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
40012774: e0 24 60 44 st %l0, [ %l1 + 0x44 ]
executing->Wait.id = id;
executing->Wait.return_argument_second.mutable_object = buffer;
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
40012778: 90 10 00 03 mov %g3, %o0
4001277c: 7f ff e3 4a call 4000b4a4 <sparc_enable_interrupts>
40012780: 35 10 00 54 sethi %hi(0x40015000), %i2
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
40012784: b0 10 00 10 mov %l0, %i0
40012788: b2 10 00 1d mov %i5, %i1
4001278c: 40 00 09 58 call 40014cec <_Thread_queue_Enqueue_with_handler>
40012790: 95 ee a0 b8 restore %i2, 0xb8, %o2
40012798 <_CORE_message_queue_Submit>:
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
40012798: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
4001279c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
400127a0: a2 10 00 18 mov %i0, %l1
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
400127a4: 80 a6 80 01 cmp %i2, %g1
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
400127a8: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
ISR_Level level;
CORE_message_queue_Buffer_control *the_message;
Thread_Control *the_thread;
if ( size > the_message_queue->maximum_message_size ) {
400127ac: 18 80 00 3f bgu 400128a8 <_CORE_message_queue_Submit+0x110>
400127b0: b0 10 20 01 mov 1, %i0
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
400127b4: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
400127b8: 80 a0 60 00 cmp %g1, 0
400127bc: 32 80 00 0f bne,a 400127f8 <_CORE_message_queue_Submit+0x60>
400127c0: c4 04 60 48 ld [ %l1 + 0x48 ], %g2
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
400127c4: 40 00 08 e5 call 40014b58 <_Thread_queue_Dequeue>
400127c8: 90 10 00 11 mov %l1, %o0
if ( the_thread ) {
400127cc: a0 92 20 00 orcc %o0, 0, %l0
400127d0: 02 80 00 09 be 400127f4 <_CORE_message_queue_Submit+0x5c>
400127d4: 92 10 00 19 mov %i1, %o1
400127d8: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
400127dc: 40 00 1d f2 call 40019fa4 <memcpy>
400127e0: 94 10 00 1a mov %i2, %o2
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
400127e4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
the_thread->Wait.count = submit_type;
400127e8: fa 24 20 24 st %i5, [ %l0 + 0x24 ]
_CORE_message_queue_Copy_buffer(
buffer,
the_thread->Wait.return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
400127ec: 10 80 00 15 b 40012840 <_CORE_message_queue_Submit+0xa8>
400127f0: f4 20 40 00 st %i2, [ %g1 ]
/*
* 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 <
400127f4: c4 04 60 48 ld [ %l1 + 0x48 ], %g2
400127f8: c2 04 60 44 ld [ %l1 + 0x44 ], %g1
400127fc: 80 a0 80 01 cmp %g2, %g1
40012800: 1a 80 00 12 bcc 40012848 <_CORE_message_queue_Submit+0xb0>
40012804: 80 a4 a0 00 cmp %l2, 0
RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control *
_CORE_message_queue_Allocate_message_buffer (
CORE_message_queue_Control *the_message_queue
)
{
return (CORE_message_queue_Buffer_control *)
40012808: 7f ff ff 04 call 40012418 <_Chain_Get>
4001280c: 90 04 60 68 add %l1, 0x68, %o0
/*
* NOTE: If the system is consistent, this error should never occur.
*/
if ( !the_message ) {
40012810: a0 92 20 00 orcc %o0, 0, %l0
40012814: 02 80 00 27 be 400128b0 <_CORE_message_queue_Submit+0x118><== NEVER TAKEN
40012818: 92 10 00 19 mov %i1, %o1
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
4001281c: 94 10 00 1a mov %i2, %o2
40012820: 40 00 1d e1 call 40019fa4 <memcpy>
40012824: 90 04 20 10 add %l0, 0x10, %o0
size
);
the_message->Contents.size = size;
the_message->priority = submit_type;
_CORE_message_queue_Insert_message(
40012828: 90 10 00 11 mov %l1, %o0
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
4001282c: f4 24 20 0c st %i2, [ %l0 + 0xc ]
the_message->priority = submit_type;
40012830: fa 24 20 08 st %i5, [ %l0 + 8 ]
_CORE_message_queue_Insert_message(
40012834: 92 10 00 10 mov %l0, %o1
40012838: 40 00 17 55 call 4001858c <_CORE_message_queue_Insert_message>
4001283c: 94 10 00 1d mov %i5, %o2
40012840: 81 c7 e0 08 ret
40012844: 91 e8 20 00 restore %g0, 0, %o0
* No message buffers were available so we may need to return an
* overflow error or block the sender until the message is placed
* on the queue.
*/
if ( !wait ) {
40012848: 02 80 00 18 be 400128a8 <_CORE_message_queue_Submit+0x110><== ALWAYS TAKEN
4001284c: b0 10 20 02 mov 2, %i0
/*
* Do NOT block on a send if the caller is in an ISR. It is
* deadly to block in an ISR.
*/
if ( _ISR_Is_in_progress() ) {
40012850: 03 10 00 c6 sethi %hi(0x40031800), %g1 <== NOT EXECUTED
40012854: c2 00 62 cc ld [ %g1 + 0x2cc ], %g1 ! 40031acc <_ISR_Nest_level><== NOT EXECUTED
40012858: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4001285c: 32 80 00 13 bne,a 400128a8 <_CORE_message_queue_Submit+0x110><== NOT EXECUTED
40012860: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
* it as a variable. Doing this emphasizes how dangerous it
* would be to use this variable prior to here.
*/
{
Thread_Control *executing = _Thread_Executing;
40012864: 03 10 00 c6 sethi %hi(0x40031800), %g1 <== NOT EXECUTED
_ISR_Disable( level );
40012868: 7f ff e3 0b call 4000b494 <sparc_disable_interrupts> <== NOT EXECUTED
4001286c: e0 00 62 f0 ld [ %g1 + 0x2f0 ], %l0 ! 40031af0 <_Thread_Executing><== NOT EXECUTED
40012870: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40012874: c2 24 60 30 st %g1, [ %l1 + 0x30 ] <== NOT EXECUTED
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
executing->Wait.return_argument_second.immutable_object = buffer;
executing->Wait.option = (uint32_t) size;
executing->Wait.count = submit_type;
40012878: fa 24 20 24 st %i5, [ %l0 + 0x24 ] <== NOT EXECUTED
Thread_Control *executing = _Thread_Executing;
_ISR_Disable( level );
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
executing->Wait.id = id;
4001287c: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
40012880: f2 24 20 2c st %i1, [ %l0 + 0x2c ] <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
40012884: f4 24 20 30 st %i2, [ %l0 + 0x30 ] <== NOT EXECUTED
{
Thread_Control *executing = _Thread_Executing;
_ISR_Disable( level );
_Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
executing->Wait.queue = &the_message_queue->Wait_queue;
40012888: e2 24 20 44 st %l1, [ %l0 + 0x44 ] <== NOT EXECUTED
executing->Wait.id = id;
executing->Wait.return_argument_second.immutable_object = buffer;
executing->Wait.option = (uint32_t) size;
executing->Wait.count = submit_type;
_ISR_Enable( level );
4001288c: 7f ff e3 06 call 4000b4a4 <sparc_enable_interrupts> <== NOT EXECUTED
40012890: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
40012894: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED
40012898: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
4001289c: 15 10 00 54 sethi %hi(0x40015000), %o2 <== NOT EXECUTED
400128a0: 40 00 09 13 call 40014cec <_Thread_queue_Enqueue_with_handler><== NOT EXECUTED
400128a4: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 400150b8 <_Thread_queue_Timeout><== NOT EXECUTED
400128a8: 81 c7 e0 08 ret
400128ac: 81 e8 00 00 restore
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
400128b0: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
400128b4: 81 c7 e0 08 ret <== NOT EXECUTED
400128b8: 81 e8 00 00 restore <== NOT EXECUTED
40005e8c <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
40005e8c: 9d e3 bf 98 save %sp, -104, %sp
/* Add this to the RTEMS environment later ?????????
rtems_assert( initial_lock == CORE_MUTEX_LOCKED ||
initial_lock == CORE_MUTEX_UNLOCKED );
*/
the_mutex->Attributes = *the_mutex_attributes;
40005e90: 94 10 20 10 mov 0x10, %o2
40005e94: 90 06 20 40 add %i0, 0x40, %o0
40005e98: 40 00 1a 9f call 4000c914 <memcpy>
40005e9c: 92 10 00 19 mov %i1, %o1
the_mutex->lock = initial_lock;
40005ea0: f4 26 20 50 st %i2, [ %i0 + 0x50 ]
the_mutex->blocked_count = 0;
40005ea4: c0 26 20 58 clr [ %i0 + 0x58 ]
if ( initial_lock == CORE_MUTEX_LOCKED ) {
40005ea8: 80 a6 a0 00 cmp %i2, 0
40005eac: 12 80 00 18 bne 40005f0c <_CORE_mutex_Initialize+0x80>
40005eb0: a0 10 00 18 mov %i0, %l0
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
40005eb4: 03 10 00 5f sethi %hi(0x40017c00), %g1
40005eb8: c6 00 63 90 ld [ %g1 + 0x390 ], %g3 ! 40017f90 <_Thread_Executing>
the_mutex->Attributes = *the_mutex_attributes;
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
40005ebc: 82 10 20 01 mov 1, %g1
40005ec0: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
40005ec4: c2 00 e0 08 ld [ %g3 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
40005ec8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
40005ecc: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
40005ed0: 80 a0 a0 02 cmp %g2, 2
40005ed4: 02 80 00 05 be 40005ee8 <_CORE_mutex_Initialize+0x5c>
40005ed8: c6 26 20 5c st %g3, [ %i0 + 0x5c ]
40005edc: 80 a0 a0 03 cmp %g2, 3
40005ee0: 32 80 00 0f bne,a 40005f1c <_CORE_mutex_Initialize+0x90> <== ALWAYS TAKEN
40005ee4: c2 06 60 08 ld [ %i1 + 8 ], %g1
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
40005ee8: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2
40005eec: c2 04 20 4c ld [ %l0 + 0x4c ], %g1
40005ef0: 80 a0 80 01 cmp %g2, %g1
40005ef4: 0a 80 00 11 bcs 40005f38 <_CORE_mutex_Initialize+0xac> <== NEVER TAKEN
40005ef8: b0 10 20 06 mov 6, %i0
_Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = _Thread_Executing->current_priority;
#endif
_Thread_Executing->resource_count++;
40005efc: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
40005f00: 82 00 60 01 inc %g1
40005f04: 10 80 00 05 b 40005f18 <_CORE_mutex_Initialize+0x8c>
40005f08: c2 20 e0 1c st %g1, [ %g3 + 0x1c ]
}
} else {
the_mutex->nest_count = 0;
40005f0c: c0 26 20 54 clr [ %i0 + 0x54 ]
the_mutex->holder = NULL;
40005f10: c0 26 20 5c clr [ %i0 + 0x5c ]
the_mutex->holder_id = 0;
40005f14: c0 26 20 60 clr [ %i0 + 0x60 ]
}
_Thread_queue_Initialize(
40005f18: c2 06 60 08 ld [ %i1 + 8 ], %g1
40005f1c: 90 10 00 10 mov %l0, %o0
40005f20: 80 a0 00 01 cmp %g0, %g1
40005f24: 94 10 24 00 mov 0x400, %o2
40005f28: 92 40 20 00 addx %g0, 0, %o1
40005f2c: 96 10 20 05 mov 5, %o3
40005f30: 40 00 07 7b call 40007d1c <_Thread_queue_Initialize>
40005f34: b0 10 20 00 clr %i0
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
40005f38: 81 c7 e0 08 ret
40005f3c: 81 e8 00 00 restore
40005fa4 <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
40005fa4: 9d e3 bf 98 save %sp, -104, %sp
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
40005fa8: 03 10 00 5f sethi %hi(0x40017c00), %g1
40005fac: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
40005fb0: 80 a0 60 00 cmp %g1, 0
40005fb4: 02 80 00 0d be 40005fe8 <_CORE_mutex_Seize+0x44>
40005fb8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40005fbc: 80 8e a0 ff btst 0xff, %i2
40005fc0: 02 80 00 0b be 40005fec <_CORE_mutex_Seize+0x48> <== NEVER TAKEN
40005fc4: 90 10 00 18 mov %i0, %o0
40005fc8: 03 10 00 60 sethi %hi(0x40018000), %g1
40005fcc: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
40005fd0: 80 a0 60 01 cmp %g1, 1
40005fd4: 08 80 00 05 bleu 40005fe8 <_CORE_mutex_Seize+0x44>
40005fd8: 90 10 20 00 clr %o0
40005fdc: 92 10 20 00 clr %o1
40005fe0: 40 00 01 7b call 400065cc <_Internal_error_Occurred>
40005fe4: 94 10 20 13 mov 0x13, %o2
40005fe8: 90 10 00 18 mov %i0, %o0
40005fec: 40 00 13 63 call 4000ad78 <_CORE_mutex_Seize_interrupt_trylock>
40005ff0: 92 07 a0 54 add %fp, 0x54, %o1
40005ff4: 80 a2 20 00 cmp %o0, 0
40005ff8: 02 80 00 09 be 4000601c <_CORE_mutex_Seize+0x78>
40005ffc: 80 8e a0 ff btst 0xff, %i2
40006000: 12 80 00 09 bne 40006024 <_CORE_mutex_Seize+0x80>
40006004: 39 10 00 5f sethi %hi(0x40017c00), %i4
40006008: 7f ff ef 39 call 40001cec <sparc_enable_interrupts>
4000600c: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
40006010: c4 07 23 90 ld [ %i4 + 0x390 ], %g2
40006014: 82 10 20 01 mov 1, %g1
40006018: c2 20 a0 34 st %g1, [ %g2 + 0x34 ]
4000601c: 81 c7 e0 08 ret
40006020: 81 e8 00 00 restore
40006024: c6 07 23 90 ld [ %i4 + 0x390 ], %g3
40006028: 05 10 00 5f sethi %hi(0x40017c00), %g2
4000602c: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
40006030: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
40006034: 82 00 60 01 inc %g1
40006038: f0 20 e0 44 st %i0, [ %g3 + 0x44 ]
4000603c: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
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;
40006040: 82 10 20 01 mov 1, %g1
40006044: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
40006048: 7f ff ef 29 call 40001cec <sparc_enable_interrupts>
4000604c: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
40006050: 90 10 00 18 mov %i0, %o0
40006054: 7f ff ff bb call 40005f40 <_CORE_mutex_Seize_interrupt_blocking>
40006058: 92 10 00 1b mov %i3, %o1
4000605c: 81 c7 e0 08 ret
40006060: 81 e8 00 00 restore
4000ad78 <_CORE_mutex_Seize_interrupt_trylock>:
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
4000ad78: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
ISR_Level level = *level_p;
/* disabled when you get here */
executing = _Thread_Executing;
4000ad7c: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000ad80: c4 00 63 90 ld [ %g1 + 0x390 ], %g2 ! 40017f90 <_Thread_Executing>
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
Thread_Control *executing;
ISR_Level level = *level_p;
4000ad84: d0 06 40 00 ld [ %i1 ], %o0
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
4000ad88: c0 20 a0 34 clr [ %g2 + 0x34 ]
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
4000ad8c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000ad90: 80 a0 60 00 cmp %g1, 0
4000ad94: 22 80 00 32 be,a 4000ae5c <_CORE_mutex_Seize_interrupt_trylock+0xe4>
4000ad98: c6 06 20 5c ld [ %i0 + 0x5c ], %g3
the_mutex->lock = CORE_MUTEX_LOCKED;
4000ad9c: c0 26 20 50 clr [ %i0 + 0x50 ]
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
4000ada0: c2 00 a0 08 ld [ %g2 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
4000ada4: c6 06 20 48 ld [ %i0 + 0x48 ], %g3
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
4000ada8: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
4000adac: c4 26 20 5c st %g2, [ %i0 + 0x5c ]
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
4000adb0: 82 10 20 01 mov 1, %g1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
4000adb4: 80 a0 e0 02 cmp %g3, 2
4000adb8: 02 80 00 05 be 4000adcc <_CORE_mutex_Seize_interrupt_trylock+0x54><== ALWAYS TAKEN
4000adbc: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
4000adc0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED
4000adc4: 32 80 00 06 bne,a 4000addc <_CORE_mutex_Seize_interrupt_trylock+0x64><== NOT EXECUTED
4000adc8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
4000adcc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1
4000add0: 82 00 60 01 inc %g1
4000add4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ]
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
4000add8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
4000addc: 80 a0 60 03 cmp %g1, 3
4000ade0: 22 80 00 03 be,a 4000adec <_CORE_mutex_Seize_interrupt_trylock+0x74><== NEVER TAKEN
4000ade4: c6 06 20 4c ld [ %i0 + 0x4c ], %g3 <== NOT EXECUTED
_ISR_Enable( level );
4000ade8: 30 80 00 2c b,a 4000ae98 <_CORE_mutex_Seize_interrupt_trylock+0x120>
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
4000adec: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED
if ( current == ceiling ) {
4000adf0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
4000adf4: 12 80 00 03 bne 4000ae00 <_CORE_mutex_Seize_interrupt_trylock+0x88><== NOT EXECUTED
4000adf8: 01 00 00 00 nop <== NOT EXECUTED
_ISR_Enable( level );
4000adfc: 30 80 00 27 b,a 4000ae98 <_CORE_mutex_Seize_interrupt_trylock+0x120><== NOT EXECUTED
return 0;
}
if ( current > ceiling ) {
4000ae00: 08 80 00 0f bleu 4000ae3c <_CORE_mutex_Seize_interrupt_trylock+0xc4><== NOT EXECUTED
4000ae04: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
4000ae08: 05 10 00 5f sethi %hi(0x40017c00), %g2 <== NOT EXECUTED
4000ae0c: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
4000ae10: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000ae14: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ] <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( level );
4000ae18: 7f ff db b5 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
4000ae1c: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Change_priority(
4000ae20: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== NOT EXECUTED
4000ae24: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 <== NOT EXECUTED
4000ae28: 7f ff f0 52 call 40006f70 <_Thread_Change_priority> <== NOT EXECUTED
4000ae2c: 94 10 20 00 clr %o2 <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
FALSE
);
_Thread_Enable_dispatch();
4000ae30: 7f ff f1 c3 call 4000753c <_Thread_Enable_dispatch> <== NOT EXECUTED
4000ae34: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000ae38: 30 80 00 1a b,a 4000aea0 <_CORE_mutex_Seize_interrupt_trylock+0x128><== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
4000ae3c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED
the_mutex->lock = CORE_MUTEX_UNLOCKED;
4000ae40: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
the_mutex->nest_count = 0; /* undo locking above */
4000ae44: c0 26 20 54 clr [ %i0 + 0x54 ] <== NOT EXECUTED
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
4000ae48: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
4000ae4c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
4000ae50: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000ae54: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED
_ISR_Enable( level );
4000ae58: 30 80 00 10 b,a 4000ae98 <_CORE_mutex_Seize_interrupt_trylock+0x120><== NOT EXECUTED
/*
* 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 ) ) {
4000ae5c: 80 a0 c0 02 cmp %g3, %g2
4000ae60: 12 80 00 12 bne 4000aea8 <_CORE_mutex_Seize_interrupt_trylock+0x130>
4000ae64: 01 00 00 00 nop
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
4000ae68: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
4000ae6c: 80 a0 60 00 cmp %g1, 0
4000ae70: 22 80 00 07 be,a 4000ae8c <_CORE_mutex_Seize_interrupt_trylock+0x114>
4000ae74: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
4000ae78: 80 a0 60 01 cmp %g1, 1
4000ae7c: 12 80 00 0b bne 4000aea8 <_CORE_mutex_Seize_interrupt_trylock+0x130>
4000ae80: 82 10 20 02 mov 2, %g1
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
_ISR_Enable( level );
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
4000ae84: 10 80 00 05 b 4000ae98 <_CORE_mutex_Seize_interrupt_trylock+0x120>
4000ae88: c2 20 e0 34 st %g1, [ %g3 + 0x34 ]
* 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++;
4000ae8c: 82 00 60 01 inc %g1
4000ae90: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
_ISR_Enable( level );
4000ae94: 30 80 00 01 b,a 4000ae98 <_CORE_mutex_Seize_interrupt_trylock+0x120>
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
_ISR_Enable( level );
4000ae98: 7f ff db 95 call 40001cec <sparc_enable_interrupts>
4000ae9c: b0 10 20 00 clr %i0
4000aea0: 81 c7 e0 08 ret
4000aea4: 81 e8 00 00 restore
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
4000aea8: 81 c7 e0 08 ret
4000aeac: 91 e8 20 01 restore %g0, 1, %o0
40006064 <_CORE_mutex_Surrender>:
CORE_mutex_Status _CORE_mutex_Surrender(
CORE_mutex_Control *the_mutex,
Objects_Id id,
CORE_mutex_API_mp_support_callout api_mutex_mp_support
)
{
40006064: 9d e3 bf 98 save %sp, -104, %sp
* 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 ) {
40006068: c2 0e 20 44 ldub [ %i0 + 0x44 ], %g1
CORE_mutex_Status _CORE_mutex_Surrender(
CORE_mutex_Control *the_mutex,
Objects_Id id,
CORE_mutex_API_mp_support_callout api_mutex_mp_support
)
{
4000606c: a0 10 00 18 mov %i0, %l0
* 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 ) {
40006070: 80 a0 60 00 cmp %g1, 0
40006074: 02 80 00 07 be 40006090 <_CORE_mutex_Surrender+0x2c>
40006078: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !_Thread_Is_executing( holder ) )
4000607c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40006080: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
40006084: 80 a2 00 01 cmp %o0, %g1
40006088: 12 80 00 52 bne 400061d0 <_CORE_mutex_Surrender+0x16c>
4000608c: b0 10 20 03 mov 3, %i0
return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
}
/* XXX already unlocked -- not right status */
if ( !the_mutex->nest_count )
40006090: c2 04 20 54 ld [ %l0 + 0x54 ], %g1
40006094: 80 a0 60 00 cmp %g1, 0
40006098: 02 80 00 4d be 400061cc <_CORE_mutex_Surrender+0x168>
4000609c: 82 00 7f ff add %g1, -1, %g1
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
400060a0: 80 a0 60 00 cmp %g1, 0
400060a4: 02 80 00 09 be 400060c8 <_CORE_mutex_Surrender+0x64>
400060a8: c2 24 20 54 st %g1, [ %l0 + 0x54 ]
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
400060ac: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
400060b0: 80 a0 60 00 cmp %g1, 0
400060b4: 02 80 00 47 be 400061d0 <_CORE_mutex_Surrender+0x16c> <== ALWAYS TAKEN
400060b8: b0 10 20 00 clr %i0
400060bc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
400060c0: 02 80 00 44 be 400061d0 <_CORE_mutex_Surrender+0x16c> <== NOT EXECUTED
400060c4: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
400060c8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
400060cc: 80 a0 60 02 cmp %g1, 2
400060d0: 02 80 00 04 be 400060e0 <_CORE_mutex_Surrender+0x7c>
400060d4: 80 a0 60 03 cmp %g1, 3
400060d8: 32 80 00 07 bne,a 400060f4 <_CORE_mutex_Surrender+0x90> <== ALWAYS TAKEN
400060dc: c0 24 20 5c clr [ %l0 + 0x5c ]
the_mutex->nest_count++;
return CORE_MUTEX_RELEASE_NOT_ORDER;
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
400060e0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
400060e4: 82 00 7f ff add %g1, -1, %g1
400060e8: c2 22 20 1c st %g1, [ %o0 + 0x1c ]
400060ec: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
}
the_mutex->holder = NULL;
400060f0: c0 24 20 5c clr [ %l0 + 0x5c ]
/*
* 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 ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
400060f4: 80 a0 60 02 cmp %g1, 2
400060f8: 02 80 00 05 be 4000610c <_CORE_mutex_Surrender+0xa8>
400060fc: c0 24 20 60 clr [ %l0 + 0x60 ]
40006100: 80 a0 60 03 cmp %g1, 3
40006104: 12 80 00 0d bne 40006138 <_CORE_mutex_Surrender+0xd4> <== ALWAYS TAKEN
40006108: 01 00 00 00 nop
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
if(the_mutex->queue.priority_before != holder->current_priority)
_Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE);
#endif
if ( holder->resource_count == 0 &&
4000610c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
40006110: 80 a0 60 00 cmp %g1, 0
40006114: 12 80 00 09 bne 40006138 <_CORE_mutex_Surrender+0xd4>
40006118: 01 00 00 00 nop
4000611c: d2 02 20 18 ld [ %o0 + 0x18 ], %o1
40006120: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40006124: 80 a2 40 01 cmp %o1, %g1
40006128: 02 80 00 04 be 40006138 <_CORE_mutex_Surrender+0xd4>
4000612c: 01 00 00 00 nop
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, TRUE );
40006130: 40 00 03 90 call 40006f70 <_Thread_Change_priority>
40006134: 94 10 20 01 mov 1, %o2 ! 1 <PROM_START+0x1>
/*
* 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 ) ) ) {
40006138: 40 00 05 dc call 400078a8 <_Thread_queue_Dequeue>
4000613c: 90 10 00 10 mov %l0, %o0
40006140: 86 92 20 00 orcc %o0, 0, %g3
40006144: 02 80 00 1f be 400061c0 <_CORE_mutex_Surrender+0x15c>
40006148: 82 10 20 01 mov 1, %g1
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
4000614c: c2 00 e0 08 ld [ %g3 + 8 ], %g1
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
40006150: c4 04 20 48 ld [ %l0 + 0x48 ], %g2
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
40006154: c2 24 20 60 st %g1, [ %l0 + 0x60 ]
} else
#endif
{
the_mutex->holder = the_thread;
40006158: c6 24 20 5c st %g3, [ %l0 + 0x5c ]
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
4000615c: 82 10 20 01 mov 1, %g1
switch ( the_mutex->Attributes.discipline ) {
40006160: 80 a0 a0 02 cmp %g2, 2
40006164: 02 80 00 07 be 40006180 <_CORE_mutex_Surrender+0x11c>
40006168: c2 24 20 54 st %g1, [ %l0 + 0x54 ]
4000616c: 80 a0 a0 03 cmp %g2, 3
40006170: 12 80 00 18 bne 400061d0 <_CORE_mutex_Surrender+0x16c> <== ALWAYS TAKEN
40006174: b0 10 20 00 clr %i0
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
40006178: 10 80 00 07 b 40006194 <_CORE_mutex_Surrender+0x130> <== NOT EXECUTED
4000617c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
40006180: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
40006184: 82 00 60 01 inc %g1
40006188: c2 20 e0 1c st %g1, [ %g3 + 0x1c ]
4000618c: 81 c7 e0 08 ret
40006190: 91 e8 20 00 restore %g0, 0, %o0
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
if (the_mutex->Attributes.priority_ceiling <
40006194: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
#ifdef __RTEMS_STRICT_ORDER_MUTEX__
_Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue);
the_mutex->queue.priority_before = the_thread->current_priority;
#endif
the_thread->resource_count++;
40006198: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000619c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
400061a0: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 <== NOT EXECUTED
400061a4: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
400061a8: 3a 80 00 0a bcc,a 400061d0 <_CORE_mutex_Surrender+0x16c> <== NOT EXECUTED
400061ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
400061b0: 40 00 03 70 call 40006f70 <_Thread_Change_priority> <== NOT EXECUTED
400061b4: 94 10 20 00 clr %o2 <== NOT EXECUTED
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
400061b8: 81 c7 e0 08 ret <== NOT EXECUTED
400061bc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
400061c0: c2 24 20 50 st %g1, [ %l0 + 0x50 ]
400061c4: 81 c7 e0 08 ret
400061c8: 91 e8 20 00 restore %g0, 0, %o0
400061cc: b0 10 20 00 clr %i0
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
400061d0: 81 c7 e0 08 ret
400061d4: 81 e8 00 00 restore
40006224 <_CORE_semaphore_Surrender>:
CORE_semaphore_Status _CORE_semaphore_Surrender(
CORE_semaphore_Control *the_semaphore,
Objects_Id id,
CORE_semaphore_API_mp_support_callout api_semaphore_mp_support
)
{
40006224: 9d e3 bf 98 save %sp, -104, %sp
40006228: a0 10 00 18 mov %i0, %l0
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
4000622c: b0 10 20 00 clr %i0
40006230: 40 00 05 9e call 400078a8 <_Thread_queue_Dequeue>
40006234: 90 10 00 10 mov %l0, %o0
40006238: 80 a2 20 00 cmp %o0, 0
4000623c: 12 80 00 0e bne 40006274 <_CORE_semaphore_Surrender+0x50>
40006240: 01 00 00 00 nop
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
40006244: 7f ff ee a6 call 40001cdc <sparc_disable_interrupts>
40006248: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
4000624c: c4 04 20 48 ld [ %l0 + 0x48 ], %g2
40006250: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
40006254: 80 a0 80 01 cmp %g2, %g1
40006258: 1a 80 00 05 bcc 4000626c <_CORE_semaphore_Surrender+0x48> <== NEVER TAKEN
4000625c: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
40006260: 82 00 a0 01 add %g2, 1, %g1
40006264: b0 10 20 00 clr %i0
40006268: c2 24 20 48 st %g1, [ %l0 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
4000626c: 7f ff ee a0 call 40001cec <sparc_enable_interrupts>
40006270: 01 00 00 00 nop
}
return status;
}
40006274: 81 c7 e0 08 ret
40006278: 81 e8 00 00 restore
4000ac6c <_Debug_Is_enabled>:
*/
bool _Debug_Is_enabled(
rtems_debug_control level
)
{
4000ac6c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000ac70: c2 00 63 94 ld [ %g1 + 0x394 ], %g1 ! 40017f94 <_Debug_Level><== NOT EXECUTED
4000ac74: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED
4000ac78: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
return (_Debug_Level & level) ? true : false;
}
4000ac7c: 81 c3 e0 08 retl <== NOT EXECUTED
4000ac80: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED
40004d9c <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
40004d9c: 9d e3 bf 98 save %sp, -104, %sp
rtems_event_set pending_events;
ISR_Level level;
RTEMS_API_Control *api;
Thread_blocking_operation_States sync_state;
executing = _Thread_Executing;
40004da0: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004da4: e0 00 63 90 ld [ %g1 + 0x390 ], %l0 ! 40017f90 <_Thread_Executing>
executing->Wait.return_code = RTEMS_SUCCESSFUL;
40004da8: c0 24 20 34 clr [ %l0 + 0x34 ]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
_ISR_Disable( level );
40004dac: 7f ff f3 cc call 40001cdc <sparc_disable_interrupts>
40004db0: e4 04 21 5c ld [ %l0 + 0x15c ], %l2
pending_events = api->pending_events;
40004db4: c2 04 80 00 ld [ %l2 ], %g1
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
40004db8: a2 8e 00 01 andcc %i0, %g1, %l1
40004dbc: 02 80 00 0e be 40004df4 <_Event_Seize+0x58>
40004dc0: 80 8e 60 01 btst 1, %i1
40004dc4: 80 a4 40 18 cmp %l1, %i0
40004dc8: 02 80 00 04 be 40004dd8 <_Event_Seize+0x3c>
40004dcc: 80 8e 60 02 btst 2, %i1
40004dd0: 02 80 00 09 be 40004df4 <_Event_Seize+0x58> <== NEVER TAKEN
40004dd4: 80 8e 60 01 btst 1, %i1
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
40004dd8: 82 28 40 11 andn %g1, %l1, %g1
40004ddc: c2 24 80 00 st %g1, [ %l2 ]
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
40004de0: 7f ff f3 c3 call 40001cec <sparc_enable_interrupts>
40004de4: 01 00 00 00 nop
40004de8: e2 26 c0 00 st %l1, [ %i3 ]
40004dec: 81 c7 e0 08 ret
40004df0: 81 e8 00 00 restore
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
40004df4: 02 80 00 09 be 40004e18 <_Event_Seize+0x7c>
40004df8: 84 10 20 01 mov 1, %g2
_ISR_Enable( level );
40004dfc: 7f ff f3 bc call 40001cec <sparc_enable_interrupts>
40004e00: 01 00 00 00 nop
executing->Wait.return_code = RTEMS_UNSATISFIED;
40004e04: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
40004e08: c2 24 20 34 st %g1, [ %l0 + 0x34 ]
*event_out = seized_events;
40004e0c: e2 26 c0 00 st %l1, [ %i3 ]
40004e10: 81 c7 e0 08 ret
40004e14: 81 e8 00 00 restore
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40004e18: 03 10 00 60 sethi %hi(0x40018000), %g1
executing->Wait.option = (uint32_t) option_set;
40004e1c: f2 24 20 30 st %i1, [ %l0 + 0x30 ]
executing->Wait.count = (uint32_t) event_in;
40004e20: f0 24 20 24 st %i0, [ %l0 + 0x24 ]
executing->Wait.return_argument = event_out;
40004e24: f6 24 20 28 st %i3, [ %l0 + 0x28 ]
executing->Wait.return_code = RTEMS_UNSATISFIED;
*event_out = seized_events;
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
40004e28: c4 20 61 a4 st %g2, [ %g1 + 0x1a4 ]
executing->Wait.option = (uint32_t) option_set;
executing->Wait.count = (uint32_t) event_in;
executing->Wait.return_argument = event_out;
_ISR_Enable( level );
40004e2c: 7f ff f3 b0 call 40001cec <sparc_enable_interrupts>
40004e30: 01 00 00 00 nop
if ( ticks ) {
40004e34: 80 a6 a0 00 cmp %i2, 0
40004e38: 02 80 00 0f be 40004e74 <_Event_Seize+0xd8>
40004e3c: 90 10 00 10 mov %l0, %o0
_Watchdog_Initialize(
40004e40: c2 04 20 08 ld [ %l0 + 8 ], %g1
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40004e44: 11 10 00 5f sethi %hi(0x40017c00), %o0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
40004e48: c2 24 20 68 st %g1, [ %l0 + 0x68 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40004e4c: 03 10 00 14 sethi %hi(0x40005000), %g1
40004e50: 82 10 60 44 or %g1, 0x44, %g1 ! 40005044 <_Event_Timeout>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40004e54: f4 24 20 54 st %i2, [ %l0 + 0x54 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40004e58: c0 24 20 50 clr [ %l0 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40004e5c: c0 24 20 6c clr [ %l0 + 0x6c ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40004e60: c2 24 20 64 st %g1, [ %l0 + 0x64 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40004e64: 90 12 23 b0 or %o0, 0x3b0, %o0
40004e68: 40 00 0e 0e call 400086a0 <_Watchdog_Insert>
40004e6c: 92 04 20 48 add %l0, 0x48, %o1
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
40004e70: 90 10 00 10 mov %l0, %o0
40004e74: 40 00 0c 0f call 40007eb0 <_Thread_Set_state>
40004e78: 92 10 21 00 mov 0x100, %o1
_ISR_Disable( level );
40004e7c: 7f ff f3 98 call 40001cdc <sparc_disable_interrupts>
40004e80: 01 00 00 00 nop
sync_state = _Event_Sync_state;
40004e84: 03 10 00 60 sethi %hi(0x40018000), %g1
40004e88: f0 00 61 a4 ld [ %g1 + 0x1a4 ], %i0 ! 400181a4 <_Event_Sync_state>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
40004e8c: c0 20 61 a4 clr [ %g1 + 0x1a4 ]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
40004e90: 80 a6 20 01 cmp %i0, 1
40004e94: 12 80 00 04 bne 40004ea4 <_Event_Seize+0x108>
40004e98: b2 10 00 10 mov %l0, %i1
_ISR_Enable( level );
40004e9c: 7f ff f3 94 call 40001cec <sparc_enable_interrupts>
40004ea0: 91 e8 00 08 restore %g0, %o0, %o0
* 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 );
40004ea4: 40 00 08 1e call 40006f1c <_Thread_blocking_operation_Cancel>
40004ea8: 95 e8 00 08 restore %g0, %o0, %o2
40004f08 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
40004f08: 9d e3 bf 98 save %sp, -104, %sp
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 ];
40004f0c: e0 06 21 5c ld [ %i0 + 0x15c ], %l0
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
40004f10: 7f ff f3 73 call 40001cdc <sparc_disable_interrupts>
40004f14: e2 06 20 30 ld [ %i0 + 0x30 ], %l1
40004f18: b2 10 00 08 mov %o0, %i1
pending_events = api->pending_events;
40004f1c: c8 04 00 00 ld [ %l0 ], %g4
event_condition = (rtems_event_set) the_thread->Wait.count;
40004f20: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
40004f24: 86 88 80 04 andcc %g2, %g4, %g3
40004f28: 12 80 00 03 bne 40004f34 <_Event_Surrender+0x2c>
40004f2c: 03 10 00 5f sethi %hi(0x40017c00), %g1
_ISR_Enable( level );
40004f30: 30 80 00 42 b,a 40005038 <_Event_Surrender+0x130>
/*
* 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() &&
40004f34: c2 00 63 6c ld [ %g1 + 0x36c ], %g1 ! 40017f6c <_ISR_Nest_level>
40004f38: 80 a0 60 00 cmp %g1, 0
40004f3c: 22 80 00 1e be,a 40004fb4 <_Event_Surrender+0xac>
40004f40: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40004f44: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004f48: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
40004f4c: 80 a6 00 01 cmp %i0, %g1
40004f50: 32 80 00 19 bne,a 40004fb4 <_Event_Surrender+0xac>
40004f54: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40004f58: 1b 10 00 60 sethi %hi(0x40018000), %o5
40004f5c: c2 03 61 a4 ld [ %o5 + 0x1a4 ], %g1 ! 400181a4 <_Event_Sync_state>
40004f60: 80 a0 60 01 cmp %g1, 1
40004f64: 02 80 00 07 be 40004f80 <_Event_Surrender+0x78> <== ALWAYS TAKEN
40004f68: 80 a0 c0 02 cmp %g3, %g2
40004f6c: c2 03 61 a4 ld [ %o5 + 0x1a4 ], %g1 <== NOT EXECUTED
40004f70: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40004f74: 32 80 00 10 bne,a 40004fb4 <_Event_Surrender+0xac> <== NOT EXECUTED
40004f78: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
40004f7c: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
40004f80: 02 80 00 04 be 40004f90 <_Event_Surrender+0x88> <== ALWAYS TAKEN
40004f84: 80 8c 60 02 btst 2, %l1
40004f88: 02 80 00 0a be 40004fb0 <_Event_Surrender+0xa8> <== NOT EXECUTED
40004f8c: 01 00 00 00 nop <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
40004f90: 82 29 00 03 andn %g4, %g3, %g1
40004f94: c2 24 00 00 st %g1, [ %l0 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40004f98: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
40004f9c: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40004fa0: c6 20 40 00 st %g3, [ %g1 ]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
40004fa4: 84 10 20 03 mov 3, %g2
40004fa8: 03 10 00 60 sethi %hi(0x40018000), %g1
40004fac: c4 20 61 a4 st %g2, [ %g1 + 0x1a4 ] ! 400181a4 <_Event_Sync_state>
}
_ISR_Enable( level );
40004fb0: 30 80 00 22 b,a 40005038 <_Event_Surrender+0x130>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
40004fb4: 80 88 61 00 btst 0x100, %g1
40004fb8: 02 80 00 20 be 40005038 <_Event_Surrender+0x130> <== NEVER TAKEN
40004fbc: 80 a0 c0 02 cmp %g3, %g2
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
40004fc0: 02 80 00 04 be 40004fd0 <_Event_Surrender+0xc8>
40004fc4: 80 8c 60 02 btst 2, %l1
40004fc8: 02 80 00 1c be 40005038 <_Event_Surrender+0x130> <== NEVER TAKEN
40004fcc: 01 00 00 00 nop
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
40004fd0: 82 29 00 03 andn %g4, %g3, %g1
40004fd4: c2 24 00 00 st %g1, [ %l0 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40004fd8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
* 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 );
the_thread->Wait.count = 0;
40004fdc: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
40004fe0: c6 20 40 00 st %g3, [ %g1 ]
_ISR_Flash( level );
40004fe4: 7f ff f3 42 call 40001cec <sparc_enable_interrupts>
40004fe8: 90 10 00 19 mov %i1, %o0
40004fec: 7f ff f3 3c call 40001cdc <sparc_disable_interrupts>
40004ff0: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
40004ff4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
40004ff8: 80 a0 60 02 cmp %g1, 2
40004ffc: 02 80 00 06 be 40005014 <_Event_Surrender+0x10c>
40005000: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
40005004: 7f ff f3 3a call 40001cec <sparc_enable_interrupts>
40005008: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000500c: 10 80 00 08 b 4000502c <_Event_Surrender+0x124>
40005010: 33 04 00 ff sethi %hi(0x1003fc00), %i1
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
40005014: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
40005018: 7f ff f3 35 call 40001cec <sparc_enable_interrupts>
4000501c: 90 10 00 19 mov %i1, %o0
(void) _Watchdog_Remove( &the_thread->Timer );
40005020: 40 00 0d fa call 40008808 <_Watchdog_Remove>
40005024: 90 06 20 48 add %i0, 0x48, %o0
40005028: 33 04 00 ff sethi %hi(0x1003fc00), %i1
4000502c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
40005030: 40 00 08 48 call 40007150 <_Thread_Clear_state>
40005034: 81 e8 00 00 restore
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
40005038: 7f ff f3 2d call 40001cec <sparc_enable_interrupts>
4000503c: 91 e8 00 19 restore %g0, %i1, %o0
40005044 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
40005044: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
40005048: 90 10 00 18 mov %i0, %o0
4000504c: 40 00 09 49 call 40007570 <_Thread_Get>
40005050: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40005054: c2 07 bf f4 ld [ %fp + -12 ], %g1
40005058: 80 a0 60 00 cmp %g1, 0
4000505c: 12 80 00 0f bne 40005098 <_Event_Timeout+0x54> <== NEVER TAKEN
40005060: b0 10 00 08 mov %o0, %i0
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
40005064: 7f ff f3 1e call 40001cdc <sparc_disable_interrupts>
40005068: 01 00 00 00 nop
4000506c: 86 10 00 08 mov %o0, %g3
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
40005070: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40005074: 80 a0 60 00 cmp %g1, 0
40005078: 12 80 00 0a bne 400050a0 <_Event_Timeout+0x5c> <== ALWAYS TAKEN
4000507c: 03 10 00 5f sethi %hi(0x40017c00), %g1
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
40005080: 05 10 00 5f sethi %hi(0x40017c00), %g2 <== NOT EXECUTED
40005084: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
40005088: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000508c: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ] <== NOT EXECUTED
_Thread_Unnest_dispatch();
_ISR_Enable( level );
40005090: 7f ff f3 17 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40005094: 01 00 00 00 nop <== NOT EXECUTED
40005098: 81 c7 e0 08 ret <== NOT EXECUTED
4000509c: 81 e8 00 00 restore <== NOT EXECUTED
return;
}
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
400050a0: c2 00 63 90 ld [ %g1 + 0x390 ], %g1
400050a4: 80 a6 00 01 cmp %i0, %g1
400050a8: 12 80 00 09 bne 400050cc <_Event_Timeout+0x88>
400050ac: c0 26 20 24 clr [ %i0 + 0x24 ]
Thread_blocking_operation_States sync = _Event_Sync_state;
400050b0: 05 10 00 60 sethi %hi(0x40018000), %g2
400050b4: c2 00 a1 a4 ld [ %g2 + 0x1a4 ], %g1 ! 400181a4 <_Event_Sync_state>
if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
400050b8: 80 a0 60 01 cmp %g1, 1
400050bc: 18 80 00 05 bgu 400050d0 <_Event_Timeout+0x8c> <== NEVER TAKEN
400050c0: 82 10 20 06 mov 6, %g1
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
400050c4: 82 10 20 02 mov 2, %g1
400050c8: c2 20 a1 a4 st %g1, [ %g2 + 0x1a4 ]
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
400050cc: 82 10 20 06 mov 6, %g1
400050d0: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
_ISR_Enable( level );
400050d4: 7f ff f3 06 call 40001cec <sparc_enable_interrupts>
400050d8: 90 10 00 03 mov %g3, %o0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
400050dc: 90 10 00 18 mov %i0, %o0
400050e0: 13 04 00 ff sethi %hi(0x1003fc00), %o1
400050e4: 40 00 08 1b call 40007150 <_Thread_Clear_state>
400050e8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
400050ec: 05 10 00 5f sethi %hi(0x40017c00), %g2
400050f0: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
400050f4: 82 00 7f ff add %g1, -1, %g1
400050f8: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
400050fc: 81 c7 e0 08 ret
40005100: 81 e8 00 00 restore
4000af14 <_Heap_Allocate>:
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
4000af14: 9d e3 bf 98 save %sp, -104, %sp
Heap_Block *the_block;
void *ptr = NULL;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
the_size =
4000af18: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000af1c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
4000af20: a0 10 00 18 mov %i0, %l0
Heap_Block *the_block;
void *ptr = NULL;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
the_size =
4000af24: 90 10 00 19 mov %i1, %o0
4000af28: 7f ff ed 6b call 400064d4 <_Heap_Calc_block_size>
4000af2c: b0 10 20 00 clr %i0
_Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
if(the_size == 0)
4000af30: 80 a2 20 00 cmp %o0, 0
4000af34: 02 80 00 1d be 4000afa8 <_Heap_Allocate+0x94> <== NEVER TAKEN
4000af38: b2 10 20 00 clr %i1
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
4000af3c: 10 80 00 13 b 4000af88 <_Heap_Allocate+0x74>
4000af40: f0 04 20 08 ld [ %l0 + 8 ], %i0
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
/* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the
result of the comparison. */
if(the_block->size >= the_size) {
4000af44: 80 a0 40 08 cmp %g1, %o0
4000af48: 2a 80 00 0f bcs,a 4000af84 <_Heap_Allocate+0x70>
4000af4c: f0 06 20 08 ld [ %i0 + 8 ], %i0
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
4000af50: 94 10 00 08 mov %o0, %o2
4000af54: 92 10 00 18 mov %i0, %o1
4000af58: 7f ff ed 73 call 40006524 <_Heap_Block_allocate>
4000af5c: 90 10 00 10 mov %l0, %o0
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
4000af60: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
stats->searches += search_count + 1;
4000af64: c4 04 20 4c ld [ %l0 + 0x4c ], %g2
if(the_block->size >= the_size) {
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
4000af68: 82 00 60 01 inc %g1
stats->searches += search_count + 1;
4000af6c: 84 00 a0 01 inc %g2
if(the_block->size >= the_size) {
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
4000af70: c2 24 20 48 st %g1, [ %l0 + 0x48 ]
stats->searches += search_count + 1;
4000af74: 84 00 80 19 add %g2, %i1, %g2
4000af78: b0 06 20 08 add %i0, 8, %i0
4000af7c: 10 80 00 07 b 4000af98 <_Heap_Allocate+0x84>
4000af80: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
4000af84: b2 06 60 01 inc %i1
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
4000af88: 80 a6 00 10 cmp %i0, %l0
4000af8c: 32 bf ff ee bne,a 4000af44 <_Heap_Allocate+0x30>
4000af90: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000af94: b0 10 20 00 clr %i0
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
4000af98: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
4000af9c: 80 a0 40 19 cmp %g1, %i1
4000afa0: 2a 80 00 02 bcs,a 4000afa8 <_Heap_Allocate+0x94>
4000afa4: f2 24 20 44 st %i1, [ %l0 + 0x44 ]
stats->max_search = search_count;
return ptr;
}
4000afa8: 81 c7 e0 08 ret
4000afac: 81 e8 00 00 restore
4000920c <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
)
{
4000920c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t search_count;
Heap_Block *the_block;
void *user_ptr = NULL;
uint32_t const page_size = the_heap->page_size;
40009210: e8 06 20 10 ld [ %i0 + 0x10 ], %l4
Heap_Block *const tail = _Heap_Tail(the_heap);
uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;
uint32_t const the_size =
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
40009214: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
40009218: 90 10 00 19 mov %i1, %o0
4000921c: 40 00 01 5d call 40009790 <_Heap_Calc_block_size>
40009220: 92 10 00 14 mov %l4, %o1
void *user_ptr = NULL;
uint32_t const page_size = the_heap->page_size;
Heap_Statistics *const stats = &the_heap->stats;
Heap_Block *const tail = _Heap_Tail(the_heap);
uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET;
40009224: b2 06 7f fc add %i1, -4, %i1
uint32_t const the_size =
_Heap_Calc_block_size(size, page_size, the_heap->min_block_size);
if(the_size == 0)
40009228: ba 92 20 00 orcc %o0, 0, %i5
4000922c: 02 80 00 67 be 400093c8 <_Heap_Allocate_aligned+0x1bc> <== NEVER TAKEN
40009230: 90 10 20 00 clr %o0
return NULL;
if(alignment == 0)
40009234: 80 a6 a0 00 cmp %i2, 0
40009238: 22 80 00 02 be,a 40009240 <_Heap_Allocate_aligned+0x34>
4000923c: b4 10 20 08 mov 8, %i2
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
40009240: e2 06 20 08 ld [ %i0 + 8 ], %l1
40009244: 10 80 00 59 b 400093a8 <_Heap_Allocate_aligned+0x19c>
40009248: aa 10 20 00 clr %l5
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
4000924c: a6 08 7f fe and %g1, -2, %l3
uint32_t const block_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
if(block_size >= the_size) { /* the_block is large enough. */
40009250: 80 a4 c0 1d cmp %l3, %i5
40009254: 2a 80 00 54 bcs,a 400093a4 <_Heap_Allocate_aligned+0x198>
40009258: e2 04 60 08 ld [ %l1 + 8 ], %l1
_H_uptr_t *value,
uint32_t alignment
)
{
_H_uptr_t v = *value;
*value = v - (v % alignment);
4000925c: 92 10 00 1a mov %i2, %o1
/* Calculate 'aligned_user_addr' that will become the user pointer we
return. It should be at least 'end_to_user_offs' bytes less than the
the 'block_end' and should be aligned on 'alignment' boundary.
Calculations are from the 'block_end' as we are going to split free
block so that the upper part of the block becomes used block. */
_H_uptr_t const block_end = _H_p2u(the_block) + block_size;
40009260: ae 04 40 13 add %l1, %l3, %l7
aligned_user_addr = block_end - end_to_user_offs;
40009264: a0 25 c0 19 sub %l7, %i1, %l0
40009268: 40 00 3c 8d call 4001849c <.urem>
4000926c: 90 10 00 10 mov %l0, %o0
if(block_size >= the_size) { /* the_block is large enough. */
_H_uptr_t user_addr;
_H_uptr_t aligned_user_addr;
_H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
40009270: 92 10 00 14 mov %l4, %o1
40009274: a4 24 00 08 sub %l0, %o0, %l2
40009278: 40 00 3c 89 call 4001849c <.urem>
4000927c: 90 10 00 12 mov %l2, %o0
40009280: a0 04 60 08 add %l1, 8, %l0
40009284: 84 24 80 08 sub %l2, %o0, %g2
only at 'page_size' aligned addresses */
user_addr = aligned_user_addr;
_Heap_Align_down_uptr(&user_addr, page_size);
/* Make sure 'user_addr' calculated didn't run out of 'the_block'. */
if(user_addr >= user_area) {
40009288: 80 a0 80 10 cmp %g2, %l0
4000928c: 2a 80 00 46 bcs,a 400093a4 <_Heap_Allocate_aligned+0x198>
40009290: e2 04 60 08 ld [ %l1 + 8 ], %l1
/* The block seems to be acceptable. Check if the remainder of
'the_block' is less than 'min_block_size' so that 'the_block' won't
actually be split at the address we assume. */
if(user_addr - user_area < the_heap->min_block_size) {
40009294: ec 06 20 14 ld [ %i0 + 0x14 ], %l6
40009298: 82 20 80 10 sub %g2, %l0, %g1
4000929c: 80 a0 40 16 cmp %g1, %l6
400092a0: 1a 80 00 15 bcc 400092f4 <_Heap_Allocate_aligned+0xe8>
400092a4: 80 a4 a0 00 cmp %l2, 0
'aligned_user_addr' to be outside of [0,page_size) range. If we do,
we will need to store this distance somewhere to be able to
resurrect the block address from the user pointer. (Having the
distance within [0,page_size) range allows resurrection by
aligning user pointer down to the nearest 'page_size' boundary.) */
if(aligned_user_addr - user_addr >= page_size) {
400092a8: 82 24 80 10 sub %l2, %l0, %g1
400092ac: 80 a0 40 14 cmp %g1, %l4
400092b0: 0a 80 00 10 bcs 400092f0 <_Heap_Allocate_aligned+0xe4> <== ALWAYS TAKEN
400092b4: 84 10 00 10 mov %l0, %g2
uint32_t alignment
)
{
_H_uptr_t v = *value;
uint32_t a = alignment;
_H_uptr_t r = v % a;
400092b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400092bc: 40 00 3c 78 call 4001849c <.urem> <== NOT EXECUTED
400092c0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
*value = r ? v - r + a : v;
400092c4: 82 04 00 1a add %l0, %i2, %g1 <== NOT EXECUTED
400092c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400092cc: 12 80 00 03 bne 400092d8 <_Heap_Allocate_aligned+0xcc> <== NOT EXECUTED
400092d0: 90 20 40 08 sub %g1, %o0, %o0 <== NOT EXECUTED
400092d4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
/* The user pointer will be too far from 'user_addr'. See if we
can make 'aligned_user_addr' to be close enough to the
'user_addr'. */
aligned_user_addr = user_addr;
_Heap_Align_up_uptr(&aligned_user_addr, alignment);
if(aligned_user_addr - user_addr >= page_size) {
400092d8: 82 22 00 10 sub %o0, %l0, %g1 <== NOT EXECUTED
400092dc: 80 a0 40 14 cmp %g1, %l4 <== NOT EXECUTED
400092e0: 3a 80 00 31 bcc,a 400093a4 <_Heap_Allocate_aligned+0x198><== NOT EXECUTED
400092e4: e2 04 60 08 ld [ %l1 + 8 ], %l1 <== NOT EXECUTED
400092e8: 84 10 00 10 mov %l0, %g2 <== NOT EXECUTED
400092ec: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
400092f0: 80 a4 a0 00 cmp %l2, 0
400092f4: 22 80 00 2c be,a 400093a4 <_Heap_Allocate_aligned+0x198> <== NEVER TAKEN
400092f8: e2 04 60 08 ld [ %l1 + 8 ], %l1 <== NOT EXECUTED
/* The block is indeed acceptable: calculate the size of the block
to be allocated and perform allocation. */
uint32_t const alloc_size =
block_end - user_addr + HEAP_BLOCK_USER_OFFSET;
400092fc: 82 05 e0 08 add %l7, 8, %g1
40009300: a0 20 40 02 sub %g1, %g2, %l0
Heap_Block *the_block,
uint32_t alloc_size)
{
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const block_size = _Heap_Block_size(the_block);
uint32_t const the_rest = block_size - alloc_size;
40009304: 84 24 c0 10 sub %l3, %l0, %g2
_HAssert(_Heap_Is_aligned(block_size, the_heap->page_size));
_HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size));
_HAssert(alloc_size <= block_size);
_HAssert(_Heap_Is_prev_used(the_block));
if(the_rest >= the_heap->min_block_size) {
40009308: 80 a0 80 16 cmp %g2, %l6
4000930c: 2a 80 00 08 bcs,a 4000932c <_Heap_Allocate_aligned+0x120>
40009310: c6 04 60 08 ld [ %l1 + 8 ], %g3
/* Split the block so that lower part is still free, and upper part
becomes used. */
the_block->size = the_rest | HEAP_PREV_USED;
40009314: 82 10 a0 01 or %g2, 1, %g1
40009318: c2 24 60 04 st %g1, [ %l1 + 4 ]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
void *base,
uint32_t offset
)
{
return (void *)((char *)base + offset);
4000931c: a2 04 40 02 add %l1, %g2, %l1
the_block = _Heap_Block_at(the_block, the_rest);
the_block->prev_size = the_rest;
40009320: c4 24 40 00 st %g2, [ %l1 ]
the_block->size = alloc_size;
40009324: 10 80 00 09 b 40009348 <_Heap_Allocate_aligned+0x13c>
40009328: e0 24 60 04 st %l0, [ %l1 + 4 ]
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
4000932c: c4 04 60 0c ld [ %l1 + 0xc ], %g2
/* Don't split the block as remainder is either zero or too small to be
used as a separate free block. Change 'alloc_size' to the size of the
block and remove the block from the list of free blocks. */
_Heap_Block_remove(the_block);
alloc_size = block_size;
stats->free_blocks -= 1;
40009330: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
prev->next = next;
next->prev = prev;
40009334: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
40009338: 82 00 7f ff add %g1, -1, %g1
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
4000933c: c6 20 a0 08 st %g3, [ %g2 + 8 ]
40009340: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
40009344: a0 10 00 13 mov %l3, %l0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
40009348: 84 04 40 10 add %l1, %l0, %g2
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
4000934c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40009350: 82 10 60 01 or %g1, 1, %g1
40009354: c2 20 a0 04 st %g1, [ %g2 + 4 ]
/* Update statistics */
stats->free_size -= alloc_size;
40009358: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
if(stats->min_free_size > stats->free_size)
4000935c: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
stats->free_blocks -= 1;
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
/* Update statistics */
stats->free_size -= alloc_size;
40009360: 82 20 40 10 sub %g1, %l0, %g1
if(stats->min_free_size > stats->free_size)
40009364: 80 a0 80 01 cmp %g2, %g1
40009368: 08 80 00 03 bleu 40009374 <_Heap_Allocate_aligned+0x168>
4000936c: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
stats->min_free_size = stats->free_size;
40009370: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
stats->used_blocks += 1;
40009374: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
40009378: c6 06 20 4c ld [ %i0 + 0x4c ], %g3
stats->allocs += 1;
4000937c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
/* Update statistics */
stats->free_size -= alloc_size;
if(stats->min_free_size > stats->free_size)
stats->min_free_size = stats->free_size;
stats->used_blocks += 1;
40009380: 82 00 60 01 inc %g1
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
40009384: 86 00 e0 01 inc %g3
stats->allocs += 1;
40009388: 84 00 a0 01 inc %g2
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
4000938c: 86 00 c0 15 add %g3, %l5, %g3
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
/* Update statistics */
stats->free_size -= alloc_size;
if(stats->min_free_size > stats->free_size)
stats->min_free_size = stats->free_size;
stats->used_blocks += 1;
40009390: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
stats->allocs += 1;
40009394: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
_HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment));
the_block = block_allocate(the_heap, the_block, alloc_size);
stats->searches += search_count + 1;
40009398: c6 26 20 4c st %g3, [ %i0 + 0x4c ]
stats->allocs += 1;
check_result(the_heap, the_block, user_addr,
aligned_user_addr, size);
user_ptr = (void*)aligned_user_addr;
4000939c: 10 80 00 07 b 400093b8 <_Heap_Allocate_aligned+0x1ac>
400093a0: 90 10 00 12 mov %l2, %o0
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
the_block = the_block->next, ++search_count)
400093a4: aa 05 60 01 inc %l5
alignment = CPU_ALIGNMENT;
/* Find large enough free block that satisfies the alignment requirements. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
400093a8: 80 a4 40 18 cmp %l1, %i0
400093ac: 32 bf ff a8 bne,a 4000924c <_Heap_Allocate_aligned+0x40>
400093b0: c2 04 60 04 ld [ %l1 + 4 ], %g1
400093b4: 90 10 20 00 clr %o0
}
}
}
}
if(stats->max_search < search_count)
400093b8: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
400093bc: 80 a0 40 15 cmp %g1, %l5
400093c0: 2a 80 00 02 bcs,a 400093c8 <_Heap_Allocate_aligned+0x1bc>
400093c4: ea 26 20 44 st %l5, [ %i0 + 0x44 ]
stats->max_search = search_count;
return user_ptr;
}
400093c8: 81 c7 e0 08 ret
400093cc: 91 e8 00 08 restore %g0, %o0, %o0
4000e4c8 <_Heap_Extend>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t *amount_extended
)
{
4000e4c8: 9d e3 bf 98 save %sp, -104, %sp
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
4000e4cc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
4000e4d0: 80 a6 40 01 cmp %i1, %g1
4000e4d4: 0a 80 00 06 bcs 4000e4ec <_Heap_Extend+0x24>
4000e4d8: a2 10 00 18 mov %i0, %l1
4000e4dc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000e4e0: 80 a6 40 01 cmp %i1, %g1
4000e4e4: 0a 80 00 28 bcs 4000e584 <_Heap_Extend+0xbc>
4000e4e8: b0 10 20 01 mov 1, %i0
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
4000e4ec: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
4000e4f0: 80 a6 40 01 cmp %i1, %g1
4000e4f4: 12 80 00 24 bne 4000e584 <_Heap_Extend+0xbc>
4000e4f8: b0 10 20 02 mov 2, %i0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
4000e4fc: d2 04 60 10 ld [ %l1 + 0x10 ], %o1
* Currently only case 4 should make it to this point.
* The basic trick is to make the extend area look like a used
* block and free it.
*/
old_final = the_heap->final;
4000e500: e4 04 60 24 ld [ %l1 + 0x24 ], %l2
4000e504: 82 06 40 1a add %i1, %i2, %g1
the_heap->end = _Addresses_Add_offset( the_heap->end, size );
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
4000e508: a0 20 40 12 sub %g1, %l2, %l0
* The basic trick is to make the extend area look like a used
* block and free it.
*/
old_final = the_heap->final;
the_heap->end = _Addresses_Add_offset( the_heap->end, size );
4000e50c: c2 24 60 1c st %g1, [ %l1 + 0x1c ]
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
4000e510: a0 04 3f f8 add %l0, -8, %l0
4000e514: 40 00 27 e2 call 4001849c <.urem>
4000e518: 90 10 00 10 mov %l0, %o0
_Heap_Align_down( &the_size, the_heap->page_size );
*amount_extended = size;
4000e51c: f4 26 c0 00 st %i2, [ %i3 ]
if( the_size < the_heap->min_block_size )
4000e520: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
4000e524: a0 24 00 08 sub %l0, %o0, %l0
4000e528: 80 a4 00 01 cmp %l0, %g1
4000e52c: 0a 80 00 16 bcs 4000e584 <_Heap_Extend+0xbc> <== NEVER TAKEN
4000e530: b0 10 20 00 clr %i0
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
4000e534: c2 04 a0 04 ld [ %l2 + 4 ], %g1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
4000e538: 88 04 80 10 add %l2, %l0, %g4
4000e53c: 82 08 60 01 and %g1, 1, %g1
4000e540: 82 14 00 01 or %l0, %g1, %g1
4000e544: c2 24 a0 04 st %g1, [ %l2 + 4 ]
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
4000e548: 82 10 20 01 mov 1, %g1
4000e54c: c2 21 20 04 st %g1, [ %g4 + 4 ]
the_heap->final = new_final;
stats->size += size;
4000e550: c2 04 60 2c ld [ %l1 + 0x2c ], %g1
stats->used_blocks += 1;
4000e554: c4 04 60 40 ld [ %l1 + 0x40 ], %g2
stats->frees -= 1; /* Don't count subsequent call as actual free() */
4000e558: c6 04 60 50 ld [ %l1 + 0x50 ], %g3
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
the_heap->final = new_final;
stats->size += size;
4000e55c: 82 00 40 1a add %g1, %i2, %g1
stats->used_blocks += 1;
4000e560: 84 00 a0 01 inc %g2
stats->frees -= 1; /* Don't count subsequent call as actual free() */
4000e564: 86 00 ff ff add %g3, -1, %g3
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
the_heap->final = new_final;
4000e568: c8 24 60 24 st %g4, [ %l1 + 0x24 ]
stats->size += size;
4000e56c: c2 24 60 2c st %g1, [ %l1 + 0x2c ]
stats->used_blocks += 1;
4000e570: c4 24 60 40 st %g2, [ %l1 + 0x40 ]
stats->frees -= 1; /* Don't count subsequent call as actual free() */
4000e574: c6 24 60 50 st %g3, [ %l1 + 0x50 ]
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
4000e578: 90 10 00 11 mov %l1, %o0
4000e57c: 7f ff eb bc call 4000946c <_Heap_Free>
4000e580: 92 04 a0 08 add %l2, 8, %o1
return HEAP_EXTEND_SUCCESSFUL;
}
4000e584: 81 c7 e0 08 ret
4000e588: 81 e8 00 00 restore
4000afb0 <_Heap_Free>:
bool _Heap_Free(
Heap_Control *the_heap,
void *starting_address
)
{
4000afb0: 9d e3 bf 98 save %sp, -104, %sp
uint32_t the_size;
uint32_t next_size;
Heap_Statistics *const stats = &the_heap->stats;
bool next_is_free;
if ( !_Addresses_Is_in_range(
4000afb4: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
4000afb8: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
4000afbc: 80 a6 40 12 cmp %i1, %l2
4000afc0: 84 60 3f ff subx %g0, -1, %g2
4000afc4: 80 a4 40 19 cmp %l1, %i1
4000afc8: 82 60 3f ff subx %g0, -1, %g1
4000afcc: 80 88 80 01 btst %g2, %g1
4000afd0: 02 80 00 73 be 4000b19c <_Heap_Free+0x1ec>
4000afd4: 01 00 00 00 nop
/* The address passed could be greater than the block address plus
* HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
* pointers. To get rid of this offset we need to align the address down
* to the nearest 'page_size' boundary. */
_Heap_Align_down_uptr ( &addr, the_heap->page_size );
*the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
4000afd8: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
4000afdc: 40 00 20 d8 call 4001333c <.urem>
4000afe0: 90 10 00 19 mov %i1, %o0
4000afe4: a0 06 7f f8 add %i1, -8, %l0
4000afe8: 90 24 00 08 sub %l0, %o0, %o0
return( FALSE );
}
_Heap_Start_of_block( the_heap, starting_address, &the_block );
if ( !_Heap_Is_block_in( the_heap, the_block ) ) {
4000afec: 80 a2 00 12 cmp %o0, %l2
4000aff0: 84 60 3f ff subx %g0, -1, %g2
4000aff4: 80 a4 40 08 cmp %l1, %o0
4000aff8: 82 60 3f ff subx %g0, -1, %g1
4000affc: 80 88 80 01 btst %g2, %g1
4000b000: 02 80 00 67 be 4000b19c <_Heap_Free+0x1ec> <== NEVER TAKEN
4000b004: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
4000b008: c6 02 20 04 ld [ %o0 + 4 ], %g3
4000b00c: 96 08 ff fe and %g3, -2, %o3
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
4000b010: 88 02 00 0b add %o0, %o3, %g4
}
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
4000b014: 80 a1 00 12 cmp %g4, %l2
4000b018: 84 60 3f ff subx %g0, -1, %g2
4000b01c: 80 a4 40 04 cmp %l1, %g4
4000b020: 82 60 3f ff subx %g0, -1, %g1
4000b024: 80 88 80 01 btst %g2, %g1
4000b028: 02 80 00 5d be 4000b19c <_Heap_Free+0x1ec> <== NEVER TAKEN
4000b02c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
4000b030: c2 01 20 04 ld [ %g4 + 4 ], %g1
_HAssert( FALSE );
return( FALSE );
}
if ( !_Heap_Is_prev_used( next_block ) ) {
4000b034: 80 88 60 01 btst 1, %g1
4000b038: 02 80 00 59 be 4000b19c <_Heap_Free+0x1ec> <== NEVER TAKEN
4000b03c: 94 08 7f fe and %g1, -2, %o2
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
4000b040: 80 a1 00 11 cmp %g4, %l1
4000b044: 1a 80 00 06 bcc 4000b05c <_Heap_Free+0xac>
4000b048: 82 10 20 00 clr %g1
4000b04c: 82 01 00 0a add %g4, %o2, %g1
4000b050: c2 00 60 04 ld [ %g1 + 4 ], %g1
4000b054: 82 08 60 01 and %g1, 1, %g1
4000b058: 82 18 60 01 xor %g1, 1, %g1
!_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));
if ( !_Heap_Is_prev_used( the_block ) ) {
4000b05c: 80 88 e0 01 btst 1, %g3
4000b060: 12 80 00 25 bne 4000b0f4 <_Heap_Free+0x144>
4000b064: 86 10 00 01 mov %g1, %g3
uint32_t const prev_size = the_block->prev_size;
4000b068: d8 02 00 00 ld [ %o0 ], %o4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
4000b06c: 9a 22 00 0c sub %o0, %o4, %o5
Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );
if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
4000b070: 80 a3 40 12 cmp %o5, %l2
4000b074: 84 60 3f ff subx %g0, -1, %g2
4000b078: 80 a4 40 0d cmp %l1, %o5
4000b07c: 82 60 3f ff subx %g0, -1, %g1
4000b080: 80 88 80 01 btst %g2, %g1
4000b084: 02 80 00 46 be 4000b19c <_Heap_Free+0x1ec> <== NEVER TAKEN
4000b088: 01 00 00 00 nop
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) ) {
4000b08c: c2 03 60 04 ld [ %o5 + 4 ], %g1
4000b090: 80 88 60 01 btst 1, %g1
4000b094: 02 80 00 42 be 4000b19c <_Heap_Free+0x1ec> <== NEVER TAKEN
4000b098: 80 a0 e0 00 cmp %g3, 0
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
4000b09c: 02 80 00 0f be 4000b0d8 <_Heap_Free+0x128>
4000b0a0: 84 02 c0 0c add %o3, %o4, %g2
uint32_t const size = the_size + prev_size + next_size;
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
4000b0a4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
4000b0a8: c6 01 20 0c ld [ %g4 + 0xc ], %g3
Heap_Block *the_block
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
4000b0ac: c4 01 20 08 ld [ %g4 + 8 ], %g2
4000b0b0: 82 00 7f ff add %g1, -1, %g1
4000b0b4: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
Heap_Block *prev = block->prev;
prev->next = next;
next->prev = prev;
4000b0b8: c6 20 a0 0c st %g3, [ %g2 + 0xc ]
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
uint32_t const size = the_size + prev_size + next_size;
4000b0bc: 82 02 c0 0a add %o3, %o2, %g1
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
4000b0c0: c4 20 e0 08 st %g2, [ %g3 + 8 ]
4000b0c4: 82 00 40 0c add %g1, %o4, %g1
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
prev_block->size = size | HEAP_PREV_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
4000b0c8: c2 23 40 01 st %g1, [ %o5 + %g1 ]
if ( next_is_free ) { /* coalesce both */
uint32_t const size = the_size + prev_size + next_size;
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
prev_block->size = size | HEAP_PREV_USED;
4000b0cc: 82 10 60 01 or %g1, 1, %g1
4000b0d0: 10 80 00 28 b 4000b170 <_Heap_Free+0x1c0>
4000b0d4: c2 23 60 04 st %g1, [ %o5 + 4 ]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
}
else { /* coalesce prev */
uint32_t const size = the_size + prev_size;
prev_block->size = size | HEAP_PREV_USED;
4000b0d8: 82 10 a0 01 or %g2, 1, %g1
4000b0dc: c2 23 60 04 st %g1, [ %o5 + 4 ]
next_block->size &= ~HEAP_PREV_USED;
4000b0e0: c2 01 20 04 ld [ %g4 + 4 ], %g1
next_block->prev_size = size;
4000b0e4: c4 22 00 0b st %g2, [ %o0 + %o3 ]
next_block->prev_size = size;
}
else { /* coalesce prev */
uint32_t const size = the_size + prev_size;
prev_block->size = size | HEAP_PREV_USED;
next_block->size &= ~HEAP_PREV_USED;
4000b0e8: 82 08 7f fe and %g1, -2, %g1
4000b0ec: 10 80 00 21 b 4000b170 <_Heap_Free+0x1c0>
4000b0f0: c2 21 20 04 st %g1, [ %g4 + 4 ]
next_block->prev_size = size;
}
}
else if ( next_is_free ) { /* coalesce next */
4000b0f4: 80 a0 e0 00 cmp %g3, 0
4000b0f8: 02 80 00 0d be 4000b12c <_Heap_Free+0x17c>
4000b0fc: 82 12 e0 01 or %o3, 1, %g1
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
4000b100: c2 01 20 0c ld [ %g4 + 0xc ], %g1
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
4000b104: c4 01 20 08 ld [ %g4 + 8 ], %g2
Heap_Block *prev = block->prev;
block = new_block;
block->next = next;
block->prev = prev;
4000b108: c2 22 20 0c st %g1, [ %o0 + 0xc ]
Heap_Block *block = old_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
block = new_block;
block->next = next;
4000b10c: c4 22 20 08 st %g2, [ %o0 + 8 ]
block->prev = prev;
next->prev = prev->next = block;
4000b110: d0 20 60 08 st %o0, [ %g1 + 8 ]
4000b114: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
uint32_t const size = the_size + next_size;
4000b118: 82 02 80 0b add %o2, %o3, %g1
_Heap_Block_replace( next_block, the_block );
the_block->size = size | HEAP_PREV_USED;
next_block = _Heap_Block_at( the_block, size );
next_block->prev_size = size;
4000b11c: c2 22 00 01 st %g1, [ %o0 + %g1 ]
}
}
else if ( next_is_free ) { /* coalesce next */
uint32_t const size = the_size + next_size;
_Heap_Block_replace( next_block, the_block );
the_block->size = size | HEAP_PREV_USED;
4000b120: 82 10 60 01 or %g1, 1, %g1
4000b124: 10 80 00 13 b 4000b170 <_Heap_Free+0x1c0>
4000b128: c2 22 20 04 st %g1, [ %o0 + 4 ]
}
else { /* no coalesce */
/* Add 'the_block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Block_insert_after( _Heap_Head( the_heap), the_block );
the_block->size = the_size | HEAP_PREV_USED;
4000b12c: c2 22 20 04 st %g1, [ %o0 + 4 ]
next_block->size &= ~HEAP_PREV_USED;
4000b130: c2 01 20 04 ld [ %g4 + 4 ], %g1
)
{
Heap_Block *prev = prev_block;
Heap_Block *block = the_block;
Heap_Block *next = prev->next;
4000b134: c6 06 20 08 ld [ %i0 + 8 ], %g3
4000b138: 82 08 7f fe and %g1, -2, %g1
next_block->prev_size = the_size;
4000b13c: d6 22 00 0b st %o3, [ %o0 + %o3 ]
else { /* no coalesce */
/* Add 'the_block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Block_insert_after( _Heap_Head( the_heap), the_block );
the_block->size = the_size | HEAP_PREV_USED;
next_block->size &= ~HEAP_PREV_USED;
4000b140: c2 21 20 04 st %g1, [ %g4 + 4 ]
next_block->prev_size = the_size;
stats->free_blocks += 1;
4000b144: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
block->next = next;
4000b148: c6 22 20 08 st %g3, [ %o0 + 8 ]
block->prev = prev;
4000b14c: f0 22 20 0c st %i0, [ %o0 + 0xc ]
if ( stats->max_free_blocks < stats->free_blocks )
4000b150: c4 06 20 3c ld [ %i0 + 0x3c ], %g2
_Heap_Block_insert_after( _Heap_Head( the_heap), the_block );
the_block->size = the_size | HEAP_PREV_USED;
next_block->size &= ~HEAP_PREV_USED;
next_block->prev_size = the_size;
stats->free_blocks += 1;
4000b154: 82 00 60 01 inc %g1
next->prev = prev->next = block;
4000b158: d0 20 e0 0c st %o0, [ %g3 + 0xc ]
4000b15c: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks )
4000b160: 80 a0 80 01 cmp %g2, %g1
4000b164: 1a 80 00 03 bcc 4000b170 <_Heap_Free+0x1c0>
4000b168: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
4000b16c: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
stats->used_blocks -= 1;
4000b170: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
stats->free_size += the_size;
4000b174: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
stats->frees += 1;
4000b178: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
stats->free_size += the_size;
4000b17c: 84 00 80 0b add %g2, %o3, %g2
stats->free_blocks += 1;
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
4000b180: 82 00 7f ff add %g1, -1, %g1
stats->free_size += the_size;
4000b184: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
stats->free_blocks += 1;
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
4000b188: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
stats->free_size += the_size;
stats->frees += 1;
4000b18c: 86 00 e0 01 inc %g3
4000b190: c6 26 20 50 st %g3, [ %i0 + 0x50 ]
4000b194: 81 c7 e0 08 ret
4000b198: 91 e8 20 01 restore %g0, 1, %o0
return( TRUE );
}
4000b19c: 81 c7 e0 08 ret
4000b1a0: 91 e8 20 00 restore %g0, 0, %o0
4000e58c <_Heap_Get_free_information>:
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Tail(the_heap);
info->number = 0;
4000e58c: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
4000e590: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
4000e594: c0 22 60 08 clr [ %o1 + 8 ]
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
4000e598: 10 80 00 0e b 4000e5d0 <_Heap_Get_free_information+0x44>
4000e59c: da 02 20 08 ld [ %o0 + 8 ], %o5
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
4000e5a0: c2 02 40 00 ld [ %o1 ], %g1
info->total += the_size;
4000e5a4: c4 02 60 08 ld [ %o1 + 8 ], %g2
if ( info->largest < the_size )
4000e5a8: c8 02 60 04 ld [ %o1 + 4 ], %g4
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
4000e5ac: 86 08 ff fe and %g3, -2, %g3
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
4000e5b0: 82 00 60 01 inc %g1
info->total += the_size;
4000e5b4: 84 00 80 03 add %g2, %g3, %g2
uint32_t const the_size = _Heap_Block_size(the_block);
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
4000e5b8: c2 22 40 00 st %g1, [ %o1 ]
info->total += the_size;
if ( info->largest < the_size )
4000e5bc: 80 a1 00 03 cmp %g4, %g3
4000e5c0: 1a 80 00 03 bcc 4000e5cc <_Heap_Get_free_information+0x40><== NEVER TAKEN
4000e5c4: c4 22 60 08 st %g2, [ %o1 + 8 ]
info->largest = the_size;
4000e5c8: c6 22 60 04 st %g3, [ %o1 + 4 ]
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
the_block = the_block->next)
4000e5cc: da 03 60 08 ld [ %o5 + 8 ], %o5
info->number = 0;
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
4000e5d0: 80 a3 40 08 cmp %o5, %o0
4000e5d4: 32 bf ff f3 bne,a 4000e5a0 <_Heap_Get_free_information+0x14>
4000e5d8: c6 03 60 04 ld [ %o5 + 4 ], %g3
info->number++;
info->total += the_size;
if ( info->largest < the_size )
info->largest = the_size;
}
}
4000e5dc: 81 c3 e0 08 retl
4000e5e4 <_Heap_Get_information>:
Heap_Block *const end = the_heap->final;
_HAssert(the_block->prev_size == HEAP_PREV_USED);
_HAssert(_Heap_Is_prev_used(the_block));
the_info->Free.number = 0;
4000e5e4: c0 22 40 00 clr [ %o1 ]
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
Heap_Block *the_block = the_heap->start;
Heap_Block *const end = the_heap->final;
4000e5e8: d8 02 20 24 ld [ %o0 + 0x24 ], %o4
_HAssert(the_block->prev_size == HEAP_PREV_USED);
_HAssert(_Heap_Is_prev_used(the_block));
the_info->Free.number = 0;
the_info->Free.total = 0;
4000e5ec: c0 22 60 08 clr [ %o1 + 8 ]
the_info->Free.largest = 0;
4000e5f0: c0 22 60 04 clr [ %o1 + 4 ]
the_info->Used.number = 0;
4000e5f4: c0 22 60 0c clr [ %o1 + 0xc ]
the_info->Used.total = 0;
4000e5f8: c0 22 60 14 clr [ %o1 + 0x14 ]
the_info->Used.largest = 0;
4000e5fc: c0 22 60 10 clr [ %o1 + 0x10 ]
Heap_Get_information_status _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
Heap_Block *the_block = the_heap->start;
4000e600: 10 80 00 23 b 4000e68c <_Heap_Get_information+0xa8>
4000e604: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
4000e608: 88 08 7f fe and %g1, -2, %g4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
4000e60c: 9a 00 80 04 add %g2, %g4, %o5
while ( the_block != end ) {
uint32_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
if ( _Heap_Is_prev_used(next_block) ) {
4000e610: c2 03 60 04 ld [ %o5 + 4 ], %g1
4000e614: 80 88 60 01 btst 1, %g1
4000e618: 22 80 00 0d be,a 4000e64c <_Heap_Get_information+0x68>
4000e61c: c2 02 40 00 ld [ %o1 ], %g1
the_info->Used.number++;
4000e620: c2 02 60 0c ld [ %o1 + 0xc ], %g1
the_info->Used.total += the_size;
4000e624: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
if ( the_info->Used.largest < the_size )
4000e628: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
while ( the_block != end ) {
uint32_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
if ( _Heap_Is_prev_used(next_block) ) {
the_info->Used.number++;
4000e62c: 82 00 60 01 inc %g1
the_info->Used.total += the_size;
4000e630: 84 00 80 04 add %g2, %g4, %g2
while ( the_block != end ) {
uint32_t const the_size = _Heap_Block_size(the_block);
Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);
if ( _Heap_Is_prev_used(next_block) ) {
the_info->Used.number++;
4000e634: c2 22 60 0c st %g1, [ %o1 + 0xc ]
the_info->Used.total += the_size;
if ( the_info->Used.largest < the_size )
4000e638: 80 a0 c0 04 cmp %g3, %g4
4000e63c: 1a 80 00 13 bcc 4000e688 <_Heap_Get_information+0xa4>
4000e640: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
the_info->Used.largest = the_size;
4000e644: 10 80 00 11 b 4000e688 <_Heap_Get_information+0xa4>
4000e648: c8 22 60 10 st %g4, [ %o1 + 0x10 ]
} else {
the_info->Free.number++;
the_info->Free.total += the_size;
4000e64c: c4 02 60 08 ld [ %o1 + 8 ], %g2
if ( the_info->Free.largest < the_size )
4000e650: c6 02 60 04 ld [ %o1 + 4 ], %g3
the_info->Used.number++;
the_info->Used.total += the_size;
if ( the_info->Used.largest < the_size )
the_info->Used.largest = the_size;
} else {
the_info->Free.number++;
4000e654: 82 00 60 01 inc %g1
the_info->Free.total += the_size;
4000e658: 84 00 80 04 add %g2, %g4, %g2
the_info->Used.number++;
the_info->Used.total += the_size;
if ( the_info->Used.largest < the_size )
the_info->Used.largest = the_size;
} else {
the_info->Free.number++;
4000e65c: c2 22 40 00 st %g1, [ %o1 ]
the_info->Free.total += the_size;
if ( the_info->Free.largest < the_size )
4000e660: 80 a0 c0 04 cmp %g3, %g4
4000e664: 1a 80 00 03 bcc 4000e670 <_Heap_Get_information+0x8c> <== NEVER TAKEN
4000e668: c4 22 60 08 st %g2, [ %o1 + 8 ]
the_info->Free.largest = the_size;
4000e66c: c8 22 60 04 st %g4, [ %o1 + 4 ]
if ( the_size != next_block->prev_size )
4000e670: c2 03 40 00 ld [ %o5 ], %g1
4000e674: 80 a1 00 01 cmp %g4, %g1
4000e678: 02 80 00 05 be 4000e68c <_Heap_Get_information+0xa8> <== ALWAYS TAKEN
4000e67c: 84 10 00 0d mov %o5, %g2
4000e680: 81 c3 e0 08 retl <== NOT EXECUTED
4000e684: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4000e688: 84 10 00 0d mov %o5, %g2
the_info->Free.largest = 0;
the_info->Used.number = 0;
the_info->Used.total = 0;
the_info->Used.largest = 0;
while ( the_block != end ) {
4000e68c: 80 a0 80 0c cmp %g2, %o4
4000e690: 32 bf ff de bne,a 4000e608 <_Heap_Get_information+0x24>
4000e694: c2 00 a0 04 ld [ %g2 + 4 ], %g1
}
/* Handle the last dummy block. Don't consider this block to be
"used" as client never allocated it. Make 'Used.total' contain this
blocks' overhead though. */
the_info->Used.total += HEAP_OVERHEAD;
4000e698: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
4000e69c: 90 10 20 00 clr %o0
4000e6a0: 82 00 60 08 add %g1, 8, %g1
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
4000e6a4: 81 c3 e0 08 retl
4000e6a8: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
400063a4 <_Heap_Initialize>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
400063a4: 9d e3 bf 98 save %sp, -104, %sp
_H_uptr_t start;
_H_uptr_t aligned_start;
uint32_t overhead;
Heap_Statistics *const stats = &the_heap->stats;
if (page_size == 0)
400063a8: 80 a6 e0 00 cmp %i3, 0
400063ac: 12 80 00 04 bne 400063bc <_Heap_Initialize+0x18>
400063b0: 84 8e e0 07 andcc %i3, 7, %g2
400063b4: 10 80 00 06 b 400063cc <_Heap_Initialize+0x28>
400063b8: b6 10 20 08 mov 8, %i3
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
*value = r ? v - r + a : v;
400063bc: 02 80 00 05 be 400063d0 <_Heap_Initialize+0x2c>
400063c0: a0 06 60 08 add %i1, 8, %l0
400063c4: 82 06 e0 08 add %i3, 8, %g1
400063c8: b6 20 40 02 sub %g1, %g2, %i3
/* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET
(value of user pointer) is aligned on 'page_size' boundary. Make sure
resulting 'aligned_start' is not below 'starting_address'. */
start = _H_p2u(starting_address);
aligned_start = start + HEAP_BLOCK_USER_OFFSET;
400063cc: a0 06 60 08 add %i1, 8, %l0
uint32_t alignment
)
{
_H_uptr_t v = *value;
uint32_t a = alignment;
_H_uptr_t r = v % a;
400063d0: 92 10 00 1b mov %i3, %o1
400063d4: 40 00 33 da call 4001333c <.urem>
400063d8: 90 10 00 10 mov %l0, %o0
*value = r ? v - r + a : v;
400063dc: 80 a2 20 00 cmp %o0, 0
400063e0: 22 80 00 05 be,a 400063f4 <_Heap_Initialize+0x50>
400063e4: 90 10 20 10 mov 0x10, %o0
400063e8: 82 06 c0 10 add %i3, %l0, %g1
400063ec: a0 20 40 08 sub %g1, %o0, %l0
uint32_t alignment
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
400063f0: 90 10 20 10 mov 0x10, %o0
400063f4: 40 00 33 d2 call 4001333c <.urem>
400063f8: 92 10 00 1b mov %i3, %o1
*value = r ? v - r + a : v;
400063fc: 82 06 e0 10 add %i3, 0x10, %g1
40006400: 80 a2 20 00 cmp %o0, 0
_Heap_Align_up_uptr ( &aligned_start, page_size );
aligned_start -= HEAP_BLOCK_USER_OFFSET;
40006404: a2 04 3f f8 add %l0, -8, %l1
40006408: 12 80 00 03 bne 40006414 <_Heap_Initialize+0x70>
4000640c: 82 20 40 08 sub %g1, %o0, %g1
40006410: 82 10 20 10 mov 0x10, %g1
40006414: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
/* Calculate 'the_size' -- size of the first block so that there is enough
space at the end for the permanent last block. It is equal to 'size'
minus total overhead aligned down to the nearest multiple of
'page_size'. */
overhead = HEAP_OVERHEAD + (aligned_start - start);
40006418: 82 24 40 19 sub %l1, %i1, %g1
4000641c: 82 00 60 08 add %g1, 8, %g1
if ( size < overhead )
40006420: 80 a6 80 01 cmp %i2, %g1
40006424: 0a 80 00 2a bcs 400064cc <_Heap_Initialize+0x128> <== NEVER TAKEN
40006428: a0 26 80 01 sub %i2, %g1, %l0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
4000642c: 92 10 00 1b mov %i3, %o1
40006430: 40 00 33 c3 call 4001333c <.urem>
40006434: 90 10 00 10 mov %l0, %o0
return 0; /* Too small area for the heap */
the_size = size - overhead;
_Heap_Align_down ( &the_size, page_size );
if ( the_size == 0 )
40006438: a0 a4 00 08 subcc %l0, %o0, %l0
4000643c: 02 80 00 24 be 400064cc <_Heap_Initialize+0x128>
40006440: 07 10 00 5f sethi %hi(0x40017c00), %g3
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
40006444: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
the_heap->begin = starting_address;
the_heap->end = starting_address + size;
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
40006448: f6 24 40 00 st %i3, [ %l1 ]
the_block->size = the_size | HEAP_PREV_USED;
4000644c: 82 14 20 01 or %l0, 1, %g1
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
40006450: c4 00 e0 80 ld [ %g3 + 0x80 ], %g2
the_heap->end = starting_address + size;
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
the_block->size = the_size | HEAP_PREV_USED;
40006454: c2 24 60 04 st %g1, [ %l1 + 4 ]
_HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size));
_HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size));
the_block = _Heap_Block_at( the_block, the_size );
the_heap->final = the_block; /* Permanent final block of the heap */
the_block->prev_size = the_size; /* Previous block is free */
40006458: e0 24 40 10 st %l0, [ %l1 + %l0 ]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
void *base,
uint32_t offset
)
{
return (void *)((char *)base + offset);
4000645c: 88 04 40 10 add %l1, %l0, %g4
the_block->size = page_size;
40006460: f6 21 20 04 st %i3, [ %g4 + 4 ]
the_block = (Heap_Block *) aligned_start;
the_block->prev_size = page_size;
the_block->size = the_size | HEAP_PREV_USED;
the_block->next = _Heap_Tail( the_heap );
40006464: f0 24 60 08 st %i0, [ %l1 + 8 ]
the_block->prev = _Heap_Head( the_heap );
40006468: f0 24 60 0c st %i0, [ %l1 + 0xc ]
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
4000646c: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
the_block->size = page_size;
stats->size = size;
stats->free_size = the_size;
stats->min_free_size = the_size;
stats->free_blocks = 1;
40006470: 82 10 20 01 mov 1, %g1
the_block = _Heap_Block_at( the_block, the_size );
the_heap->final = the_block; /* Permanent final block of the heap */
the_block->prev_size = the_size; /* Previous block is free */
the_block->size = page_size;
stats->size = size;
40006474: f4 26 20 2c st %i2, [ %i0 + 0x2c ]
stats->free_size = the_size;
stats->min_free_size = the_size;
stats->free_blocks = 1;
stats->max_free_blocks = 1;
40006478: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
the_block->size = page_size;
stats->size = size;
stats->free_size = the_size;
stats->min_free_size = the_size;
stats->free_blocks = 1;
4000647c: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
the_heap->final = the_block; /* Permanent final block of the heap */
the_block->prev_size = the_size; /* Previous block is free */
the_block->size = page_size;
stats->size = size;
stats->free_size = the_size;
40006480: e0 26 20 30 st %l0, [ %i0 + 0x30 ]
stats->min_free_size = the_size;
40006484: e0 26 20 34 st %l0, [ %i0 + 0x34 ]
stats->free_blocks = 1;
stats->max_free_blocks = 1;
stats->used_blocks = 0;
40006488: c0 26 20 40 clr [ %i0 + 0x40 ]
stats->max_search = 0;
4000648c: c0 26 20 44 clr [ %i0 + 0x44 ]
stats->allocs = 0;
40006490: c0 26 20 48 clr [ %i0 + 0x48 ]
stats->searches = 0;
40006494: c0 26 20 4c clr [ %i0 + 0x4c ]
stats->frees = 0;
40006498: c0 26 20 50 clr [ %i0 + 0x50 ]
stats->resizes = 0;
4000649c: c0 26 20 54 clr [ %i0 + 0x54 ]
if ( the_size == 0 )
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
the_heap->begin = starting_address;
the_heap->end = starting_address + size;
400064a0: 82 06 40 1a add %i1, %i2, %g1
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
400064a4: 84 00 a0 01 inc %g2
if ( the_size == 0 )
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
the_heap->begin = starting_address;
the_heap->end = starting_address + size;
400064a8: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
_Heap_Align_down ( &the_size, page_size );
if ( the_size == 0 )
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
the_heap->begin = starting_address;
400064ac: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
the_block->prev_size = page_size;
the_block->size = the_size | HEAP_PREV_USED;
the_block->next = _Heap_Tail( the_heap );
the_block->prev = _Heap_Head( the_heap );
_Heap_Head(the_heap)->next = the_block;
400064b0: e2 26 20 08 st %l1, [ %i0 + 8 ]
_Heap_Tail(the_heap)->prev = the_block;
400064b4: e2 26 20 0c st %l1, [ %i0 + 0xc ]
the_heap->start = the_block;
400064b8: e2 26 20 20 st %l1, [ %i0 + 0x20 ]
_HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT));
_HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size));
_HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size));
the_block = _Heap_Block_at( the_block, the_size );
the_heap->final = the_block; /* Permanent final block of the heap */
400064bc: c8 26 20 24 st %g4, [ %i0 + 0x24 ]
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
400064c0: c4 20 e0 80 st %g2, [ %g3 + 0x80 ]
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
400064c4: 81 c7 e0 08 ret
400064c8: 91 ec 3f fc restore %l0, -4, %o0
}
400064cc: 81 c7 e0 08 ret
400064d0: 91 e8 20 00 restore %g0, 0, %o0
400159d8 <_Heap_Resize_block>:
void *starting_address,
size_t size,
uint32_t *old_mem_size,
uint32_t *avail_mem_size
)
{
400159d8: 9d e3 bf 98 save %sp, -104, %sp
Heap_Block *next_next_block;
uint32_t old_block_size;
uint32_t old_user_size;
uint32_t prev_used_flag;
Heap_Statistics *const stats = &the_heap->stats;
uint32_t const min_block_size = the_heap->min_block_size;
400159dc: e8 06 20 14 ld [ %i0 + 0x14 ], %l4
uint32_t const page_size = the_heap->page_size;
400159e0: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
*old_mem_size = 0;
400159e4: c0 26 c0 00 clr [ %i3 ]
*avail_mem_size = 0;
400159e8: c0 27 00 00 clr [ %i4 ]
/* The address passed could be greater than the block address plus
* HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
* pointers. To get rid of this offset we need to align the address down
* to the nearest 'page_size' boundary. */
_Heap_Align_down_uptr ( &addr, the_heap->page_size );
*the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
400159ec: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
400159f0: 7f ff f6 53 call 4001333c <.urem>
400159f4: 90 10 00 19 mov %i1, %o0
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in (
Heap_Control *the_heap,
Heap_Block *the_block
)
{
return _Addresses_Is_in_range( the_block, the_heap->start, the_heap->final );
400159f8: c8 06 20 20 ld [ %i0 + 0x20 ], %g4
400159fc: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
/* The address passed could be greater than the block address plus
* HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
* pointers. To get rid of this offset we need to align the address down
* to the nearest 'page_size' boundary. */
_Heap_Align_down_uptr ( &addr, the_heap->page_size );
*the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
40015a00: 82 06 7f f8 add %i1, -8, %g1
40015a04: a4 20 40 08 sub %g1, %o0, %l2
_Heap_Start_of_block(the_heap, starting_address, &the_block);
_HAssert(_Heap_Is_block_in(the_heap, the_block));
if (!_Heap_Is_block_in(the_heap, the_block))
40015a08: 80 a4 80 04 cmp %l2, %g4
40015a0c: 84 60 3f ff subx %g0, -1, %g2
40015a10: 80 a0 c0 12 cmp %g3, %l2
40015a14: 82 60 3f ff subx %g0, -1, %g1
40015a18: 80 88 80 01 btst %g2, %g1
40015a1c: 02 80 00 75 be 40015bf0 <_Heap_Resize_block+0x218>
40015a20: a6 10 00 18 mov %i0, %l3
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
40015a24: da 04 a0 04 ld [ %l2 + 4 ], %o5
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
40015a28: aa 0b 7f fe and %o5, -2, %l5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
40015a2c: a2 04 80 15 add %l2, %l5, %l1
old_block_size = _Heap_Block_size(the_block);
next_block = _Heap_Block_at(the_block, old_block_size);
_HAssert(_Heap_Is_block_in(the_heap, next_block));
_HAssert(_Heap_Is_prev_used(next_block));
if ( !_Heap_Is_block_in(the_heap, next_block) ||
40015a30: 80 a4 40 04 cmp %l1, %g4
40015a34: 84 60 3f ff subx %g0, -1, %g2
40015a38: 80 a0 c0 11 cmp %g3, %l1
40015a3c: 82 60 3f ff subx %g0, -1, %g1
40015a40: 80 88 80 01 btst %g2, %g1
40015a44: 02 80 00 6b be 40015bf0 <_Heap_Resize_block+0x218> <== NEVER TAKEN
40015a48: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
40015a4c: c2 04 60 04 ld [ %l1 + 4 ], %g1
40015a50: 80 88 60 01 btst 1, %g1
40015a54: 02 80 00 67 be 40015bf0 <_Heap_Resize_block+0x218> <== NEVER TAKEN
40015a58: 80 a4 40 03 cmp %l1, %g3
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
40015a5c: b0 08 7f fe and %g1, -2, %i0
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
40015a60: 84 10 20 01 mov 1, %g2
40015a64: 02 80 00 04 be 40015a74 <_Heap_Resize_block+0x9c> <== NEVER TAKEN
40015a68: 82 04 40 18 add %l1, %i0, %g1
40015a6c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40015a70: 84 08 60 01 and %g1, 1, %g2
_Heap_Is_prev_used(next_next_block);
/* See _Heap_Size_of_user_area() source for explanations */
old_user_size = _Addresses_Subtract(next_block, starting_address)
40015a74: 82 24 40 19 sub %l1, %i1, %g1
40015a78: 82 00 60 04 add %g1, 4, %g1
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
40015a7c: c2 26 c0 00 st %g1, [ %i3 ]
!_Heap_Is_prev_used(next_block))
return HEAP_RESIZE_FATAL_ERROR;
next_block_size = _Heap_Block_size(next_block);
next_next_block = _Heap_Block_at(next_block, next_block_size);
next_is_used = (next_block == the_heap->final) ||
40015a80: b2 10 00 02 mov %g2, %i1
old_user_size = _Addresses_Subtract(next_block, starting_address)
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
if (size > old_user_size) {
40015a84: 80 a6 80 01 cmp %i2, %g1
40015a88: 08 80 00 1e bleu 40015b00 <_Heap_Resize_block+0x128>
40015a8c: b6 0b 60 01 and %o5, 1, %i3
/* Need to extend the block: allocate part of the next block and then
merge 'the_block' and allocated block together. */
if (next_is_used) /* Next block is in use, -- no way to extend */
40015a90: 80 a6 60 00 cmp %i1, 0
40015a94: 12 80 00 59 bne 40015bf8 <_Heap_Resize_block+0x220>
40015a98: a0 26 80 01 sub %i2, %g1, %l0
uint32_t alignment
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
40015a9c: 92 10 00 16 mov %l6, %o1
40015aa0: 7f ff f6 27 call 4001333c <.urem>
40015aa4: 90 10 00 10 mov %l0, %o0
*value = r ? v - r + a : v;
40015aa8: 80 a2 20 00 cmp %o0, 0
40015aac: 02 80 00 05 be 40015ac0 <_Heap_Resize_block+0xe8> <== NEVER TAKEN
40015ab0: 80 a4 00 14 cmp %l0, %l4
40015ab4: 82 04 00 16 add %l0, %l6, %g1
40015ab8: a0 20 40 08 sub %g1, %o0, %l0
40015abc: 80 a4 00 14 cmp %l0, %l4
40015ac0: 1a 80 00 03 bcc 40015acc <_Heap_Resize_block+0xf4> <== NEVER TAKEN
40015ac4: 90 10 00 10 mov %l0, %o0
40015ac8: 90 10 00 14 mov %l4, %o0
else {
uint32_t add_block_size = size - old_user_size;
_Heap_Align_up(&add_block_size, page_size);
if (add_block_size < min_block_size)
add_block_size = min_block_size;
if (add_block_size > next_block_size)
40015acc: 80 a2 00 18 cmp %o0, %i0
40015ad0: 18 80 00 4a bgu 40015bf8 <_Heap_Resize_block+0x220> <== NEVER TAKEN
40015ad4: 94 10 00 08 mov %o0, %o2
return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
add_block_size =
40015ad8: 92 10 00 11 mov %l1, %o1
40015adc: 7f ff c2 92 call 40006524 <_Heap_Block_allocate>
40015ae0: 90 10 00 13 mov %l3, %o0
_Heap_Block_allocate(the_heap, next_block, add_block_size);
/* Merge two subsequent blocks */
the_block->size = (old_block_size + add_block_size) | prev_used_flag;
40015ae4: 90 02 00 15 add %o0, %l5, %o0
40015ae8: 90 12 00 1b or %o0, %i3, %o0
40015aec: d0 24 a0 04 st %o0, [ %l2 + 4 ]
--stats->used_blocks;
40015af0: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1
40015af4: 82 00 7f ff add %g1, -1, %g1
40015af8: 10 80 00 39 b 40015bdc <_Heap_Resize_block+0x204>
40015afc: c2 24 e0 40 st %g1, [ %l3 + 0x40 ]
}
} else {
/* Calculate how much memory we could free */
uint32_t free_block_size = old_user_size - size;
40015b00: a0 20 40 1a sub %g1, %i2, %l0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
40015b04: 92 10 00 16 mov %l6, %o1
40015b08: 7f ff f6 0d call 4001333c <.urem>
40015b0c: 90 10 00 10 mov %l0, %o0
_Heap_Align_down(&free_block_size, page_size);
if (free_block_size > 0) {
40015b10: a0 a4 00 08 subcc %l0, %o0, %l0
40015b14: 22 80 00 33 be,a 40015be0 <_Heap_Resize_block+0x208>
40015b18: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1
/* To free some memory the block should be shortened so that it can
can hold 'size' user bytes and still remain not shorter than
'min_block_size'. */
uint32_t new_block_size = old_block_size - free_block_size;
40015b1c: 84 25 40 10 sub %l5, %l0, %g2
if (new_block_size < min_block_size) {
40015b20: 80 a0 80 14 cmp %g2, %l4
40015b24: 1a 80 00 07 bcc 40015b40 <_Heap_Resize_block+0x168>
40015b28: 80 a6 60 00 cmp %i1, 0
uint32_t delta = min_block_size - new_block_size;
40015b2c: 82 25 00 02 sub %l4, %g2, %g1
_HAssert(free_block_size >= delta);
free_block_size -= delta;
if (free_block_size == 0) {
40015b30: a0 a4 00 01 subcc %l0, %g1, %l0
40015b34: 02 80 00 2a be 40015bdc <_Heap_Resize_block+0x204> <== ALWAYS TAKEN
40015b38: 84 00 80 01 add %g2, %g1, %g2
_HAssert(new_block_size >= min_block_size);
_HAssert(new_block_size + free_block_size == old_block_size);
_HAssert(_Heap_Is_aligned(new_block_size, page_size));
_HAssert(_Heap_Is_aligned(free_block_size, page_size));
if (!next_is_used) {
40015b3c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40015b40: 12 80 00 15 bne 40015b94 <_Heap_Resize_block+0x1bc> <== NEVER TAKEN
40015b44: 80 a4 00 14 cmp %l0, %l4
Heap_Block *const new_next_block =
_Heap_Block_at(the_block, new_block_size);
uint32_t const new_next_block_size =
next_block_size + free_block_size;
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
40015b48: 82 10 80 1b or %g2, %i3, %g1
if (!next_is_used) {
/* Extend the next block to the low addresses by 'free_block_size' */
Heap_Block *const new_next_block =
_Heap_Block_at(the_block, new_block_size);
uint32_t const new_next_block_size =
next_block_size + free_block_size;
40015b4c: 86 04 00 18 add %l0, %i0, %g3
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
40015b50: c2 24 a0 04 st %g1, [ %l2 + 4 ]
new_next_block->size = new_next_block_size | HEAP_PREV_USED;
40015b54: 82 10 e0 01 or %g3, 1, %g1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
40015b58: 84 04 80 02 add %l2, %g2, %g2
next_next_block->prev_size = new_next_block_size;
40015b5c: c6 24 40 18 st %g3, [ %l1 + %i0 ]
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
40015b60: da 04 60 0c ld [ %l1 + 0xc ], %o5
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
40015b64: c8 04 60 08 ld [ %l1 + 8 ], %g4
_Heap_Block_at(the_block, new_block_size);
uint32_t const new_next_block_size =
next_block_size + free_block_size;
_HAssert(_Heap_Is_block_in(the_heap, next_next_block));
the_block->size = new_block_size | prev_used_flag;
new_next_block->size = new_next_block_size | HEAP_PREV_USED;
40015b68: c2 20 a0 04 st %g1, [ %g2 + 4 ]
next_next_block->prev_size = new_next_block_size;
_Heap_Block_replace(next_block, new_next_block);
the_heap->stats.free_size += free_block_size;
40015b6c: c2 04 e0 30 ld [ %l3 + 0x30 ], %g1
Heap_Block *prev = block->prev;
block = new_block;
block->next = next;
40015b70: c8 20 a0 08 st %g4, [ %g2 + 8 ]
40015b74: 82 00 40 10 add %g1, %l0, %g1
block->prev = prev;
40015b78: da 20 a0 0c st %o5, [ %g2 + 0xc ]
40015b7c: c2 24 e0 30 st %g1, [ %l3 + 0x30 ]
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
40015b80: 86 00 ff fc add %g3, -4, %g3
next->prev = prev->next = block;
40015b84: c4 21 20 0c st %g2, [ %g4 + 0xc ]
40015b88: c4 23 60 08 st %g2, [ %o5 + 8 ]
40015b8c: 10 80 00 14 b 40015bdc <_Heap_Resize_block+0x204>
40015b90: c6 27 00 00 st %g3, [ %i4 ]
} else if (free_block_size >= min_block_size) {
40015b94: 2a 80 00 13 bcs,a 40015be0 <_Heap_Resize_block+0x208> <== NOT EXECUTED
40015b98: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1 <== NOT EXECUTED
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
40015b9c: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED
40015ba0: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
40015ba4: 82 14 20 01 or %l0, 1, %g1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
40015ba8: 92 04 80 02 add %l2, %g2, %o1 <== NOT EXECUTED
40015bac: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED
++stats->used_blocks; /* We have created used block */
40015bb0: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1 <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
40015bb4: c4 04 e0 50 ld [ %l3 + 0x50 ], %g2 <== NOT EXECUTED
} else if (free_block_size >= min_block_size) {
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
++stats->used_blocks; /* We have created used block */
40015bb8: 82 00 60 01 inc %g1 <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
40015bbc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
} else if (free_block_size >= min_block_size) {
/* Split the block into 2 used parts, then free the second one. */
the_block->size = new_block_size | prev_used_flag;
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
++stats->used_blocks; /* We have created used block */
40015bc0: c2 24 e0 40 st %g1, [ %l3 + 0x40 ] <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
40015bc4: c4 24 e0 50 st %g2, [ %l3 + 0x50 ] <== NOT EXECUTED
_Heap_Free(the_heap, _Heap_User_area(next_block));
40015bc8: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED
40015bcc: 7f ff d4 f9 call 4000afb0 <_Heap_Free> <== NOT EXECUTED
40015bd0: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
40015bd4: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED
40015bd8: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED
}
}
}
++stats->resizes;
40015bdc: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1
40015be0: 82 00 60 01 inc %g1
40015be4: c2 24 e0 54 st %g1, [ %l3 + 0x54 ]
40015be8: 81 c7 e0 08 ret
40015bec: 91 e8 20 00 restore %g0, 0, %o0
return HEAP_RESIZE_SUCCESSFUL;
40015bf0: 81 c7 e0 08 ret
40015bf4: 91 e8 20 02 restore %g0, 2, %o0
}
40015bf8: 81 c7 e0 08 ret
40015bfc: 91 e8 20 01 restore %g0, 1, %o0
40015c00 <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
Heap_Control *the_heap,
void *starting_address,
size_t *size
)
{
40015c00: 9d e3 bf 98 save %sp, -104, %sp
Heap_Block *the_block;
Heap_Block *next_block;
uint32_t the_size;
if ( !_Addresses_Is_in_range(
40015c04: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
40015c08: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
40015c0c: 80 a6 40 10 cmp %i1, %l0
40015c10: 84 60 3f ff subx %g0, -1, %g2
40015c14: 80 a4 40 19 cmp %l1, %i1
40015c18: 82 60 3f ff subx %g0, -1, %g1
40015c1c: 80 88 80 01 btst %g2, %g1
40015c20: 02 80 00 20 be 40015ca0 <_Heap_Size_of_user_area+0xa0>
40015c24: 01 00 00 00 nop
/* The address passed could be greater than the block address plus
* HEAP_BLOCK_USER_OFFSET as _Heap_Allocate_aligned() may produce such user
* pointers. To get rid of this offset we need to align the address down
* to the nearest 'page_size' boundary. */
_Heap_Align_down_uptr ( &addr, the_heap->page_size );
*the_block = (Heap_Block *)(addr - HEAP_BLOCK_USER_OFFSET);
40015c28: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
40015c2c: 7f ff f5 c4 call 4001333c <.urem>
40015c30: 90 10 00 19 mov %i1, %o0
40015c34: 82 06 7f f8 add %i1, -8, %g1
40015c38: 86 20 40 08 sub %g1, %o0, %g3
return( FALSE );
_Heap_Start_of_block( the_heap, starting_address, &the_block );
_HAssert(_Heap_Is_block_in( the_heap, the_block ));
if ( !_Heap_Is_block_in( the_heap, the_block ) )
40015c3c: 80 a0 c0 10 cmp %g3, %l0
40015c40: 84 60 3f ff subx %g0, -1, %g2
40015c44: 80 a4 40 03 cmp %l1, %g3
40015c48: 82 60 3f ff subx %g0, -1, %g1
40015c4c: 80 88 80 01 btst %g2, %g1
40015c50: 02 80 00 14 be 40015ca0 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
40015c54: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
40015c58: c2 00 e0 04 ld [ %g3 + 4 ], %g1
40015c5c: 82 08 7f fe and %g1, -2, %g1
40015c60: 90 00 c0 01 add %g3, %g1, %o0
the_size = _Heap_Block_size( the_block );
next_block = _Heap_Block_at( the_block, the_size );
_HAssert(_Heap_Is_block_in( the_heap, next_block ));
_HAssert(_Heap_Is_prev_used( next_block ));
if (
40015c64: 80 a2 00 10 cmp %o0, %l0
40015c68: 84 60 3f ff subx %g0, -1, %g2
40015c6c: 80 a4 40 08 cmp %l1, %o0
40015c70: 82 60 3f ff subx %g0, -1, %g1
40015c74: 80 88 80 01 btst %g2, %g1
40015c78: 02 80 00 0a be 40015ca0 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
40015c7c: 01 00 00 00 nop
40015c80: c2 02 20 04 ld [ %o0 + 4 ], %g1
40015c84: 80 88 60 01 btst 1, %g1
40015c88: 02 80 00 06 be 40015ca0 <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
40015c8c: 82 22 00 19 sub %o0, %i1, %g1
and then add correction equal to the offset of the 'size' field of the
'Heap_Block' structure. The correction is due to the fact that
'prev_size' field of the next block is actually used as user accessible
area of 'the_block'. */
*size = _Addresses_Subtract ( next_block, starting_address )
40015c90: 82 00 60 04 add %g1, 4, %g1
40015c94: c2 26 80 00 st %g1, [ %i2 ]
40015c98: 81 c7 e0 08 ret
40015c9c: 91 e8 20 01 restore %g0, 1, %o0
+ HEAP_BLOCK_HEADER_OFFSET;
return( TRUE );
}
40015ca0: 81 c7 e0 08 ret
40015ca4: 91 e8 20 00 restore %g0, 0, %o0
4000e754 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
4000e754: 9d e3 bf 98 save %sp, -104, %sp
4000e758: a6 10 00 18 mov %i0, %l3
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
4000e75c: 80 a6 60 00 cmp %i1, 0
Heap_Control *the_heap,
int source,
bool do_dump
)
{
Heap_Block *the_block = the_heap->start;
4000e760: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
4000e764: 16 80 00 03 bge 4000e770 <_Heap_Walk+0x1c> <== ALWAYS TAKEN
4000e768: ec 06 20 24 ld [ %i0 + 0x24 ], %l6
source = the_heap->stats.instance;
4000e76c: f2 06 20 28 ld [ %i0 + 0x28 ], %i1 <== NOT EXECUTED
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
4000e770: c2 04 20 04 ld [ %l0 + 4 ], %g1
4000e774: 80 88 60 01 btst 1, %g1
4000e778: 12 80 00 07 bne 4000e794 <_Heap_Walk+0x40> <== ALWAYS TAKEN
4000e77c: b0 10 20 00 clr %i0
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
4000e780: 11 10 00 6d sethi %hi(0x4001b400), %o0 <== NOT EXECUTED
4000e784: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e788: 90 12 23 b8 or %o0, 0x3b8, %o0 <== NOT EXECUTED
4000e78c: 7f ff db 93 call 400055d8 <printk> <== NOT EXECUTED
4000e790: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
4000e794: c4 04 00 00 ld [ %l0 ], %g2
4000e798: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1
4000e79c: 80 a0 80 01 cmp %g2, %g1
4000e7a0: 22 80 00 5e be,a 4000e918 <_Heap_Walk+0x1c4> <== ALWAYS TAKEN
4000e7a4: 03 10 00 6e sethi %hi(0x4001b800), %g1
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
4000e7a8: 11 10 00 6d sethi %hi(0x4001b400), %o0 <== NOT EXECUTED
4000e7ac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e7b0: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
4000e7b4: 7f ff db 89 call 400055d8 <printk> <== NOT EXECUTED
4000e7b8: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
4000e7bc: 10 80 00 57 b 4000e918 <_Heap_Walk+0x1c4> <== NOT EXECUTED
4000e7c0: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
4000e7c4: e8 04 20 04 ld [ %l0 + 4 ], %l4
printk(" prev_size %d", the_block->prev_size);
else
printk(" (prev_size) %d", the_block->prev_size);
}
if (!_Heap_Is_block_in(the_heap, next_block)) {
4000e7c8: c6 04 e0 24 ld [ %l3 + 0x24 ], %g3
4000e7cc: a4 0d 3f fe and %l4, -2, %l2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
4000e7d0: a2 04 00 12 add %l0, %l2, %l1
4000e7d4: 80 a4 40 01 cmp %l1, %g1
4000e7d8: 84 60 3f ff subx %g0, -1, %g2
4000e7dc: 80 a0 c0 11 cmp %g3, %l1
4000e7e0: 82 60 3f ff subx %g0, -1, %g1
4000e7e4: 80 88 80 01 btst %g2, %g1
4000e7e8: 32 80 00 09 bne,a 4000e80c <_Heap_Walk+0xb8> <== ALWAYS TAKEN
4000e7ec: c2 04 60 04 ld [ %l1 + 4 ], %g1
if (do_dump) printk("\n");
printk("PASS: %d !block %p is out of heap\n", source, next_block);
4000e7f0: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4000e7f4: 11 10 00 6e sethi %hi(0x4001b800), %o0 <== NOT EXECUTED
4000e7f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e7fc: 7f ff db 77 call 400055d8 <printk> <== NOT EXECUTED
4000e800: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
4000e804: 10 80 00 51 b 4000e948 <_Heap_Walk+0x1f4> <== NOT EXECUTED
4000e808: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
printk("PASS: %d !block %p is out of heap\n", source, next_block);
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
4000e80c: 80 88 60 01 btst 1, %g1
4000e810: 12 80 00 27 bne 4000e8ac <_Heap_Walk+0x158>
4000e814: 80 a6 20 00 cmp %i0, 0
if (do_dump)
printk( " prev %p next %p", the_block->prev, the_block->next);
if (_Heap_Block_size(the_block) != next_block->prev_size) {
4000e818: c2 04 40 00 ld [ %l1 ], %g1
4000e81c: 80 a4 80 01 cmp %l2, %g1
4000e820: 02 80 00 07 be 4000e83c <_Heap_Walk+0xe8> <== ALWAYS TAKEN
4000e824: 80 8d 20 01 btst 1, %l4
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
4000e828: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
4000e82c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e830: 7f ff db 6a call 400055d8 <printk> <== NOT EXECUTED
4000e834: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
error = 1;
}
if (!prev_used) {
4000e838: 80 8d 20 01 btst 1, %l4 <== NOT EXECUTED
4000e83c: 32 80 00 0c bne,a 4000e86c <_Heap_Walk+0x118> <== ALWAYS TAKEN
4000e840: c2 04 e0 08 ld [ %l3 + 8 ], %g1
if (do_dump || error) printk("\n");
4000e844: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000e848: 02 80 00 05 be 4000e85c <_Heap_Walk+0x108> <== NOT EXECUTED
4000e84c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000e850: 7f ff db 62 call 400055d8 <printk> <== NOT EXECUTED
4000e854: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
4000e858: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
4000e85c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e860: 7f ff db 5e call 400055d8 <printk> <== NOT EXECUTED
4000e864: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
4000e868: c2 04 e0 08 ld [ %l3 + 8 ], %g1 <== NOT EXECUTED
error = 1;
}
{ /* Check if 'the_block' is in the free block list */
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
4000e86c: 80 a0 40 10 cmp %g1, %l0
4000e870: 02 80 00 0e be 4000e8a8 <_Heap_Walk+0x154>
4000e874: 80 a0 40 13 cmp %g1, %l3
4000e878: 32 bf ff fd bne,a 4000e86c <_Heap_Walk+0x118> <== ALWAYS TAKEN
4000e87c: c2 00 60 08 ld [ %g1 + 8 ], %g1
block = block->next;
if(block != the_block) {
if (do_dump || error) printk("\n");
4000e880: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000e884: 22 80 00 05 be,a 4000e898 <_Heap_Walk+0x144> <== NOT EXECUTED
4000e888: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e88c: 7f ff db 53 call 400055d8 <printk> <== NOT EXECUTED
4000e890: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
4000e894: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e898: 7f ff db 50 call 400055d8 <printk> <== NOT EXECUTED
4000e89c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
4000e8a0: 10 80 00 06 b 4000e8b8 <_Heap_Walk+0x164> <== NOT EXECUTED
4000e8a4: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
4000e8a8: 80 a6 20 00 cmp %i0, 0
4000e8ac: 22 80 00 06 be,a 4000e8c4 <_Heap_Walk+0x170> <== ALWAYS TAKEN
4000e8b0: c2 04 e0 14 ld [ %l3 + 0x14 ], %g1
4000e8b4: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
4000e8b8: 7f ff db 48 call 400055d8 <printk> <== NOT EXECUTED
4000e8bc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
4000e8c0: c2 04 e0 14 ld [ %l3 + 0x14 ], %g1 <== NOT EXECUTED
4000e8c4: 80 a4 80 01 cmp %l2, %g1
4000e8c8: 3a 80 00 05 bcc,a 4000e8dc <_Heap_Walk+0x188> <== ALWAYS TAKEN
4000e8cc: d2 04 e0 10 ld [ %l3 + 0x10 ], %o1
printk("PASS: %d !block size is too small\n", source);
4000e8d0: 11 10 00 6e sethi %hi(0x4001b800), %o0 <== NOT EXECUTED
4000e8d4: 10 80 00 09 b 4000e8f8 <_Heap_Walk+0x1a4> <== NOT EXECUTED
4000e8d8: 90 12 20 e0 or %o0, 0xe0, %o0 ! 4001b8e0 <status_flags_assoc+0x158><== NOT EXECUTED
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
4000e8dc: 40 00 26 f0 call 4001849c <.urem>
4000e8e0: 90 10 00 12 mov %l2, %o0
4000e8e4: 80 a2 20 00 cmp %o0, 0
4000e8e8: 02 80 00 08 be 4000e908 <_Heap_Walk+0x1b4> <== ALWAYS TAKEN
4000e8ec: 80 a6 20 00 cmp %i0, 0
printk("PASS: %d !block size is misaligned\n", source);
4000e8f0: 11 10 00 6e sethi %hi(0x4001b800), %o0 <== NOT EXECUTED
4000e8f4: 90 12 21 08 or %o0, 0x108, %o0 ! 4001b908 <status_flags_assoc+0x180><== NOT EXECUTED
4000e8f8: 7f ff db 38 call 400055d8 <printk> <== NOT EXECUTED
4000e8fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
4000e900: 10 80 00 12 b 4000e948 <_Heap_Walk+0x1f4> <== NOT EXECUTED
4000e904: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
printk("PASS: %d !block size is misaligned\n", source);
error = 1;
}
if (++passes > (do_dump ? 10 : 0) && error)
4000e908: 12 80 00 10 bne 4000e948 <_Heap_Walk+0x1f4> <== NEVER TAKEN
4000e90c: 96 10 00 16 mov %l6, %o3
break;
4000e910: 10 80 00 09 b 4000e934 <_Heap_Walk+0x1e0>
4000e914: a0 10 00 11 mov %l1, %l0
error = 1;
}
}
}
if (do_dump || error) printk("\n");
4000e918: aa 10 60 20 or %g1, 0x20, %l5
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
block = block->next;
if(block != the_block) {
if (do_dump || error) printk("\n");
printk("PASS: %d !the_block not in the free list", source);
4000e91c: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000e920: b8 10 60 b0 or %g1, 0xb0, %i4 ! 4001b8b0 <status_flags_assoc+0x128>
printk("PASS: %d !front and back sizes don't match", source);
error = 1;
}
if (!prev_used) {
if (do_dump || error) printk("\n");
printk("PASS: %d !two consecutive blocks are free", source);
4000e924: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000e928: ba 10 60 80 or %g1, 0x80, %i5 ! 4001b880 <status_flags_assoc+0xf8>
if (!_Heap_Is_prev_used(next_block)) {
if (do_dump)
printk( " prev %p next %p", the_block->prev, the_block->next);
if (_Heap_Block_size(the_block) != next_block->prev_size) {
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
4000e92c: 03 10 00 6e sethi %hi(0x4001b800), %g1
4000e930: ae 10 60 50 or %g1, 0x50, %l7 ! 4001b850 <status_flags_assoc+0xc8>
if (the_block->prev_size != the_heap->page_size) {
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
error = 1;
}
while ( the_block != end ) {
4000e934: 80 a4 00 16 cmp %l0, %l6
4000e938: 32 bf ff a3 bne,a 4000e7c4 <_Heap_Walk+0x70>
4000e93c: c2 04 e0 20 ld [ %l3 + 0x20 ], %g1
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
4000e940: 10 80 00 09 b 4000e964 <_Heap_Walk+0x210>
4000e944: c2 04 20 04 ld [ %l0 + 4 ], %g1
the_block = next_block;
}
if (the_block != end) {
printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
4000e948: 11 10 00 6e sethi %hi(0x4001b800), %o0 <== NOT EXECUTED
4000e94c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000e950: 90 12 21 30 or %o0, 0x130, %o0 <== NOT EXECUTED
4000e954: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
4000e958: 7f ff db 20 call 400055d8 <printk> <== NOT EXECUTED
4000e95c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
4000e960: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
4000e964: d6 04 e0 10 ld [ %l3 + 0x10 ], %o3
4000e968: 94 08 7f fe and %g1, -2, %o2
4000e96c: 80 a2 80 0b cmp %o2, %o3
4000e970: 02 80 00 06 be 4000e988 <_Heap_Walk+0x234> <== ALWAYS TAKEN
4000e974: 92 10 00 19 mov %i1, %o1
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
4000e978: 11 10 00 6e sethi %hi(0x4001b800), %o0 <== NOT EXECUTED
4000e97c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
4000e980: 7f ff db 16 call 400055d8 <printk> <== NOT EXECUTED
4000e984: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
4000e988: 81 c7 e0 08 ret
4000e98c: 81 e8 00 00 restore
4000b1a4 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
int _Objects_API_maximum_class(
uint32_t api
)
{
4000b1a4: 82 10 00 08 mov %o0, %g1
switch (api) {
4000b1a8: 80 a2 20 02 cmp %o0, 2
4000b1ac: 02 80 00 08 be 4000b1cc <_Objects_API_maximum_class+0x28>
4000b1b0: 90 10 20 0a mov 0xa, %o0
4000b1b4: 80 a0 60 02 cmp %g1, 2
4000b1b8: 18 80 00 07 bgu 4000b1d4 <_Objects_API_maximum_class+0x30>
4000b1bc: 80 a0 60 03 cmp %g1, 3
4000b1c0: 80 a0 60 01 cmp %g1, 1
4000b1c4: 12 80 00 09 bne 4000b1e8 <_Objects_API_maximum_class+0x44>
4000b1c8: 90 10 20 02 mov 2, %o0
4000b1cc: 81 c3 e0 08 retl
4000b1d0: 01 00 00 00 nop
4000b1d4: 02 bf ff fe be 4000b1cc <_Objects_API_maximum_class+0x28> <== NEVER TAKEN
4000b1d8: 90 10 20 0c mov 0xc, %o0 ! c <PROM_START+0xc>
4000b1dc: 80 a0 60 04 cmp %g1, 4
4000b1e0: 02 bf ff fb be 4000b1cc <_Objects_API_maximum_class+0x28>
4000b1e4: 90 10 20 08 mov 8, %o0
case OBJECTS_CLASSIC_API:
return OBJECTS_RTEMS_CLASSES_LAST;
case OBJECTS_POSIX_API:
return OBJECTS_POSIX_CLASSES_LAST;
case OBJECTS_ITRON_API:
return OBJECTS_ITRON_CLASSES_LAST;
4000b1e8: 90 10 3f ff mov -1, %o0
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
4000b1ec: 81 c3 e0 08 retl
40006688 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
40006688: 9d e3 bf 98 save %sp, -104, %sp
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
4000668c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
40006690: a0 10 00 18 mov %i0, %l0
* If the application is using the optional manager stubs and
* still attempts to create the object, the information block
* should be all zeroed out because it is in the BSS. So let's
* check that code for this manager is even present.
*/
if ( information->size == 0 )
40006694: 80 a0 60 00 cmp %g1, 0
40006698: 02 80 00 24 be 40006728 <_Objects_Allocate+0xa0> <== NEVER TAKEN
4000669c: b0 10 20 00 clr %i0
/*
* OK. The manager should be initialized and configured to have objects.
* With any luck, it is safe to attempt to allocate an object.
*/
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
400066a0: a2 04 20 20 add %l0, 0x20, %l1
400066a4: 40 00 11 97 call 4000ad00 <_Chain_Get>
400066a8: 90 10 00 11 mov %l1, %o0
if ( information->auto_extend ) {
400066ac: c2 0c 20 12 ldub [ %l0 + 0x12 ], %g1
400066b0: 80 a0 60 00 cmp %g1, 0
400066b4: 02 80 00 1d be 40006728 <_Objects_Allocate+0xa0>
400066b8: b0 10 00 08 mov %o0, %i0
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
400066bc: 80 a2 20 00 cmp %o0, 0
400066c0: 32 80 00 0a bne,a 400066e8 <_Objects_Allocate+0x60>
400066c4: c4 06 20 08 ld [ %i0 + 8 ], %g2
_Objects_Extend_information( information );
400066c8: 40 00 00 25 call 4000675c <_Objects_Extend_information>
400066cc: 90 10 00 10 mov %l0, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
400066d0: 40 00 11 8c call 4000ad00 <_Chain_Get>
400066d4: 90 10 00 11 mov %l1, %o0
}
if ( the_object ) {
400066d8: b0 92 20 00 orcc %o0, 0, %i0
400066dc: 02 80 00 13 be 40006728 <_Objects_Allocate+0xa0> <== NEVER TAKEN
400066e0: 01 00 00 00 nop
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
400066e4: c4 06 20 08 ld [ %i0 + 8 ], %g2
400066e8: d0 04 20 08 ld [ %l0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
400066ec: d2 04 20 14 ld [ %l0 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
400066f0: 03 00 00 3f sethi %hi(0xfc00), %g1
400066f4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400066f8: 84 08 80 01 and %g2, %g1, %g2
400066fc: 90 0a 00 01 and %o0, %g1, %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40006700: 40 00 32 63 call 4001308c <.udiv>
40006704: 90 20 80 08 sub %g2, %o0, %o0
40006708: c6 04 20 30 ld [ %l0 + 0x30 ], %g3
4000670c: 91 2a 20 02 sll %o0, 2, %o0
information->inactive--;
40006710: c2 14 20 2c lduh [ %l0 + 0x2c ], %g1
block = _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40006714: c4 00 c0 08 ld [ %g3 + %o0 ], %g2
information->inactive--;
40006718: 82 00 7f ff add %g1, -1, %g1
block = _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
4000671c: 84 00 bf ff add %g2, -1, %g2
information->inactive--;
40006720: c2 34 20 2c sth %g1, [ %l0 + 0x2c ]
block = _Objects_Get_index( the_object->id ) -
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
40006724: c4 20 c0 08 st %g2, [ %g3 + %o0 ]
information->inactive--;
}
}
return the_object;
}
40006728: 81 c7 e0 08 ret
4000672c: 81 e8 00 00 restore
4000675c <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
4000675c: 9d e3 bf 88 save %sp, -120, %sp
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index(
Objects_Id id
)
{
return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS;
40006760: c4 06 20 08 ld [ %i0 + 8 ], %g2
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
if ( information->maximum < minimum_index )
40006764: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0
40006768: 03 00 00 3f sethi %hi(0xfc00), %g1
4000676c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40006770: a2 08 80 01 and %g2, %g1, %l1
40006774: 80 a4 00 11 cmp %l0, %l1
40006778: 3a 80 00 06 bcc,a 40006790 <_Objects_Extend_information+0x34>
4000677c: e4 06 20 14 ld [ %i0 + 0x14 ], %l2
40006780: aa 10 00 11 mov %l1, %l5
40006784: ae 10 20 00 clr %l7
40006788: 10 80 00 13 b 400067d4 <_Objects_Extend_information+0x78>
4000678c: ac 10 20 00 clr %l6
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
40006790: 90 10 00 10 mov %l0, %o0
40006794: 92 10 00 12 mov %l2, %o1
40006798: 40 00 32 3d call 4001308c <.udiv>
4000679c: aa 10 00 11 mov %l1, %l5
400067a0: ac 10 20 00 clr %l6
400067a4: 10 80 00 09 b 400067c8 <_Objects_Extend_information+0x6c>
400067a8: ae 10 00 08 mov %o0, %l7
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL )
400067ac: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
400067b0: c2 00 40 02 ld [ %g1 + %g2 ], %g1
400067b4: 80 a0 60 00 cmp %g1, 0
400067b8: 02 80 00 08 be 400067d8 <_Objects_Extend_information+0x7c>
400067bc: 80 a5 40 10 cmp %l5, %l0
break;
else
index_base += information->allocation_size;
400067c0: aa 05 40 12 add %l5, %l2, %l5
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
400067c4: ac 05 a0 01 inc %l6
400067c8: 80 a5 80 17 cmp %l6, %l7
400067cc: 0a bf ff f8 bcs 400067ac <_Objects_Extend_information+0x50>
400067d0: 85 2d a0 02 sll %l6, 2, %g2
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
400067d4: 80 a5 40 10 cmp %l5, %l0
400067d8: 2a 80 00 5d bcs,a 4000694c <_Objects_Extend_information+0x1f0>
400067dc: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
* Up the block count and maximum
*/
block_count++;
maximum = information->maximum + information->allocation_size;
400067e0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
400067e4: c4 0e 20 12 ldub [ %i0 + 0x12 ], %g2
* Up the block count and maximum
*/
block_count++;
maximum = information->maximum + information->allocation_size;
400067e8: ba 04 00 01 add %l0, %g1, %i5
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
400067ec: 80 a0 a0 00 cmp %g2, 0
/*
* Up the block count and maximum
*/
block_count++;
400067f0: a0 05 e0 01 add %l7, 1, %l0
400067f4: 82 07 40 11 add %i5, %l1, %g1
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
400067f8: 02 80 00 0b be 40006824 <_Objects_Extend_information+0xc8>
400067fc: 91 2c 20 01 sll %l0, 1, %o0
object_blocks = (void**)
40006800: 90 02 00 10 add %o0, %l0, %o0
40006804: 90 00 40 08 add %g1, %o0, %o0
40006808: 40 00 08 5b call 40008974 <_Workspace_Allocate>
4000680c: 91 2a 20 02 sll %o0, 2, %o0
block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *))
);
if ( !object_blocks )
40006810: a4 92 20 00 orcc %o0, 0, %l2
40006814: 32 80 00 0a bne,a 4000683c <_Objects_Extend_information+0xe0><== ALWAYS TAKEN
40006818: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
4000681c: 81 c7 e0 08 ret <== NOT EXECUTED
40006820: 81 e8 00 00 restore <== NOT EXECUTED
return;
}
else {
object_blocks = (void**)
40006824: 90 02 00 10 add %o0, %l0, %o0
40006828: 90 00 40 08 add %g1, %o0, %o0
4000682c: 40 00 08 59 call 40008990 <_Workspace_Allocate_or_fatal_error>
40006830: 91 2a 20 02 sll %o0, 2, %o0
40006834: a4 10 00 08 mov %o0, %l2
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
40006838: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
4000683c: 85 2c 20 02 sll %l0, 2, %g2
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
40006840: 80 a0 40 11 cmp %g1, %l1
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
40006844: a8 04 80 02 add %l2, %g2, %l4
40006848: a6 05 00 02 add %l4, %g2, %l3
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
4000684c: 08 80 00 15 bleu 400068a0 <_Objects_Extend_information+0x144>
40006850: 84 10 20 00 clr %g2
/*
* 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,
40006854: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40006858: a1 2d e0 02 sll %l7, 2, %l0
4000685c: 90 10 00 12 mov %l2, %o0
40006860: 40 00 18 2d call 4000c914 <memcpy>
40006864: 94 10 00 10 mov %l0, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
40006868: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
4000686c: 94 10 00 10 mov %l0, %o2
40006870: 40 00 18 29 call 4000c914 <memcpy>
40006874: 90 10 00 14 mov %l4, %o0
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
40006878: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
4000687c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
40006880: 94 04 40 0a add %l1, %o2, %o2
40006884: 90 10 00 13 mov %l3, %o0
40006888: 40 00 18 23 call 4000c914 <memcpy>
4000688c: 95 2a a0 02 sll %o2, 2, %o2
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
40006890: 10 80 00 08 b 400068b0 <_Objects_Extend_information+0x154>
40006894: 83 2d e0 02 sll %l7, 2, %g1
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
40006898: 84 00 a0 01 inc %g2
local_table[ index ] = NULL;
4000689c: c0 24 c0 01 clr [ %l3 + %g1 ]
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
400068a0: 80 a0 80 11 cmp %g2, %l1
400068a4: 2a bf ff fd bcs,a 40006898 <_Objects_Extend_information+0x13c>
400068a8: 83 28 a0 02 sll %g2, 2, %g1
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
400068ac: 83 2d e0 02 sll %l7, 2, %g1
inactive_per_block[block_count] = 0;
400068b0: c0 25 00 01 clr [ %l4 + %g1 ]
for ( index=index_base ;
index < ( information->allocation_size + index_base );
400068b4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
400068b8: c0 24 80 01 clr [ %l2 + %g1 ]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
400068bc: 83 2d 60 02 sll %l5, 2, %g1
400068c0: 86 05 40 02 add %l5, %g2, %g3
400068c4: 84 04 c0 01 add %l3, %g1, %g2
400068c8: 10 80 00 04 b 400068d8 <_Objects_Extend_information+0x17c>
400068cc: 82 10 00 15 mov %l5, %g1
index++ ) {
400068d0: 82 00 60 01 inc %g1
400068d4: 84 00 a0 04 add %g2, 4, %g2
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
400068d8: 80 a0 40 03 cmp %g1, %g3
400068dc: 2a bf ff fd bcs,a 400068d0 <_Objects_Extend_information+0x174>
400068e0: c0 20 80 00 clr [ %g2 ]
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
400068e4: 7f ff ec fe call 40001cdc <sparc_disable_interrupts>
400068e8: 01 00 00 00 nop
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
400068ec: c2 06 00 00 ld [ %i0 ], %g1
400068f0: c8 16 20 04 lduh [ %i0 + 4 ], %g4
400068f4: 87 2f 60 10 sll %i5, 0x10, %g3
400068f8: 89 29 20 1b sll %g4, 0x1b, %g4
400068fc: 87 30 e0 10 srl %g3, 0x10, %g3
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
40006900: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
40006904: 05 00 00 40 sethi %hi(0x10000), %g2
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
40006908: e8 26 20 30 st %l4, [ %i0 + 0x30 ]
information->local_table = local_table;
4000690c: e6 26 20 1c st %l3, [ %i0 + 0x1c ]
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
40006910: 83 28 60 18 sll %g1, 0x18, %g1
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = maximum;
40006914: fa 36 20 10 sth %i5, [ %i0 + 0x10 ]
information->maximum_id = _Objects_Build_id(
40006918: 82 10 40 02 or %g1, %g2, %g1
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
4000691c: e4 26 20 34 st %l2, [ %i0 + 0x34 ]
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
40006920: 82 10 40 04 or %g1, %g4, %g1
40006924: 82 10 40 03 or %g1, %g3, %g1
40006928: c2 26 20 0c st %g1, [ %i0 + 0xc ]
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
4000692c: 7f ff ec f0 call 40001cec <sparc_enable_interrupts>
40006930: 01 00 00 00 nop
if ( old_tables )
40006934: 80 a4 20 00 cmp %l0, 0
40006938: 22 80 00 05 be,a 4000694c <_Objects_Extend_information+0x1f0>
4000693c: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
_Workspace_Free( old_tables );
40006940: 40 00 08 06 call 40008958 <_Workspace_Free>
40006944: 90 10 00 10 mov %l0, %o0
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
40006948: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
4000694c: e2 06 20 34 ld [ %i0 + 0x34 ], %l1
40006950: 80 a0 60 00 cmp %g1, 0
40006954: 02 80 00 0f be 40006990 <_Objects_Extend_information+0x234>
40006958: a1 2d a0 02 sll %l6, 2, %l0
information->object_blocks[ block ] =
4000695c: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
40006960: 40 00 31 91 call 40012fa4 <.umul>
40006964: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
40006968: 40 00 08 03 call 40008974 <_Workspace_Allocate>
4000696c: 01 00 00 00 nop
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
40006970: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
information->object_blocks[ block ] =
40006974: d0 24 40 10 st %o0, [ %l1 + %l0 ]
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
40006978: c2 00 40 10 ld [ %g1 + %l0 ], %g1
4000697c: 80 a0 60 00 cmp %g1, 0
40006980: 32 80 00 0b bne,a 400069ac <_Objects_Extend_information+0x250><== ALWAYS TAKEN
40006984: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40006988: 81 c7 e0 08 ret <== NOT EXECUTED
4000698c: 81 e8 00 00 restore <== NOT EXECUTED
return;
}
else {
information->object_blocks[ block ] =
40006990: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
40006994: 40 00 31 84 call 40012fa4 <.umul>
40006998: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
4000699c: 40 00 07 fd call 40008990 <_Workspace_Allocate_or_fatal_error>
400069a0: 01 00 00 00 nop
400069a4: d0 24 40 10 st %o0, [ %l1 + %l0 ]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
400069a8: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
400069ac: a5 2d a0 02 sll %l6, 2, %l2
400069b0: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
400069b4: d2 00 40 12 ld [ %g1 + %l2 ], %o1
400069b8: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
400069bc: 90 07 bf ec add %fp, -20, %o0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
400069c0: a0 10 00 15 mov %l5, %l0
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
400069c4: a8 10 00 08 mov %o0, %l4
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
400069c8: 40 00 10 de call 4000ad40 <_Chain_Initialize>
400069cc: a2 06 20 20 add %i0, 0x20, %l1
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
400069d0: 10 80 00 0d b 40006a04 <_Objects_Extend_information+0x2a8>
400069d4: 27 00 00 40 sethi %hi(0x10000), %l3
400069d8: c4 16 20 04 lduh [ %i0 + 4 ], %g2
400069dc: 83 28 60 18 sll %g1, 0x18, %g1
400069e0: 85 28 a0 1b sll %g2, 0x1b, %g2
400069e4: 82 10 40 13 or %g1, %l3, %g1
400069e8: 82 10 40 02 or %g1, %g2, %g1
400069ec: 82 10 40 10 or %g1, %l0, %g1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
400069f0: 92 10 00 08 mov %o0, %o1
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
400069f4: c2 22 20 08 st %g1, [ %o0 + 8 ]
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
400069f8: a0 04 20 01 inc %l0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
400069fc: 7f ff fd 14 call 40005e4c <_Chain_Append>
40006a00: 90 10 00 11 mov %l1, %o0
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
40006a04: 40 00 10 bf call 4000ad00 <_Chain_Get>
40006a08: 90 10 00 14 mov %l4, %o0
40006a0c: 80 a2 20 00 cmp %o0, 0
40006a10: 32 bf ff f2 bne,a 400069d8 <_Objects_Extend_information+0x27c>
40006a14: c2 06 00 00 ld [ %i0 ], %g1
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40006a18: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40006a1c: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
information->inactive += information->allocation_size;
40006a20: c6 16 20 2c lduh [ %i0 + 0x2c ], %g3
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
40006a24: c2 20 80 12 st %g1, [ %g2 + %l2 ]
information->inactive += information->allocation_size;
40006a28: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40006a2c: 82 00 40 03 add %g1, %g3, %g1
40006a30: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
40006a34: 81 c7 e0 08 ret
40006a38: 81 e8 00 00 restore
40006ae8 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
40006ae8: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
40006aec: 82 06 3f ff add %i0, -1, %g1
40006af0: 80 a0 60 03 cmp %g1, 3
40006af4: 38 80 00 1c bgu,a 40006b64 <_Objects_Get_information+0x7c>
40006af8: b0 10 20 00 clr %i0
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
40006afc: 10 80 00 1c b 40006b6c <_Objects_Get_information+0x84>
40006b00: 80 a6 60 00 cmp %i1, 0
return NULL;
the_class_api_maximum = _Objects_API_maximum_class( the_api );
40006b04: 40 00 11 a8 call 4000b1a4 <_Objects_API_maximum_class>
40006b08: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum < 0 ||
40006b0c: 80 a2 20 00 cmp %o0, 0
40006b10: 06 80 00 14 bl 40006b60 <_Objects_Get_information+0x78> <== NEVER TAKEN
40006b14: 80 a6 40 08 cmp %i1, %o0
40006b18: 38 80 00 13 bgu,a 40006b64 <_Objects_Get_information+0x7c><== NEVER TAKEN
40006b1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
40006b20: 85 2e 20 02 sll %i0, 2, %g2
40006b24: 03 10 00 5f sethi %hi(0x40017c00), %g1
40006b28: 82 10 62 30 or %g1, 0x230, %g1 ! 40017e30 <_Objects_Information_table>
40006b2c: c4 00 40 02 ld [ %g1 + %g2 ], %g2
40006b30: 80 a0 a0 00 cmp %g2, 0
40006b34: 02 80 00 0c be 40006b64 <_Objects_Get_information+0x7c> <== NEVER TAKEN
40006b38: b0 10 20 00 clr %i0
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
40006b3c: 83 2e 60 02 sll %i1, 2, %g1
40006b40: f0 00 80 01 ld [ %g2 + %g1 ], %i0
if ( !info )
40006b44: 80 a6 20 00 cmp %i0, 0
40006b48: 02 80 00 07 be 40006b64 <_Objects_Get_information+0x7c> <== NEVER TAKEN
40006b4c: 01 00 00 00 nop
* 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 )
40006b50: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40006b54: 80 a0 60 00 cmp %g1, 0
40006b58: 12 80 00 03 bne 40006b64 <_Objects_Get_information+0x7c>
40006b5c: 01 00 00 00 nop
40006b60: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return NULL;
#endif
return info;
}
40006b64: 81 c7 e0 08 ret
40006b68: 81 e8 00 00 restore
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
40006b6c: 22 bf ff fe be,a 40006b64 <_Objects_Get_information+0x7c>
40006b70: b0 10 20 00 clr %i0
40006b74: 30 bf ff e4 b,a 40006b04 <_Objects_Get_information+0x1c>
40006b78 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
40006b78: 9d e3 bf 98 save %sp, -104, %sp
#if defined(RTEMS_MULTIPROCESSING)
index = id - information->minimum_id + 1;
#else
/* index = _Objects_Get_index( id ); */
index = id & 0x0000ffff;
40006b7c: 03 00 00 3f sethi %hi(0xfc00), %g1
40006b80: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
/* This should work but doesn't always :( */
/* index = (uint16_t ) id; */
#endif
_ISR_Disable( level );
40006b84: 7f ff ec 56 call 40001cdc <sparc_disable_interrupts>
40006b88: b2 0e 40 01 and %i1, %g1, %i1
if ( information->maximum >= index ) {
40006b8c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
40006b90: 80 a0 40 19 cmp %g1, %i1
40006b94: 0a 80 00 11 bcs 40006bd8 <_Objects_Get_isr_disable+0x60>
40006b98: 83 2e 60 02 sll %i1, 2, %g1
if ( (the_object = information->local_table[ index ]) != NULL ) {
40006b9c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
40006ba0: f0 00 80 01 ld [ %g2 + %g1 ], %i0
40006ba4: 80 a6 20 00 cmp %i0, 0
40006ba8: 02 80 00 06 be 40006bc0 <_Objects_Get_isr_disable+0x48> <== NEVER TAKEN
40006bac: 01 00 00 00 nop
*location = OBJECTS_LOCAL;
*level_p = level;
40006bb0: d0 26 c0 00 st %o0, [ %i3 ]
#endif
_ISR_Disable( level );
if ( information->maximum >= index ) {
if ( (the_object = information->local_table[ index ]) != NULL ) {
*location = OBJECTS_LOCAL;
40006bb4: c0 26 80 00 clr [ %i2 ]
40006bb8: 81 c7 e0 08 ret
40006bbc: 81 e8 00 00 restore
*level_p = level;
return the_object;
}
_ISR_Enable( level );
40006bc0: 7f ff ec 4b call 40001cec <sparc_enable_interrupts>
40006bc4: 01 00 00 00 nop
*location = OBJECTS_ERROR;
40006bc8: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1> <== NOT EXECUTED
40006bcc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
40006bd0: 81 c7 e0 08 ret <== NOT EXECUTED
40006bd4: 81 e8 00 00 restore <== NOT EXECUTED
return NULL;
}
_ISR_Enable( level );
40006bd8: 7f ff ec 45 call 40001cec <sparc_enable_interrupts>
40006bdc: b0 10 20 00 clr %i0
*location = OBJECTS_ERROR;
40006be0: 82 10 20 01 mov 1, %g1
40006be4: c2 26 80 00 st %g1, [ %i2 ]
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
40006be8: 81 c7 e0 08 ret
40006bec: 81 e8 00 00 restore
400084e4 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
400084e4: 9d e3 bf 88 save %sp, -120, %sp
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
400084e8: 80 a6 60 00 cmp %i1, 0
400084ec: 22 80 00 41 be,a 400085f0 <_Objects_Get_name_as_string+0x10c>
400084f0: b4 10 20 00 clr %i2
return NULL;
if ( name == NULL )
400084f4: 80 a6 a0 00 cmp %i2, 0
400084f8: 22 80 00 3f be,a 400085f4 <_Objects_Get_name_as_string+0x110>
400084fc: b0 10 00 1a mov %i2, %i0
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40008500: b0 96 20 00 orcc %i0, 0, %i0
40008504: 12 80 00 04 bne 40008514 <_Objects_Get_name_as_string+0x30>
40008508: 03 10 00 91 sethi %hi(0x40024400), %g1
4000850c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 40024470 <_Thread_Executing>
40008510: f0 00 60 08 ld [ %g1 + 8 ], %i0
information = _Objects_Get_information_id( tmpId );
40008514: 7f ff ff ab call 400083c0 <_Objects_Get_information_id>
40008518: 90 10 00 18 mov %i0, %o0
if ( !information )
4000851c: a0 92 20 00 orcc %o0, 0, %l0
40008520: 22 80 00 34 be,a 400085f0 <_Objects_Get_name_as_string+0x10c>
40008524: b4 10 20 00 clr %i2
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
40008528: 92 10 00 18 mov %i0, %o1
4000852c: 40 00 00 34 call 400085fc <_Objects_Get>
40008530: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
40008534: c2 07 bf f4 ld [ %fp + -12 ], %g1
40008538: 80 a0 60 00 cmp %g1, 0
4000853c: 32 80 00 2d bne,a 400085f0 <_Objects_Get_name_as_string+0x10c>
40008540: b4 10 20 00 clr %i2
case OBJECTS_ERROR:
return NULL;
case OBJECTS_LOCAL:
if ( information->is_string ) {
40008544: c2 0c 20 38 ldub [ %l0 + 0x38 ], %g1
40008548: 80 a0 60 00 cmp %g1, 0
4000854c: 22 80 00 07 be,a 40008568 <_Objects_Get_name_as_string+0x84>
40008550: c2 02 20 0c ld [ %o0 + 0xc ], %g1
s = the_object->name.name_p;
40008554: d0 02 20 0c ld [ %o0 + 0xc ], %o0
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
40008558: 80 a2 20 00 cmp %o0, 0
4000855c: 12 80 00 0c bne 4000858c <_Objects_Get_name_as_string+0xa8><== ALWAYS TAKEN
40008560: 86 10 00 1a mov %i2, %g3
40008564: 30 80 00 1f b,a 400085e0 <_Objects_Get_name_as_string+0xfc><== NOT EXECUTED
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
40008568: c0 2f bf ec clrb [ %fp + -20 ]
if ( information->is_string ) {
s = the_object->name.name_p;
} else {
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
4000856c: 85 30 60 18 srl %g1, 0x18, %g2
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
40008570: c2 2f bf eb stb %g1, [ %fp + -21 ]
if ( information->is_string ) {
s = the_object->name.name_p;
} else {
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
40008574: c4 2f bf e8 stb %g2, [ %fp + -24 ]
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
40008578: 90 07 bf e8 add %fp, -24, %o0
s = the_object->name.name_p;
} else {
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
4000857c: 85 30 60 10 srl %g1, 0x10, %g2
lname[ 2 ] = (u32_name >> 8) & 0xff;
40008580: 83 30 60 08 srl %g1, 8, %g1
s = the_object->name.name_p;
} else {
uint32_t u32_name = (uint32_t) the_object->name.name_u32;
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
40008584: c4 2f bf e9 stb %g2, [ %fp + -23 ]
lname[ 2 ] = (u32_name >> 8) & 0xff;
40008588: c2 2f bf ea stb %g1, [ %fp + -22 ]
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint(*s)) ? *s : '*';
4000858c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
40008590: b2 06 7f ff add %i1, -1, %i1
*d = (isprint(*s)) ? *s : '*';
40008594: 98 10 62 50 or %g1, 0x250, %o4
lname[ 0 ] = (u32_name >> 24) & 0xff;
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
40008598: 86 10 00 1a mov %i2, %g3
4000859c: 10 80 00 0a b 400085c4 <_Objects_Get_name_as_string+0xe0>
400085a0: 84 10 20 00 clr %g2
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
*d = (isprint(*s)) ? *s : '*';
400085a4: c2 03 00 00 ld [ %o4 ], %g1
400085a8: c2 48 40 04 ldsb [ %g1 + %g4 ], %g1
400085ac: 80 88 60 97 btst 0x97, %g1
400085b0: 12 80 00 03 bne 400085bc <_Objects_Get_name_as_string+0xd8>
400085b4: 84 00 a0 01 inc %g2
400085b8: 9a 10 20 2a mov 0x2a, %o5
400085bc: da 28 c0 00 stb %o5, [ %g3 ]
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
400085c0: 86 00 e0 01 inc %g3
400085c4: 80 a0 80 19 cmp %g2, %i1
400085c8: 1a 80 00 06 bcc 400085e0 <_Objects_Get_name_as_string+0xfc>
400085cc: 01 00 00 00 nop
400085d0: c8 4a 00 02 ldsb [ %o0 + %g2 ], %g4
400085d4: 80 a1 20 00 cmp %g4, 0
400085d8: 12 bf ff f3 bne 400085a4 <_Objects_Get_name_as_string+0xc0>
400085dc: da 0a 00 02 ldub [ %o0 + %g2 ], %o5
*d = (isprint(*s)) ? *s : '*';
}
}
*d = '\0';
_Thread_Enable_dispatch();
400085e0: 40 00 02 2d call 40008e94 <_Thread_Enable_dispatch>
400085e4: c0 28 c0 00 clrb [ %g3 ]
return name;
}
return NULL; /* unreachable path */
}
400085e8: 81 c7 e0 08 ret
400085ec: 91 e8 00 1a restore %g0, %i2, %o0
400085f0: b0 10 00 1a mov %i2, %i0
400085f4: 81 c7 e0 08 ret
400085f8: 81 e8 00 00 restore
40013e58 <_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;
40013e58: c2 02 20 08 ld [ %o0 + 8 ], %g1
if ( information->maximum >= index ) {
40013e5c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2
/*
* 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;
40013e60: 92 22 40 01 sub %o1, %g1, %o1
40013e64: 82 02 60 01 add %o1, 1, %g1
if ( information->maximum >= index ) {
40013e68: 80 a0 80 01 cmp %g2, %g1
40013e6c: 0a 80 00 09 bcs 40013e90 <_Objects_Get_no_protection+0x38>
40013e70: 83 28 60 02 sll %g1, 2, %g1
if ( (the_object = information->local_table[ index ]) != NULL ) {
40013e74: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
40013e78: d0 00 80 01 ld [ %g2 + %g1 ], %o0
40013e7c: 80 a2 20 00 cmp %o0, 0
40013e80: 02 80 00 05 be 40013e94 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
40013e84: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
40013e88: 81 c3 e0 08 retl
40013e8c: c0 22 80 00 clr [ %o2 ]
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
40013e90: 82 10 20 01 mov 1, %g1
40013e94: 90 10 20 00 clr %o0
return NULL;
}
40013e98: 81 c3 e0 08 retl
40013e9c: c2 22 80 00 st %g1, [ %o2 ]
40008048 <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
40008048: 9d e3 bf 90 save %sp, -112, %sp
4000804c: 92 10 00 18 mov %i0, %o1
Objects_Id tmpId;
Objects_Information *information;
Objects_Control *the_object = (Objects_Control *) 0;
Objects_Locations ignored_location;
if ( !name )
40008050: 80 a6 60 00 cmp %i1, 0
40008054: 02 80 00 22 be 400080dc <_Objects_Id_to_name+0x94> <== NEVER TAKEN
40008058: b0 10 20 01 mov 1, %i0
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
4000805c: 80 a2 60 00 cmp %o1, 0
40008060: 12 80 00 06 bne 40008078 <_Objects_Id_to_name+0x30>
40008064: 83 32 60 18 srl %o1, 0x18, %g1
40008068: 03 10 00 70 sethi %hi(0x4001c000), %g1
4000806c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 ! 4001c110 <_Thread_Executing>
40008070: d2 00 60 08 ld [ %g1 + 8 ], %o1
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
40008074: 83 32 60 18 srl %o1, 0x18, %g1
40008078: 84 08 60 07 and %g1, 7, %g2
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
4000807c: 82 00 bf ff add %g2, -1, %g1
40008080: 80 a0 60 03 cmp %g1, 3
40008084: 38 80 00 16 bgu,a 400080dc <_Objects_Id_to_name+0x94>
40008088: b0 10 20 03 mov 3, %i0
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
4000808c: 10 80 00 18 b 400080ec <_Objects_Id_to_name+0xa4>
40008090: 85 28 a0 02 sll %g2, 2, %g2
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
40008094: 83 28 60 02 sll %g1, 2, %g1
40008098: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !information )
4000809c: 80 a2 20 00 cmp %o0, 0
400080a0: 02 80 00 0f be 400080dc <_Objects_Id_to_name+0x94> <== NEVER TAKEN
400080a4: b0 10 20 03 mov 3, %i0
return OBJECTS_INVALID_ID;
if ( information->is_string )
400080a8: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
400080ac: 80 a0 60 00 cmp %g1, 0
400080b0: 12 80 00 0d bne 400080e4 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN
400080b4: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &ignored_location );
400080b8: 7f ff ff c7 call 40007fd4 <_Objects_Get>
400080bc: 94 07 bf f4 add %fp, -12, %o2
if ( !the_object )
400080c0: 80 a2 20 00 cmp %o0, 0
400080c4: 22 80 00 06 be,a 400080dc <_Objects_Id_to_name+0x94>
400080c8: b0 10 20 03 mov 3, %i0
return OBJECTS_INVALID_ID;
*name = the_object->name;
400080cc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
400080d0: b0 10 20 00 clr %i0
400080d4: 40 00 02 44 call 400089e4 <_Thread_Enable_dispatch>
400080d8: c2 26 40 00 st %g1, [ %i1 ]
400080dc: 81 c7 e0 08 ret
400080e0: 81 e8 00 00 restore
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
400080e4: 81 c7 e0 08 ret
400080e8: 81 e8 00 00 restore <== 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 ] )
400080ec: 03 10 00 6f sethi %hi(0x4001bc00), %g1
400080f0: 82 10 63 b0 or %g1, 0x3b0, %g1 ! 4001bfb0 <_Objects_Information_table>
400080f4: c4 00 40 02 ld [ %g1 + %g2 ], %g2
400080f8: 80 a0 a0 00 cmp %g2, 0
400080fc: 12 bf ff e6 bne 40008094 <_Objects_Id_to_name+0x4c> <== ALWAYS TAKEN
40008100: 83 32 60 1b srl %o1, 0x1b, %g1
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
40008104: 81 c7 e0 08 ret <== NOT EXECUTED
40008108: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED
40006c64 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
40006c64: 9d e3 bf 98 save %sp, -104, %sp
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
40006c68: 03 10 00 5f sethi %hi(0x40017c00), %g1
40006c6c: 85 2e 60 02 sll %i1, 2, %g2
40006c70: 82 10 62 30 or %g1, 0x230, %g1
40006c74: c2 00 40 02 ld [ %g1 + %g2 ], %g1
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006c78: 89 2e a0 1b sll %i2, 0x1b, %g4
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
40006c7c: f4 36 20 04 sth %i2, [ %i0 + 4 ]
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
40006c80: b5 2e a0 02 sll %i2, 2, %i2
40006c84: f0 20 40 1a st %i0, [ %g1 + %i2 ]
/*
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
40006c88: 83 36 e0 1f srl %i3, 0x1f, %g1
40006c8c: c2 2e 20 12 stb %g1, [ %i0 + 0x12 ]
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
40006c90: 03 20 00 00 sethi %hi(0x80000000), %g1
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
40006c94: de 07 a0 5c ld [ %fp + 0x5c ], %o7
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
information->is_string = is_string;
40006c98: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ]
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
40006c9c: ba 2e c0 01 andn %i3, %g1, %i5
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
40006ca0: 03 10 00 5f sethi %hi(0x40017c00), %g1
40006ca4: 82 10 60 84 or %g1, 0x84, %g1 ! 40017c84 <null_local_table.3613>
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006ca8: 80 a0 00 1d cmp %g0, %i5
/*
* Set the size of the object
*/
information->size = size;
40006cac: b9 2f 20 10 sll %i4, 0x10, %i4
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006cb0: 86 40 20 00 addx %g0, 0, %g3
40006cb4: 85 2e 60 18 sll %i1, 0x18, %g2
/*
* Set the size of the object
*/
information->size = size;
40006cb8: b9 37 20 10 srl %i4, 0x10, %i4
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
40006cbc: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
/*
* Set the size of the object
*/
information->size = size;
40006cc0: f8 26 20 18 st %i4, [ %i0 + 0x18 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006cc4: 03 00 00 40 sethi %hi(0x10000), %g1
uint32_t name_length;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
40006cc8: f2 26 00 00 st %i1, [ %i0 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006ccc: 84 10 80 01 or %g2, %g1, %g2
information->the_api = the_api;
information->the_class = the_class;
information->is_string = is_string;
information->local_table = 0;
information->inactive_per_block = 0;
40006cd0: c0 26 20 30 clr [ %i0 + 0x30 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006cd4: 84 10 80 04 or %g2, %g4, %g2
information->the_class = the_class;
information->is_string = is_string;
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
40006cd8: c0 26 20 34 clr [ %i0 + 0x34 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006cdc: 84 10 80 03 or %g2, %g3, %g2
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
information->inactive = 0;
40006ce0: c0 36 20 2c clrh [ %i0 + 0x2c ]
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum;
40006ce4: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
40006ce8: c4 26 20 08 st %g2, [ %i0 + 8 ]
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
40006cec: 82 03 e0 04 add %o7, 4, %g1
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
40006cf0: 80 8b e0 03 btst 3, %o7
40006cf4: 12 80 00 03 bne 40006d00 <_Objects_Initialize_information+0x9c><== NEVER TAKEN
40006cf8: 82 08 7f fc and %g1, -4, %g1
40006cfc: 82 10 00 0f mov %o7, %g1
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
40006d00: c2 36 20 3a sth %g1, [ %i0 + 0x3a ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40006d04: 82 06 20 24 add %i0, 0x24, %g1
the_chain->permanent_null = NULL;
40006d08: c0 26 20 24 clr [ %i0 + 0x24 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40006d0c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
40006d10: 82 06 20 20 add %i0, 0x20, %g1
/*
* Initialize objects .. if there are any
*/
if ( maximum ) {
40006d14: 80 a7 60 00 cmp %i5, 0
40006d18: 02 80 00 05 be 40006d2c <_Objects_Initialize_information+0xc8>
40006d1c: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
/*
* Reset the maximum value. It will be updated when the information is
* extended.
*/
information->maximum = 0;
40006d20: c0 36 20 10 clrh [ %i0 + 0x10 ]
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
40006d24: 7f ff fe 8e call 4000675c <_Objects_Extend_information>
40006d28: 81 e8 00 00 restore
40006d2c: 81 c7 e0 08 ret
40006d30: 81 e8 00 00 restore
40006d6c <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
40006d6c: 9a 10 00 08 mov %o0, %o5
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
40006d70: 80 a2 e0 00 cmp %o3, 0
40006d74: 02 80 00 29 be 40006e18 <_Objects_Name_to_id_u32+0xac>
40006d78: 90 10 20 02 mov 2, %o0
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
40006d7c: 80 a2 60 00 cmp %o1, 0
40006d80: 22 80 00 26 be,a 40006e18 <_Objects_Name_to_id_u32+0xac>
40006d84: 90 10 20 01 mov 1, %o0
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
40006d88: c2 13 60 10 lduh [ %o5 + 0x10 ], %g1
40006d8c: 84 90 60 00 orcc %g1, 0, %g2
40006d90: 22 80 00 22 be,a 40006e18 <_Objects_Name_to_id_u32+0xac> <== NEVER TAKEN
40006d94: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
40006d98: 80 a2 a0 00 cmp %o2, 0
40006d9c: 02 80 00 19 be 40006e00 <_Objects_Name_to_id_u32+0x94>
40006da0: 83 28 a0 10 sll %g2, 0x10, %g1
40006da4: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
40006da8: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
40006dac: 80 a2 80 01 cmp %o2, %g1
40006db0: 02 80 00 13 be 40006dfc <_Objects_Name_to_id_u32+0x90>
40006db4: 80 a2 a0 01 cmp %o2, 1
40006db8: 32 80 00 18 bne,a 40006e18 <_Objects_Name_to_id_u32+0xac>
40006dbc: 90 10 20 01 mov 1, %o0
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
40006dc0: 10 80 00 10 b 40006e00 <_Objects_Name_to_id_u32+0x94>
40006dc4: 83 28 a0 10 sll %g2, 0x10, %g1
the_object = information->local_table[ index ];
40006dc8: c2 03 60 1c ld [ %o5 + 0x1c ], %g1
40006dcc: c4 00 40 02 ld [ %g1 + %g2 ], %g2
if ( !the_object )
40006dd0: 80 a0 a0 00 cmp %g2, 0
40006dd4: 02 80 00 0d be 40006e08 <_Objects_Name_to_id_u32+0x9c>
40006dd8: 86 00 e0 01 inc %g3
continue;
if ( name == the_object->name.name_u32 ) {
40006ddc: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
40006de0: 80 a2 40 01 cmp %o1, %g1
40006de4: 32 80 00 0a bne,a 40006e0c <_Objects_Name_to_id_u32+0xa0>
40006de8: 80 a0 c0 04 cmp %g3, %g4
*id = the_object->id;
40006dec: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40006df0: 90 10 20 00 clr %o0
40006df4: 81 c3 e0 08 retl
40006df8: c2 22 c0 00 st %g1, [ %o3 ]
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
40006dfc: 83 28 a0 10 sll %g2, 0x10, %g1
40006e00: 86 10 20 01 mov 1, %g3
40006e04: 89 30 60 10 srl %g1, 0x10, %g4
40006e08: 80 a0 c0 04 cmp %g3, %g4
40006e0c: 08 bf ff ef bleu 40006dc8 <_Objects_Name_to_id_u32+0x5c>
40006e10: 85 28 e0 02 sll %g3, 2, %g2
40006e14: 90 10 20 01 mov 1, %o0
name_for_mp.name_u32 = name;
return _Objects_MP_Global_name_search( information, name_for_mp, node, id );
#else
return OBJECTS_INVALID_NAME;
#endif
}
40006e18: 81 c3 e0 08 retl
40006d34 <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
40006d34: 9d e3 bf 98 save %sp, -104, %sp
/*
* If this is a string format name, then free the memory.
*/
if ( information->is_string && the_object->name.name_p )
40006d38: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
40006d3c: 80 a0 60 00 cmp %g1, 0
40006d40: 22 80 00 09 be,a 40006d64 <_Objects_Namespace_remove+0x30><== ALWAYS TAKEN
40006d44: c0 26 60 0c clr [ %i1 + 0xc ]
40006d48: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED
40006d4c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40006d50: 22 80 00 05 be,a 40006d64 <_Objects_Namespace_remove+0x30><== NOT EXECUTED
40006d54: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
40006d58: 40 00 07 00 call 40008958 <_Workspace_Free> <== NOT EXECUTED
40006d5c: 01 00 00 00 nop <== NOT EXECUTED
/*
* Clear out either format.
*/
the_object->name.name_p = NULL;
the_object->name.name_u32 = 0;
40006d60: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
}
40006d64: 81 c7 e0 08 ret
40006d68: 81 e8 00 00 restore
40008acc <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
40008acc: 9d e3 bf 98 save %sp, -104, %sp
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length ) + 1;
40008ad0: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1
40008ad4: 40 00 1c 94 call 4000fd24 <strnlen>
40008ad8: 90 10 00 1a mov %i2, %o0
if ( information->is_string ) {
40008adc: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
40008ae0: 80 a0 60 00 cmp %g1, 0
40008ae4: 02 80 00 17 be 40008b40 <_Objects_Set_name+0x74> <== ALWAYS TAKEN
40008ae8: a0 02 20 01 add %o0, 1, %l0
char *d;
d = _Workspace_Allocate( length );
40008aec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40008af0: 40 00 07 04 call 4000a700 <_Workspace_Allocate> <== NOT EXECUTED
40008af4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( !d )
40008af8: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED
40008afc: 02 80 00 27 be 40008b98 <_Objects_Set_name+0xcc> <== NOT EXECUTED
40008b00: 01 00 00 00 nop <== NOT EXECUTED
return FALSE;
if ( the_object->name.name_p ) {
40008b04: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED
40008b08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40008b0c: 02 80 00 06 be 40008b24 <_Objects_Set_name+0x58> <== NOT EXECUTED
40008b10: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
40008b14: 40 00 06 f4 call 4000a6e4 <_Workspace_Free> <== NOT EXECUTED
40008b18: 01 00 00 00 nop <== NOT EXECUTED
the_object->name.name_p = NULL;
40008b1c: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
}
strncpy( d, name, length );
40008b20: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40008b24: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40008b28: 40 00 1c 45 call 4000fc3c <strncpy> <== NOT EXECUTED
40008b2c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
d[ length ] = '\0';
40008b30: c0 2c 40 10 clrb [ %l1 + %l0 ] <== NOT EXECUTED
the_object->name.name_p = d;
40008b34: e2 26 60 0c st %l1, [ %i1 + 0xc ] <== NOT EXECUTED
40008b38: 81 c7 e0 08 ret <== NOT EXECUTED
40008b3c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
} else {
the_object->name.name_u32 = _Objects_Build_name(
40008b40: 80 a4 20 00 cmp %l0, 0
40008b44: 02 80 00 1a be 40008bac <_Objects_Set_name+0xe0> <== NEVER TAKEN
40008b48: 1b 08 00 00 sethi %hi(0x20000000), %o5
40008b4c: c2 4e 80 00 ldsb [ %i2 ], %g1
40008b50: 80 a4 20 01 cmp %l0, 1
40008b54: 02 80 00 16 be 40008bac <_Objects_Set_name+0xe0>
40008b58: 9b 28 60 18 sll %g1, 0x18, %o5
40008b5c: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
40008b60: 80 a4 20 02 cmp %l0, 2
40008b64: 08 80 00 0f bleu 40008ba0 <_Objects_Set_name+0xd4>
40008b68: 89 28 60 10 sll %g1, 0x10, %g4
40008b6c: c2 4e a0 02 ldsb [ %i2 + 2 ], %g1
40008b70: 80 a4 20 03 cmp %l0, 3
40008b74: 87 28 60 08 sll %g1, 8, %g3
40008b78: 08 80 00 03 bleu 40008b84 <_Objects_Set_name+0xb8>
40008b7c: 84 10 20 20 mov 0x20, %g2
40008b80: c4 4e a0 03 ldsb [ %i2 + 3 ], %g2
40008b84: 82 13 40 04 or %o5, %g4, %g1
40008b88: b0 10 20 01 mov 1, %i0
40008b8c: 82 10 40 03 or %g1, %g3, %g1
40008b90: 82 10 40 02 or %g1, %g2, %g1
40008b94: c2 26 60 0c st %g1, [ %i1 + 0xc ]
);
}
return TRUE;
}
40008b98: 81 c7 e0 08 ret
40008b9c: 81 e8 00 00 restore
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
40008ba0: 84 10 20 20 mov 0x20, %g2
40008ba4: 10 bf ff f8 b 40008b84 <_Objects_Set_name+0xb8>
40008ba8: 07 00 00 08 sethi %hi(0x2000), %g3
40008bac: 10 bf ff fd b 40008ba0 <_Objects_Set_name+0xd4>
40008bb0: 09 00 08 00 sethi %hi(0x200000), %g4
40006e28 <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
40006e28: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index(
Objects_Id id
)
{
return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS;
40006e2c: c4 06 20 08 ld [ %i0 + 8 ], %g2
/*
* Search the list to find block or chunnk with all objects inactive.
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
40006e30: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
40006e34: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0
40006e38: 03 00 00 3f sethi %hi(0xfc00), %g1
40006e3c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40006e40: 92 10 00 10 mov %l0, %o1
40006e44: a2 08 80 01 and %g2, %g1, %l1
40006e48: 40 00 30 91 call 4001308c <.udiv>
40006e4c: 90 22 00 11 sub %o0, %l1, %o0
40006e50: 10 80 00 2e b 40006f08 <_Objects_Shrink_information+0xe0>
40006e54: 84 10 20 00 clr %g2
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
40006e58: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40006e5c: c2 00 40 12 ld [ %g1 + %l2 ], %g1
40006e60: 80 a0 40 10 cmp %g1, %l0
40006e64: 12 80 00 28 bne 40006f04 <_Objects_Shrink_information+0xdc>
40006e68: 84 00 a0 01 inc %g2
/*
* XXX - Not to sure how to use a chain where you need to iterate and
* and remove elements.
*/
the_object = (Objects_Control *) information->Inactive.first;
40006e6c: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
40006e70: 03 00 00 3f sethi %hi(0xfc00), %g1
40006e74: a6 10 63 ff or %g1, 0x3ff, %l3 ! ffff <PROM_START+0xffff>
40006e78: c2 04 20 08 ld [ %l0 + 8 ], %g1
40006e7c: 84 08 40 13 and %g1, %l3, %g2
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
40006e80: 80 a0 80 11 cmp %g2, %l1
40006e84: 2a 80 00 0c bcs,a 40006eb4 <_Objects_Shrink_information+0x8c>
40006e88: e0 04 00 00 ld [ %l0 ], %l0
40006e8c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40006e90: 82 04 40 01 add %l1, %g1, %g1
40006e94: 80 a0 80 01 cmp %g2, %g1
40006e98: 1a 80 00 06 bcc 40006eb0 <_Objects_Shrink_information+0x88>
40006e9c: 90 10 00 10 mov %l0, %o0
if ( !_Chain_Is_last( &the_object->Node ) )
the_object = (Objects_Control *) the_object->Node.next;
else
the_object = NULL;
_Chain_Extract( &extract_me->Node );
40006ea0: 40 00 0f 8e call 4000acd8 <_Chain_Extract>
40006ea4: e0 04 00 00 ld [ %l0 ], %l0
}
else {
the_object = (Objects_Control *) the_object->Node.next;
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
40006ea8: 10 80 00 04 b 40006eb8 <_Objects_Shrink_information+0x90>
40006eac: 80 a4 20 00 cmp %l0, 0
the_object = NULL;
_Chain_Extract( &extract_me->Node );
}
else {
the_object = (Objects_Control *) the_object->Node.next;
40006eb0: e0 04 00 00 ld [ %l0 ], %l0
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
40006eb4: 80 a4 20 00 cmp %l0, 0
40006eb8: 22 80 00 07 be,a 40006ed4 <_Objects_Shrink_information+0xac><== NEVER TAKEN
40006ebc: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
40006ec0: c2 04 00 00 ld [ %l0 ], %g1
40006ec4: 80 a0 60 00 cmp %g1, 0
40006ec8: 32 bf ff ed bne,a 40006e7c <_Objects_Shrink_information+0x54>
40006ecc: c2 04 20 08 ld [ %l0 + 8 ], %g1
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
40006ed0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40006ed4: 40 00 06 a1 call 40008958 <_Workspace_Free>
40006ed8: d0 00 40 12 ld [ %g1 + %l2 ], %o0
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
40006edc: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
information->inactive -= information->allocation_size;
40006ee0: c2 16 20 2c lduh [ %i0 + 0x2c ], %g1
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
40006ee4: c0 20 80 12 clr [ %g2 + %l2 ]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
40006ee8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
40006eec: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
40006ef0: c0 20 80 12 clr [ %g2 + %l2 ]
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
40006ef4: 82 20 40 03 sub %g1, %g3, %g1
40006ef8: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
40006efc: 81 c7 e0 08 ret
40006f00: 81 e8 00 00 restore
return;
}
index_base += information->allocation_size;
40006f04: a2 04 40 10 add %l1, %l0, %l1
*/
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
40006f08: 80 a0 80 08 cmp %g2, %o0
40006f0c: 0a bf ff d3 bcs 40006e58 <_Objects_Shrink_information+0x30>
40006f10: a5 28 a0 02 sll %g2, 2, %l2
40006f14: 81 c7 e0 08 ret
40006f18: 81 e8 00 00 restore
4000a538 <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
4000a538: 9d e3 bf 98 save %sp, -104, %sp
Heap_Get_information_status status;
if ( !the_heap )
4000a53c: 80 a6 20 00 cmp %i0, 0
4000a540: 02 80 00 10 be 4000a580 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
4000a544: 80 a6 60 00 cmp %i1, 0
return false;
if ( !the_info )
4000a548: 02 80 00 0e be 4000a580 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
4000a54c: 23 10 00 77 sethi %hi(0x4001dc00), %l1
return false;
_RTEMS_Lock_allocator();
4000a550: 7f ff f9 87 call 40008b6c <_API_Mutex_Lock>
4000a554: d0 04 60 88 ld [ %l1 + 0x88 ], %o0 ! 4001dc88 <_RTEMS_Allocator_Mutex>
status = _Heap_Get_information( the_heap, the_info );
4000a558: 90 10 00 18 mov %i0, %o0
4000a55c: 40 00 10 22 call 4000e5e4 <_Heap_Get_information>
4000a560: 92 10 00 19 mov %i1, %o1
4000a564: a0 10 00 08 mov %o0, %l0
_RTEMS_Unlock_allocator();
4000a568: 7f ff f9 97 call 40008bc4 <_API_Mutex_Unlock>
4000a56c: d0 04 60 88 ld [ %l1 + 0x88 ], %o0
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
4000a570: 80 a0 00 10 cmp %g0, %l0
4000a574: 82 60 3f ff subx %g0, -1, %g1
4000a578: 81 c7 e0 08 ret
4000a57c: 91 e8 00 01 restore %g0, %g1, %o0
return true;
return false;
}
4000a580: 81 c7 e0 08 ret
4000a584: 91 e8 20 00 restore %g0, 0, %o0
4000ab54 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
4000ab54: 9d e3 bf 98 save %sp, -104, %sp
/*
* Notepads must be the last entry in the structure and they
* can be left off if disabled in the configuration.
*/
to_allocate = sizeof( RTEMS_API_Control );
if ( !rtems_configuration_get_notepads_enabled() )
4000ab58: 21 10 00 5f sethi %hi(0x40017c00), %l0
4000ab5c: c2 04 23 68 ld [ %l0 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
4000ab60: b0 10 20 00 clr %i0
/*
* Notepads must be the last entry in the structure and they
* can be left off if disabled in the configuration.
*/
to_allocate = sizeof( RTEMS_API_Control );
if ( !rtems_configuration_get_notepads_enabled() )
4000ab64: c2 00 60 40 ld [ %g1 + 0x40 ], %g1
4000ab68: c2 08 60 04 ldub [ %g1 + 4 ], %g1
4000ab6c: 80 a0 00 01 cmp %g0, %g1
4000ab70: 90 60 20 00 subx %g0, 0, %o0
4000ab74: 90 0a 20 40 and %o0, 0x40, %o0
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
4000ab78: 7f ff f7 7f call 40008974 <_Workspace_Allocate>
4000ab7c: 90 02 20 20 add %o0, 0x20, %o0
if ( !api )
4000ab80: 80 a2 20 00 cmp %o0, 0
4000ab84: 02 80 00 17 be 4000abe0 <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN
4000ab88: c2 04 23 68 ld [ %l0 + 0x368 ], %g1
created->API_Extensions[ THREAD_API_RTEMS ] = api;
api->pending_events = EVENT_SETS_NONE_PENDING;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
4000ab8c: c0 26 61 6c clr [ %i1 + 0x16c ]
if ( rtems_configuration_get_notepads_enabled() ) {
4000ab90: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = true;
4000ab94: 82 10 20 01 mov 1, %g1
4000ab98: c2 2a 20 08 stb %g1, [ %o0 + 8 ]
4000ab9c: c2 08 a0 04 ldub [ %g2 + 4 ], %g1
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
4000aba0: d0 26 61 5c st %o0, [ %i1 + 0x15c ]
api->pending_events = EVENT_SETS_NONE_PENDING;
4000aba4: c0 22 00 00 clr [ %o0 ]
information->handler = NULL;
4000aba8: c0 22 20 0c clr [ %o0 + 0xc ]
information->mode_set = RTEMS_DEFAULT_MODES;
4000abac: c0 22 20 10 clr [ %o0 + 0x10 ]
information->signals_posted = 0;
4000abb0: c0 22 20 14 clr [ %o0 + 0x14 ]
information->signals_pending = 0;
4000abb4: c0 22 20 18 clr [ %o0 + 0x18 ]
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
4000abb8: 80 a0 60 00 cmp %g1, 0
4000abbc: 02 80 00 08 be 4000abdc <_RTEMS_tasks_Create_extension+0x88>
4000abc0: c0 22 20 1c clr [ %o0 + 0x1c ]
4000abc4: 84 10 20 00 clr %g2
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
4000abc8: 82 02 00 02 add %o0, %g2, %g1
4000abcc: 84 00 a0 04 add %g2, 4, %g2
api->pending_events = EVENT_SETS_NONE_PENDING;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
4000abd0: 80 a0 a0 40 cmp %g2, 0x40
4000abd4: 12 bf ff fd bne 4000abc8 <_RTEMS_tasks_Create_extension+0x74>
4000abd8: c0 20 60 20 clr [ %g1 + 0x20 ]
4000abdc: b0 10 20 01 mov 1, %i0
api->Notepads[i] = 0;
}
return true;
}
4000abe0: 81 c7 e0 08 ret
4000abe4: 81 e8 00 00 restore
400057c4 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
400057c4: 9d e3 bf 90 save %sp, -112, %sp
rtems_status_code return_value;
rtems_initialization_tasks_table *user_tasks;
rtems_api_configuration_table *api_configuration;
api_configuration = _Configuration_Table->RTEMS_api_configuration;
400057c8: 03 10 00 5f sethi %hi(0x40017c00), %g1
400057cc: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
400057d0: c2 00 60 40 ld [ %g1 + 0x40 ], %g1
/*
* NOTE: This is slightly different from the Ada implementation.
*/
user_tasks = api_configuration->User_initialization_tasks_table;
400057d4: d0 00 60 2c ld [ %g1 + 0x2c ], %o0
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
400057d8: 80 a2 20 00 cmp %o0, 0
400057dc: 02 80 00 20 be 4000585c <_RTEMS_tasks_Initialize_user_tasks_body+0x98><== NEVER TAKEN
400057e0: e4 00 60 28 ld [ %g1 + 0x28 ], %l2
400057e4: 80 a4 a0 00 cmp %l2, 0
400057e8: 02 80 00 1d be 4000585c <_RTEMS_tasks_Initialize_user_tasks_body+0x98><== NEVER TAKEN
400057ec: a0 10 00 08 mov %o0, %l0
return;
400057f0: a2 10 20 00 clr %l1
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
400057f4: 10 80 00 17 b 40005850 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c>
400057f8: a6 07 bf f4 add %fp, -12, %l3
400057fc: d2 04 20 08 ld [ %l0 + 8 ], %o1
40005800: d4 04 20 04 ld [ %l0 + 4 ], %o2
40005804: d6 04 20 14 ld [ %l0 + 0x14 ], %o3
40005808: d8 04 20 0c ld [ %l0 + 0xc ], %o4
4000580c: 7f ff ff 6a call 400055b4 <rtems_task_create>
40005810: 9a 10 00 13 mov %l3, %o5
user_tasks[ index ].mode_set,
user_tasks[ index ].attribute_set,
&id
);
if ( !rtems_is_status_successful( return_value ) )
40005814: 80 a2 20 00 cmp %o0, 0
40005818: 12 80 00 0b bne 40005844 <_RTEMS_tasks_Initialize_user_tasks_body+0x80>
4000581c: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
return_value = rtems_task_start(
40005820: d2 04 20 10 ld [ %l0 + 0x10 ], %o1
40005824: d4 04 20 18 ld [ %l0 + 0x18 ], %o2
40005828: d0 07 bf f4 ld [ %fp + -12 ], %o0
4000582c: 40 00 00 0e call 40005864 <rtems_task_start>
40005830: a0 04 20 1c add %l0, 0x1c, %l0
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
40005834: 80 a2 20 00 cmp %o0, 0
40005838: 22 80 00 06 be,a 40005850 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c>
4000583c: a2 04 60 01 inc %l1
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
40005840: 94 10 00 08 mov %o0, %o2
40005844: 92 10 20 01 mov 1, %o1
40005848: 40 00 03 61 call 400065cc <_Internal_error_Occurred>
4000584c: 90 10 20 01 mov 1, %o0
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
return;
for ( index=0 ; index < maximum ; index++ ) {
40005850: 80 a4 40 12 cmp %l1, %l2
40005854: 2a bf ff ea bcs,a 400057fc <_RTEMS_tasks_Initialize_user_tasks_body+0x38>
40005858: d0 04 00 00 ld [ %l0 ], %o0
4000585c: 81 c7 e0 08 ret
40005860: 81 e8 00 00 restore
4000aa90 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
4000aa90: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_API_Control *api;
ASR_Information *asr;
rtems_signal_set signal_set;
Modes_Control prev_mode;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4000aa94: f0 06 21 5c ld [ %i0 + 0x15c ], %i0
if ( !api )
4000aa98: 80 a6 20 00 cmp %i0, 0
4000aa9c: 02 80 00 1d be 4000ab10 <_RTEMS_tasks_Post_switch_extension+0x80><== NEVER TAKEN
4000aaa0: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
4000aaa4: 7f ff dc 8e call 40001cdc <sparc_disable_interrupts>
4000aaa8: 01 00 00 00 nop
signal_set = asr->signals_posted;
4000aaac: e4 06 20 14 ld [ %i0 + 0x14 ], %l2
asr->signals_posted = 0;
4000aab0: c0 26 20 14 clr [ %i0 + 0x14 ]
_ISR_Enable( level );
4000aab4: 7f ff dc 8e call 40001cec <sparc_enable_interrupts>
4000aab8: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
4000aabc: 80 a4 a0 00 cmp %l2, 0
4000aac0: 02 80 00 14 be 4000ab10 <_RTEMS_tasks_Post_switch_extension+0x80><== NEVER TAKEN
4000aac4: a2 07 bf f4 add %fp, -12, %l1
return;
asr->nest_level += 1;
4000aac8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000aacc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
4000aad0: 82 00 60 01 inc %g1
4000aad4: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000aad8: 94 10 00 11 mov %l1, %o2
4000aadc: 21 00 00 3f sethi %hi(0xfc00), %l0
4000aae0: 40 00 04 43 call 4000bbec <rtems_task_mode>
4000aae4: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff <PROM_START+0xffff>
(*asr->handler)( signal_set );
4000aae8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000aaec: 9f c0 40 00 call %g1
4000aaf0: 90 10 00 12 mov %l2, %o0
asr->nest_level -= 1;
4000aaf4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000aaf8: d0 07 bf f4 ld [ %fp + -12 ], %o0
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
4000aafc: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000ab00: 92 14 23 ff or %l0, 0x3ff, %o1
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
(*asr->handler)( signal_set );
asr->nest_level -= 1;
4000ab04: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
4000ab08: 40 00 04 39 call 4000bbec <rtems_task_mode>
4000ab0c: 94 10 00 11 mov %l1, %o2
4000ab10: 81 c7 e0 08 ret
4000ab14: 81 e8 00 00 restore
40006a64 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
40006a64: 9d e3 bf 90 save %sp, -112, %sp
40006a68: 11 10 00 72 sethi %hi(0x4001c800), %o0
40006a6c: 92 10 00 18 mov %i0, %o1
40006a70: 90 12 20 24 or %o0, 0x24, %o0
40006a74: 40 00 07 9c call 400088e4 <_Objects_Get>
40006a78: 94 07 bf f4 add %fp, -12, %o2
/*
* 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 ) {
40006a7c: c2 07 bf f4 ld [ %fp + -12 ], %g1
40006a80: 80 a0 60 00 cmp %g1, 0
40006a84: 12 80 00 26 bne 40006b1c <_Rate_monotonic_Timeout+0xb8> <== NEVER TAKEN
40006a88: b0 10 00 08 mov %o0, %i0
case OBJECTS_LOCAL:
the_thread = the_period->owner;
40006a8c: d0 02 20 50 ld [ %o0 + 0x50 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
40006a90: 03 00 00 10 sethi %hi(0x4000), %g1
40006a94: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40006a98: 80 88 80 01 btst %g2, %g1
40006a9c: 22 80 00 0c be,a 40006acc <_Rate_monotonic_Timeout+0x68>
40006aa0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
40006aa4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
40006aa8: c2 06 20 08 ld [ %i0 + 8 ], %g1
40006aac: 80 a0 80 01 cmp %g2, %g1
40006ab0: 32 80 00 07 bne,a 40006acc <_Rate_monotonic_Timeout+0x68><== NEVER TAKEN
40006ab4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
40006ab8: 13 04 00 ff sethi %hi(0x1003fc00), %o1
40006abc: 40 00 08 e2 call 40008e44 <_Thread_Clear_state>
40006ac0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
40006ac4: 10 80 00 08 b 40006ae4 <_Rate_monotonic_Timeout+0x80>
40006ac8: 90 10 00 18 mov %i0, %o0
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
40006acc: 80 a0 60 01 cmp %g1, 1
40006ad0: 12 80 00 0e bne 40006b08 <_Rate_monotonic_Timeout+0xa4> <== ALWAYS TAKEN
40006ad4: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
40006ad8: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
40006adc: 90 10 00 18 mov %i0, %o0 <== 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;
40006ae0: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
40006ae4: 7f ff fe 4a call 4000640c <_Rate_monotonic_Initiate_statistics>
40006ae8: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006aec: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006af0: 92 06 20 10 add %i0, 0x10, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006af4: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006af8: 11 10 00 72 sethi %hi(0x4001c800), %o0
40006afc: 40 00 0f 09 call 4000a720 <_Watchdog_Insert>
40006b00: 90 12 22 80 or %o0, 0x280, %o0 ! 4001ca80 <_Watchdog_Ticks_chain>
40006b04: 30 80 00 02 b,a 40006b0c <_Rate_monotonic_Timeout+0xa8>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
40006b08: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
40006b0c: 05 10 00 72 sethi %hi(0x4001c800), %g2
40006b10: c2 00 a1 a0 ld [ %g2 + 0x1a0 ], %g1 ! 4001c9a0 <_Thread_Dispatch_disable_level>
40006b14: 82 00 7f ff add %g1, -1, %g1
40006b18: c2 20 a1 a0 st %g1, [ %g2 + 0x1a0 ]
40006b1c: 81 c7 e0 08 ret
40006b20: 81 e8 00 00 restore
40006150 <_TOD_Validate>:
*/
bool _TOD_Validate(
rtems_time_of_day *the_tod
)
{
40006150: 9d e3 bf 98 save %sp, -104, %sp
uint32_t days_in_month;
if ((!the_tod) ||
40006154: 80 a6 20 00 cmp %i0, 0
40006158: 02 80 00 30 be 40006218 <_TOD_Validate+0xc8> <== NEVER TAKEN
4000615c: 03 10 00 91 sethi %hi(0x40024400), %g1
40006160: d2 00 61 50 ld [ %g1 + 0x150 ], %o1 ! 40024550 <_TOD_Microseconds_per_tick>
40006164: 11 00 03 d0 sethi %hi(0xf4000), %o0
40006168: 40 00 41 cb call 40016894 <.udiv>
4000616c: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
40006170: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40006174: 80 a0 40 08 cmp %g1, %o0
40006178: 1a 80 00 28 bcc 40006218 <_TOD_Validate+0xc8>
4000617c: 01 00 00 00 nop
40006180: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40006184: 80 a0 60 3b cmp %g1, 0x3b
40006188: 18 80 00 24 bgu 40006218 <_TOD_Validate+0xc8>
4000618c: 01 00 00 00 nop
40006190: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40006194: 80 a0 60 3b cmp %g1, 0x3b
40006198: 18 80 00 20 bgu 40006218 <_TOD_Validate+0xc8>
4000619c: 01 00 00 00 nop
400061a0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400061a4: 80 a0 60 17 cmp %g1, 0x17
400061a8: 18 80 00 1c bgu 40006218 <_TOD_Validate+0xc8>
400061ac: 01 00 00 00 nop
400061b0: c4 06 20 04 ld [ %i0 + 4 ], %g2
400061b4: 80 a0 a0 00 cmp %g2, 0
400061b8: 02 80 00 18 be 40006218 <_TOD_Validate+0xc8> <== NEVER TAKEN
400061bc: 80 a0 a0 0c cmp %g2, 0xc
400061c0: 18 80 00 16 bgu 40006218 <_TOD_Validate+0xc8>
400061c4: 01 00 00 00 nop
400061c8: c2 06 00 00 ld [ %i0 ], %g1
400061cc: 80 a0 67 c3 cmp %g1, 0x7c3
400061d0: 08 80 00 12 bleu 40006218 <_TOD_Validate+0xc8>
400061d4: 01 00 00 00 nop
400061d8: f0 06 20 08 ld [ %i0 + 8 ], %i0
400061dc: 80 a6 20 00 cmp %i0, 0
400061e0: 02 80 00 0e be 40006218 <_TOD_Validate+0xc8> <== NEVER TAKEN
400061e4: 80 88 60 03 btst 3, %g1
400061e8: 03 10 00 68 sethi %hi(0x4001a000), %g1
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
400061ec: 12 80 00 05 bne 40006200 <_TOD_Validate+0xb0>
400061f0: 86 10 62 e8 or %g1, 0x2e8, %g3 ! 4001a2e8 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
400061f4: 82 00 a0 0d add %g2, 0xd, %g1
400061f8: 10 80 00 03 b 40006204 <_TOD_Validate+0xb4>
400061fc: 83 28 60 02 sll %g1, 2, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
40006200: 83 28 a0 02 sll %g2, 2, %g1
40006204: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
40006208: 80 a0 40 18 cmp %g1, %i0
4000620c: 82 60 3f ff subx %g0, -1, %g1
40006210: 81 c7 e0 08 ret
40006214: 91 e8 00 01 restore %g0, %g1, %o0
if ( the_tod->day > days_in_month )
return false;
return true;
}
40006218: 81 c7 e0 08 ret
4000621c: 91 e8 20 00 restore %g0, 0, %o0
40006f70 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
40006f70: 9d e3 bf 98 save %sp, -104, %sp
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
40006f74: e2 06 20 10 ld [ %i0 + 0x10 ], %l1
/*
* 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 );
40006f78: 40 00 04 30 call 40008038 <_Thread_Set_transient>
40006f7c: 90 10 00 18 mov %i0, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
40006f80: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
40006f84: a0 10 00 18 mov %i0, %l0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
40006f88: 80 a0 40 19 cmp %g1, %i1
40006f8c: 02 80 00 04 be 40006f9c <_Thread_Change_priority+0x2c>
40006f90: 92 10 00 19 mov %i1, %o1
_Thread_Set_priority( the_thread, new_priority );
40006f94: 40 00 03 ad call 40007e48 <_Thread_Set_priority>
40006f98: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
40006f9c: 7f ff eb 50 call 40001cdc <sparc_disable_interrupts>
40006fa0: 01 00 00 00 nop
40006fa4: b0 10 00 08 mov %o0, %i0
/*
* 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;
40006fa8: f2 04 20 10 ld [ %l0 + 0x10 ], %i1
if ( state != STATES_TRANSIENT ) {
40006fac: 80 a6 60 04 cmp %i1, 4
40006fb0: 02 80 00 10 be 40006ff0 <_Thread_Change_priority+0x80>
40006fb4: 82 0c 60 04 and %l1, 4, %g1
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
40006fb8: 80 a0 60 00 cmp %g1, 0
40006fbc: 12 80 00 03 bne 40006fc8 <_Thread_Change_priority+0x58> <== NEVER TAKEN
40006fc0: 82 0e 7f fb and %i1, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
40006fc4: c2 24 20 10 st %g1, [ %l0 + 0x10 ]
_ISR_Enable( level );
40006fc8: 7f ff eb 49 call 40001cec <sparc_enable_interrupts>
40006fcc: 90 10 00 18 mov %i0, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
40006fd0: 03 00 00 ef sethi %hi(0x3bc00), %g1
40006fd4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
40006fd8: 80 8e 40 01 btst %i1, %g1
40006fdc: 02 80 00 5b be 40007148 <_Thread_Change_priority+0x1d8>
40006fe0: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
40006fe4: f0 04 20 44 ld [ %l0 + 0x44 ], %i0
40006fe8: 40 00 03 6b call 40007d94 <_Thread_queue_Requeue>
40006fec: 93 e8 00 10 restore %g0, %l0, %o1
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
40006ff0: 80 a0 60 00 cmp %g1, 0
40006ff4: 12 80 00 1b bne 40007060 <_Thread_Change_priority+0xf0> <== NEVER TAKEN
40006ff8: 09 10 00 5f sethi %hi(0x40017c00), %g4
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
40006ffc: c6 04 20 90 ld [ %l0 + 0x90 ], %g3
40007000: c4 14 20 96 lduh [ %l0 + 0x96 ], %g2
40007004: c2 10 c0 00 lduh [ %g3 ], %g1
40007008: 82 10 40 02 or %g1, %g2, %g1
4000700c: c2 30 c0 00 sth %g1, [ %g3 ]
_Priority_Major_bit_map |= the_priority_map->ready_major;
40007010: c4 11 23 84 lduh [ %g4 + 0x384 ], %g2
40007014: c2 14 20 94 lduh [ %l0 + 0x94 ], %g1
* 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 );
40007018: c0 24 20 10 clr [ %l0 + 0x10 ]
4000701c: 82 10 40 02 or %g1, %g2, %g1
40007020: c2 31 23 84 sth %g1, [ %g4 + 0x384 ]
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
40007024: 80 8e a0 ff btst 0xff, %i2
40007028: 02 80 00 08 be 40007048 <_Thread_Change_priority+0xd8>
4000702c: c4 04 20 8c ld [ %l0 + 0x8c ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40007030: c2 00 80 00 ld [ %g2 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
40007034: c4 24 20 04 st %g2, [ %l0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
40007038: e0 20 80 00 st %l0, [ %g2 ]
the_node->next = before_node;
before_node->previous = the_node;
4000703c: e0 20 60 04 st %l0, [ %g1 + 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;
40007040: 10 80 00 08 b 40007060 <_Thread_Change_priority+0xf0>
40007044: c2 24 00 00 st %g1, [ %l0 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
40007048: 82 00 a0 04 add %g2, 4, %g1
4000704c: c2 24 00 00 st %g1, [ %l0 ]
old_last_node = the_chain->last;
40007050: c2 00 a0 08 ld [ %g2 + 8 ], %g1
the_chain->last = the_node;
40007054: e0 20 a0 08 st %l0, [ %g2 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
40007058: c2 24 20 04 st %g1, [ %l0 + 4 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
4000705c: e0 20 40 00 st %l0, [ %g1 ]
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
40007060: 7f ff eb 23 call 40001cec <sparc_enable_interrupts>
40007064: 90 10 00 18 mov %i0, %o0
40007068: 7f ff eb 1d call 40001cdc <sparc_disable_interrupts>
4000706c: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_highest( void )
{
Priority_Bit_map_control minor;
Priority_Bit_map_control major;
_Bitfield_Find_first_bit( _Priority_Major_bit_map, major );
40007070: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007074: c2 10 63 84 lduh [ %g1 + 0x384 ], %g1 ! 40017f84 <_Priority_Major_bit_map>
40007078: 05 10 00 59 sethi %hi(0x40016400), %g2
4000707c: 89 28 60 10 sll %g1, 0x10, %g4
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
40007080: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007084: da 00 62 24 ld [ %g1 + 0x224 ], %o5 ! 40017e24 <_Thread_Ready_chain>
40007088: 83 31 20 10 srl %g4, 0x10, %g1
4000708c: 80 a0 60 ff cmp %g1, 0xff
40007090: 18 80 00 05 bgu 400070a4 <_Thread_Change_priority+0x134>
40007094: 86 10 a0 88 or %g2, 0x88, %g3
40007098: c2 08 c0 01 ldub [ %g3 + %g1 ], %g1
4000709c: 10 80 00 04 b 400070ac <_Thread_Change_priority+0x13c>
400070a0: 88 00 60 08 add %g1, 8, %g4
400070a4: 83 31 20 18 srl %g4, 0x18, %g1
400070a8: c8 08 c0 01 ldub [ %g3 + %g1 ], %g4
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
400070ac: 83 29 20 10 sll %g4, 0x10, %g1
400070b0: 05 10 00 60 sethi %hi(0x40018000), %g2
400070b4: 83 30 60 0f srl %g1, 0xf, %g1
400070b8: 84 10 a0 00 mov %g2, %g2
400070bc: c2 10 80 01 lduh [ %g2 + %g1 ], %g1
400070c0: 05 10 00 59 sethi %hi(0x40016400), %g2
400070c4: 83 28 60 10 sll %g1, 0x10, %g1
400070c8: 86 10 a0 88 or %g2, 0x88, %g3
400070cc: 85 30 60 10 srl %g1, 0x10, %g2
400070d0: 80 a0 a0 ff cmp %g2, 0xff
400070d4: 38 80 00 05 bgu,a 400070e8 <_Thread_Change_priority+0x178>
400070d8: 83 30 60 18 srl %g1, 0x18, %g1
400070dc: c2 08 c0 02 ldub [ %g3 + %g2 ], %g1
400070e0: 10 80 00 03 b 400070ec <_Thread_Change_priority+0x17c>
400070e4: 82 00 60 08 add %g1, 8, %g1
400070e8: c2 08 c0 01 ldub [ %g3 + %g1 ], %g1
400070ec: 85 29 20 10 sll %g4, 0x10, %g2
400070f0: 85 30 a0 0c srl %g2, 0xc, %g2
400070f4: 83 28 60 10 sll %g1, 0x10, %g1
400070f8: 83 30 60 10 srl %g1, 0x10, %g1
400070fc: 82 00 40 02 add %g1, %g2, %g1
40007100: 85 28 60 04 sll %g1, 4, %g2
40007104: 83 28 60 02 sll %g1, 2, %g1
40007108: 84 20 80 01 sub %g2, %g1, %g2
4000710c: c4 03 40 02 ld [ %o5 + %g2 ], %g2
* is also the heir thread, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
40007110: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007114: c6 00 63 90 ld [ %g1 + 0x390 ], %g3 ! 40017f90 <_Thread_Executing>
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
40007118: 03 10 00 5f sethi %hi(0x40017c00), %g1
* We altered the set of thread priorities. So let's figure out
* who is the heir and if we need to switch to them.
*/
_Thread_Calculate_heir();
if ( !_Thread_Is_executing_also_the_heir() &&
4000711c: 80 a0 c0 02 cmp %g3, %g2
40007120: 02 80 00 08 be 40007140 <_Thread_Change_priority+0x1d0>
40007124: c4 20 63 5c st %g2, [ %g1 + 0x35c ]
40007128: c2 08 e0 76 ldub [ %g3 + 0x76 ], %g1
4000712c: 80 a0 60 00 cmp %g1, 0
40007130: 02 80 00 04 be 40007140 <_Thread_Change_priority+0x1d0>
40007134: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
40007138: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000713c: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ] ! 40017fa0 <_Context_Switch_necessary>
_ISR_Enable( level );
40007140: 7f ff ea eb call 40001cec <sparc_enable_interrupts>
40007144: 81 e8 00 00 restore
40007148: 81 c7 e0 08 ret
4000714c: 81 e8 00 00 restore
40007150 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
40007150: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
40007154: 7f ff ea e2 call 40001cdc <sparc_disable_interrupts>
40007158: a0 10 00 19 mov %i1, %l0
4000715c: a2 10 00 08 mov %o0, %l1
current_state = the_thread->current_state;
40007160: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
if ( current_state & state ) {
40007164: 80 8c 00 19 btst %l0, %i1
40007168: 02 80 00 2c be 40007218 <_Thread_Clear_state+0xc8>
4000716c: 82 2e 40 10 andn %i1, %l0, %g1
current_state =
the_thread->current_state = _States_Clear( state, current_state );
if ( _States_Is_ready( current_state ) ) {
40007170: 80 a0 60 00 cmp %g1, 0
40007174: 12 80 00 29 bne 40007218 <_Thread_Clear_state+0xc8>
40007178: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
4000717c: c8 06 20 90 ld [ %i0 + 0x90 ], %g4
40007180: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2
40007184: c2 11 00 00 lduh [ %g4 ], %g1
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
40007188: c6 06 20 8c ld [ %i0 + 0x8c ], %g3
4000718c: 82 10 40 02 or %g1, %g2, %g1
40007190: c2 31 00 00 sth %g1, [ %g4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
40007194: 82 00 e0 04 add %g3, 4, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
40007198: 1b 10 00 5f sethi %hi(0x40017c00), %o5
4000719c: c2 26 00 00 st %g1, [ %i0 ]
400071a0: c4 16 20 94 lduh [ %i0 + 0x94 ], %g2
old_last_node = the_chain->last;
400071a4: c2 00 e0 08 ld [ %g3 + 8 ], %g1
400071a8: c8 13 63 84 lduh [ %o5 + 0x384 ], %g4
the_chain->last = the_node;
400071ac: f0 20 e0 08 st %i0, [ %g3 + 8 ]
400071b0: 84 10 80 04 or %g2, %g4, %g2
old_last_node->next = the_node;
the_node->previous = old_last_node;
400071b4: c2 26 20 04 st %g1, [ %i0 + 4 ]
400071b8: c4 33 63 84 sth %g2, [ %o5 + 0x384 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
400071bc: f0 20 40 00 st %i0, [ %g1 ]
_ISR_Flash( level );
400071c0: 7f ff ea cb call 40001cec <sparc_enable_interrupts>
400071c4: 01 00 00 00 nop
400071c8: 7f ff ea c5 call 40001cdc <sparc_disable_interrupts>
400071cc: 01 00 00 00 nop
* a context switch.
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
400071d0: 07 10 00 5f sethi %hi(0x40017c00), %g3
400071d4: c2 00 e3 5c ld [ %g3 + 0x35c ], %g1 ! 40017f5c <_Thread_Heir>
400071d8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400071dc: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400071e0: 80 a0 80 01 cmp %g2, %g1
400071e4: 1a 80 00 0d bcc 40007218 <_Thread_Clear_state+0xc8>
400071e8: 03 10 00 5f sethi %hi(0x40017c00), %g1
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
400071ec: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
* Pseudo-ISR case:
* Even if the thread isn't preemptible, if the new heir is
* a pseudo-ISR system task, we need to do a context switch.
*/
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
400071f0: f0 20 e3 5c st %i0, [ %g3 + 0x35c ]
if ( _Thread_Executing->is_preemptible ||
400071f4: c2 08 60 76 ldub [ %g1 + 0x76 ], %g1
400071f8: 80 a0 60 00 cmp %g1, 0
400071fc: 32 80 00 05 bne,a 40007210 <_Thread_Clear_state+0xc0>
40007200: 84 10 20 01 mov 1, %g2
40007204: 80 a0 a0 00 cmp %g2, 0
40007208: 12 80 00 04 bne 40007218 <_Thread_Clear_state+0xc8> <== ALWAYS TAKEN
4000720c: 84 10 20 01 mov 1, %g2
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
40007210: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007214: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ] ! 40017fa0 <_Context_Switch_necessary>
}
}
}
_ISR_Enable( level );
40007218: 7f ff ea b5 call 40001cec <sparc_enable_interrupts>
4000721c: 91 e8 00 11 restore %g0, %l1, %o0
400072dc <_Thread_Create_idle>:
*
* _Thread_Create_idle
*/
void _Thread_Create_idle( void )
{
400072dc: 9d e3 bf 78 save %sp, -136, %sp
* This routine allocates an internal thread.
*/
RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_Thread_Internal_information );
400072e0: 11 10 00 60 sethi %hi(0x40018000), %o0
400072e4: 7f ff fc e9 call 40006688 <_Objects_Allocate>
400072e8: 90 12 20 30 or %o0, 0x30, %o0 ! 40018030 <_Thread_Internal_information>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
400072ec: 05 10 00 5f sethi %hi(0x40017c00), %g2
400072f0: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
/*
* The entire workspace is zeroed during its initialization. Thus, all
* fields not explicitly assigned were explicitly zeroed by
* _Workspace_Initialization.
*/
_Thread_Idle = _Thread_Internal_allocate();
400072f4: 07 10 00 60 sethi %hi(0x40018000), %g3
400072f8: 82 00 60 01 inc %g1
400072fc: d0 20 e0 7c st %o0, [ %g3 + 0x7c ]
40007300: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
* that when _Thread_Initialize unnests dispatch that we do not
* do anything stupid.
*/
_Thread_Disable_dispatch();
_Thread_Initialize(
40007304: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007308: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
4000730c: d2 00 e0 7c ld [ %g3 + 0x7c ], %o1
40007310: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40007314: 03 10 00 5c sethi %hi(0x40017000), %g1
40007318: d6 00 62 00 ld [ %g1 + 0x200 ], %o3 ! 40017200 <rtems_minimum_stack_size>
4000731c: 03 10 00 59 sethi %hi(0x40016400), %g1
40007320: 82 10 62 00 or %g1, 0x200, %g1 ! 40016600 <C.26.3565+0x14>
40007324: 80 a2 c0 02 cmp %o3, %g2
40007328: 1a 80 00 03 bcc 40007334 <_Thread_Create_idle+0x58> <== ALWAYS TAKEN
4000732c: c2 27 bf f4 st %g1, [ %fp + -12 ]
40007330: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED
40007334: 03 10 00 5c sethi %hi(0x40017000), %g1
40007338: da 08 62 04 ldub [ %g1 + 0x204 ], %o5 ! 40017204 <rtems_maximum_priority>
4000733c: 82 10 20 01 mov 1, %g1
40007340: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40007344: 82 07 bf f4 add %fp, -12, %g1
40007348: c0 23 a0 60 clr [ %sp + 0x60 ]
4000734c: c0 23 a0 64 clr [ %sp + 0x64 ]
40007350: c0 23 a0 68 clr [ %sp + 0x68 ]
40007354: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
40007358: 94 10 20 00 clr %o2
4000735c: 98 10 20 00 clr %o4
40007360: 11 10 00 60 sethi %hi(0x40018000), %o0
40007364: 40 00 00 af call 40007620 <_Thread_Initialize>
40007368: 90 12 20 30 or %o0, 0x30, %o0 ! 40018030 <_Thread_Internal_information>
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
_Thread_Executing = _Thread_Idle;
_Thread_Start(
4000736c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007370: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
40007374: 07 10 00 5f sethi %hi(0x40017c00), %g3
40007378: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
4000737c: c2 00 e2 d0 ld [ %g3 + 0x2d0 ], %g1
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
40007380: 05 10 00 60 sethi %hi(0x40018000), %g2
40007384: 82 00 7f ff add %g1, -1, %g1
40007388: c4 00 a0 7c ld [ %g2 + 0x7c ], %g2
4000738c: c2 20 e2 d0 st %g1, [ %g3 + 0x2d0 ]
40007390: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007394: c4 20 63 90 st %g2, [ %g1 + 0x390 ] ! 40017f90 <_Thread_Executing>
40007398: 03 10 00 5f sethi %hi(0x40017c00), %g1
_Thread_Executing = _Thread_Idle;
_Thread_Start(
4000739c: b0 10 00 02 mov %g2, %i0
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
400073a0: c4 20 63 5c st %g2, [ %g1 + 0x35c ]
_Thread_Executing = _Thread_Idle;
_Thread_Start(
400073a4: b2 10 20 00 clr %i1
400073a8: b6 10 20 00 clr %i3
400073ac: 40 00 03 81 call 400081b0 <_Thread_Start>
400073b0: 99 e8 20 00 restore %g0, 0, %o4
400073b8 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored
)
{
400073b8: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
400073bc: 90 10 00 18 mov %i0, %o0
400073c0: 40 00 00 6c call 40007570 <_Thread_Get>
400073c4: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
400073c8: c2 07 bf f4 ld [ %fp + -12 ], %g1
400073cc: 80 a0 60 00 cmp %g1, 0
400073d0: 12 80 00 08 bne 400073f0 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
400073d4: 13 04 00 ff sethi %hi(0x1003fc00), %o1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
400073d8: 7f ff ff 5e call 40007150 <_Thread_Clear_state>
400073dc: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
400073e0: 05 10 00 5f sethi %hi(0x40017c00), %g2
400073e4: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
400073e8: 82 00 7f ff add %g1, -1, %g1
400073ec: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
400073f0: 81 c7 e0 08 ret
400073f4: 81 e8 00 00 restore
400073f8 <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
400073f8: 9d e3 bf 88 save %sp, -120, %sp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
400073fc: 21 10 00 5f sethi %hi(0x40017c00), %l0
40007400: e2 04 23 90 ld [ %l0 + 0x390 ], %l1 ! 40017f90 <_Thread_Executing>
_ISR_Disable( level );
40007404: 7f ff ea 36 call 40001cdc <sparc_disable_interrupts>
40007408: a0 14 23 90 or %l0, 0x390, %l0
while ( _Context_Switch_necessary == TRUE ) {
4000740c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007410: aa 10 63 a0 or %g1, 0x3a0, %l5 ! 40017fa0 <_Context_Switch_necessary>
heir = _Thread_Heir;
40007414: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007418: b2 10 63 5c or %g1, 0x35c, %i1 ! 40017f5c <_Thread_Heir>
#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 )
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000741c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007420: b4 10 62 28 or %g1, 0x228, %i2 ! 40017e28 <_Thread_Ticks_per_timeslice>
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
40007424: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007428: 2d 10 00 5f sethi %hi(0x40017c00), %l6
4000742c: a4 10 63 98 or %g1, 0x398, %l2
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Context_Switch_necessary = FALSE;
_Thread_Executing = heir;
40007430: ae 10 00 10 mov %l0, %l7
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
40007434: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007438: b8 15 a2 d0 or %l6, 0x2d0, %i4
4000743c: b6 10 63 58 or %g1, 0x358, %i3
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
40007440: ba 10 20 01 mov 1, %i5
_ISR_Enable( level );
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
40007444: a8 07 bf f0 add %fp, -16, %l4
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
40007448: 10 80 00 29 b 400074ec <_Thread_Dispatch+0xf4>
4000744c: a6 07 bf e8 add %fp, -24, %l3
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
40007450: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Executing = heir;
#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 )
40007454: c2 04 20 7c ld [ %l0 + 0x7c ], %g1
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
heir = _Thread_Heir;
_Thread_Dispatch_disable_level = 1;
_Context_Switch_necessary = FALSE;
40007458: c0 2d 40 00 clrb [ %l5 ]
_Thread_Executing = heir;
#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 )
4000745c: 80 a0 60 01 cmp %g1, 1
40007460: 12 80 00 04 bne 40007470 <_Thread_Dispatch+0x78>
40007464: e0 25 c0 00 st %l0, [ %l7 ]
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
40007468: c2 06 80 00 ld [ %i2 ], %g1
4000746c: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
_ISR_Enable( level );
40007470: 7f ff ea 1f call 40001cec <sparc_enable_interrupts>
40007474: 01 00 00 00 nop
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
40007478: 40 00 0e 8e call 4000aeb0 <_TOD_Get_uptime>
4000747c: 90 10 00 14 mov %l4, %o0
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
40007480: 90 10 00 12 mov %l2, %o0
40007484: 92 10 00 14 mov %l4, %o1
40007488: 40 00 03 c8 call 400083a8 <_Timespec_Subtract>
4000748c: 94 10 00 13 mov %l3, %o2
_Timespec_Add_to( &executing->cpu_time_used, &ran );
40007490: 92 10 00 13 mov %l3, %o1
40007494: 40 00 03 ad call 40008348 <_Timespec_Add_to>
40007498: 90 04 60 84 add %l1, 0x84, %o0
_Thread_Time_of_last_context_switch = uptime;
4000749c: c2 07 bf f0 ld [ %fp + -16 ], %g1
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
400074a0: c4 06 c0 00 ld [ %i3 ], %g2
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
_Timespec_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
400074a4: c2 24 80 00 st %g1, [ %l2 ]
400074a8: c2 07 bf f4 ld [ %fp + -12 ], %g1
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
400074ac: 90 10 00 11 mov %l1, %o0
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
_Timespec_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
400074b0: c2 24 a0 04 st %g1, [ %l2 + 4 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
400074b4: 80 a0 a0 00 cmp %g2, 0
400074b8: 02 80 00 06 be 400074d0 <_Thread_Dispatch+0xd8> <== NEVER TAKEN
400074bc: 92 10 00 10 mov %l0, %o1
executing->libc_reent = *_Thread_libc_reent;
400074c0: c2 00 80 00 ld [ %g2 ], %g1
400074c4: c2 24 61 58 st %g1, [ %l1 + 0x158 ]
*_Thread_libc_reent = heir->libc_reent;
400074c8: c2 04 21 58 ld [ %l0 + 0x158 ], %g1
400074cc: c2 20 80 00 st %g1, [ %g2 ]
}
_User_extensions_Thread_switch( executing, heir );
400074d0: 40 00 04 64 call 40008660 <_User_extensions_Thread_switch>
400074d4: 01 00 00 00 nop
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
400074d8: 90 04 60 d0 add %l1, 0xd0, %o0
400074dc: 40 00 05 5a call 40008a44 <_CPU_Context_switch>
400074e0: 92 04 20 d0 add %l0, 0xd0, %o1
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
400074e4: 7f ff e9 fe call 40001cdc <sparc_disable_interrupts>
400074e8: e2 05 c0 00 ld [ %l7 ], %l1
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
400074ec: c2 0d 40 00 ldub [ %l5 ], %g1
400074f0: 80 a0 60 00 cmp %g1, 0
400074f4: 32 bf ff d7 bne,a 40007450 <_Thread_Dispatch+0x58>
400074f8: e0 06 40 00 ld [ %i1 ], %l0
executing = _Thread_Executing;
_ISR_Disable( level );
}
_Thread_Dispatch_disable_level = 0;
400074fc: c0 25 a2 d0 clr [ %l6 + 0x2d0 ]
_ISR_Enable( level );
40007500: 7f ff e9 fb call 40001cec <sparc_enable_interrupts>
40007504: 01 00 00 00 nop
if ( _Thread_Do_post_task_switch_extension ||
40007508: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000750c: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 40017f74 <_Thread_Do_post_task_switch_extension>
40007510: 80 a0 60 00 cmp %g1, 0
40007514: 12 80 00 06 bne 4000752c <_Thread_Dispatch+0x134> <== NEVER TAKEN
40007518: 01 00 00 00 nop
4000751c: c2 0c 60 75 ldub [ %l1 + 0x75 ], %g1
40007520: 80 a0 60 00 cmp %g1, 0
40007524: 02 80 00 04 be 40007534 <_Thread_Dispatch+0x13c>
40007528: 01 00 00 00 nop
executing->do_post_task_switch_extension ) {
executing->do_post_task_switch_extension = false;
_API_extensions_Run_postswitch();
4000752c: 7f ff f9 f0 call 40005cec <_API_extensions_Run_postswitch>
40007530: c0 2c 60 75 clrb [ %l1 + 0x75 ]
40007534: 81 c7 e0 08 ret
40007538: 81 e8 00 00 restore
4000bf0c <_Thread_Evaluate_mode>:
bool _Thread_Evaluate_mode( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
4000bf0c: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bf10: c4 00 63 90 ld [ %g1 + 0x390 ], %g2 ! 40017f90 <_Thread_Executing>
if ( !_States_Is_ready( executing->current_state ) ||
4000bf14: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
4000bf18: 80 a0 60 00 cmp %g1, 0
4000bf1c: 32 80 00 0b bne,a 4000bf48 <_Thread_Evaluate_mode+0x3c> <== NEVER TAKEN
4000bf20: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
4000bf24: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bf28: c2 00 63 5c ld [ %g1 + 0x35c ], %g1 ! 40017f5c <_Thread_Heir>
4000bf2c: 80 a0 80 01 cmp %g2, %g1
4000bf30: 02 80 00 0b be 4000bf5c <_Thread_Evaluate_mode+0x50>
4000bf34: 01 00 00 00 nop
4000bf38: c2 08 a0 76 ldub [ %g2 + 0x76 ], %g1
4000bf3c: 80 a0 60 00 cmp %g1, 0
4000bf40: 02 80 00 07 be 4000bf5c <_Thread_Evaluate_mode+0x50> <== NEVER TAKEN
4000bf44: 84 10 20 01 mov 1, %g2
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
4000bf48: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bf4c: 90 10 20 01 mov 1, %o0
4000bf50: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ]
4000bf54: 81 c3 e0 08 retl
4000bf58: 01 00 00 00 nop
return TRUE;
}
return FALSE;
}
4000bf5c: 81 c3 e0 08 retl
4000bf60: 90 10 20 00 clr %o0 ! 0 <PROM_START>
40007570 <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
40007570: 88 10 00 08 mov %o0, %g4
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 ) ) {
40007574: 80 a2 20 00 cmp %o0, 0
40007578: 12 80 00 0a bne 400075a0 <_Thread_Get+0x30>
4000757c: 94 10 00 09 mov %o1, %o2
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40007580: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007584: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 40017ed0 <_Thread_Dispatch_disable_level>
40007588: 84 00 a0 01 inc %g2
4000758c: c4 20 62 d0 st %g2, [ %g1 + 0x2d0 ]
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
40007590: 03 10 00 5f sethi %hi(0x40017c00), %g1
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;
40007594: c0 22 40 00 clr [ %o1 ]
tp = _Thread_Executing;
40007598: 81 c3 e0 08 retl
4000759c: d0 00 63 90 ld [ %g1 + 0x390 ], %o0
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
400075a0: 83 32 20 18 srl %o0, 0x18, %g1
400075a4: 84 08 60 07 and %g1, 7, %g2
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
400075a8: 82 00 bf ff add %g2, -1, %g1
400075ac: 80 a0 60 03 cmp %g1, 3
400075b0: 08 80 00 16 bleu 40007608 <_Thread_Get+0x98>
400075b4: 87 32 20 1b srl %o0, 0x1b, %g3
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
400075b8: 82 10 20 01 mov 1, %g1
400075bc: 10 80 00 09 b 400075e0 <_Thread_Get+0x70>
400075c0: c2 22 80 00 st %g1, [ %o2 ]
goto done;
}
api_information = _Objects_Information_table[ the_api ];
400075c4: 03 10 00 5f sethi %hi(0x40017c00), %g1
400075c8: 82 10 62 30 or %g1, 0x230, %g1 ! 40017e30 <_Objects_Information_table>
400075cc: c2 00 40 02 ld [ %g1 + %g2 ], %g1
if ( !api_information ) {
400075d0: 80 a0 60 00 cmp %g1, 0
400075d4: 32 80 00 05 bne,a 400075e8 <_Thread_Get+0x78>
400075d8: d0 00 60 04 ld [ %g1 + 4 ], %o0
*location = OBJECTS_ERROR;
400075dc: c6 22 80 00 st %g3, [ %o2 ]
400075e0: 81 c3 e0 08 retl
400075e4: 90 10 20 00 clr %o0
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
400075e8: 80 a2 20 00 cmp %o0, 0
400075ec: 12 80 00 04 bne 400075fc <_Thread_Get+0x8c> <== ALWAYS TAKEN
400075f0: 92 10 00 04 mov %g4, %o1
*location = OBJECTS_ERROR;
400075f4: 81 c3 e0 08 retl <== NOT EXECUTED
400075f8: c6 22 80 00 st %g3, [ %o2 ] <== NOT EXECUTED
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
400075fc: 82 13 c0 00 mov %o7, %g1
40007600: 7f ff fd 7c call 40006bf0 <_Objects_Get>
40007604: 9e 10 40 00 mov %g1, %o7
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
40007608: 80 a0 e0 01 cmp %g3, 1
4000760c: 22 bf ff ee be,a 400075c4 <_Thread_Get+0x54>
40007610: 85 28 a0 02 sll %g2, 2, %g2
*location = OBJECTS_ERROR;
40007614: 10 bf ff ea b 400075bc <_Thread_Get+0x4c>
40007618: 82 10 20 01 mov 1, %g1
4000bf64 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
4000bf64: 9d e3 bf 98 save %sp, -104, %sp
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
static char doneConstructors;
char doneCons;
#endif
executing = _Thread_Executing;
4000bf68: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bf6c: e2 00 63 90 ld [ %g1 + 0x390 ], %l1 ! 40017f90 <_Thread_Executing>
/*
* Some CPUs need to tinker with the call frame or registers when the
* thread actually begins to execute for the first time. This is a
* hook point where the port gets a shot at doing whatever it requires.
*/
_Context_Initialization_at_thread_begin();
4000bf70: 3f 10 00 2f sethi %hi(0x4000bc00), %i7
4000bf74: be 17 e3 64 or %i7, 0x364, %i7 ! 4000bf64 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
4000bf78: d0 04 60 b8 ld [ %l1 + 0xb8 ], %o0
_ISR_Set_level(level);
4000bf7c: 7f ff d7 5c call 40001cec <sparc_enable_interrupts>
4000bf80: 91 2a 20 08 sll %o0, 8, %o0
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
4000bf84: 05 10 00 5f sethi %hi(0x40017c00), %g2
doneConstructors = 1;
4000bf88: 82 10 20 01 mov 1, %g1
level = executing->Start.isr_level;
_ISR_Set_level(level);
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
4000bf8c: e0 08 a0 c4 ldub [ %g2 + 0xc4 ], %l0
* Take care that 'begin' extensions get to complete before
* 'switch' extensions can run. This means must keep dispatch
* disabled until all 'begin' extensions complete.
*/
_User_extensions_Thread_begin( executing );
4000bf90: 90 10 00 11 mov %l1, %o0
4000bf94: 7f ff f1 40 call 40008494 <_User_extensions_Thread_begin>
4000bf98: c2 28 a0 c4 stb %g1, [ %g2 + 0xc4 ]
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
4000bf9c: 7f ff ed 68 call 4000753c <_Thread_Enable_dispatch>
4000bfa0: a1 2c 20 18 sll %l0, 0x18, %l0
/*
* _init could be a weak symbol and we SHOULD test it but it isn't
* in any configuration I know of and it generates a warning on every
* RTEMS target configuration. --joel (12 May 2007)
*/
if (!doneCons) /* && (volatile void *)_init) */
4000bfa4: 80 a4 20 00 cmp %l0, 0
4000bfa8: 32 80 00 05 bne,a 4000bfbc <_Thread_Handler+0x58>
4000bfac: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1
{
_init ();
4000bfb0: 40 00 2c 5a call 40017118 <_init>
4000bfb4: 01 00 00 00 nop
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
4000bfb8: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1
4000bfbc: 80 a0 60 01 cmp %g1, 1
4000bfc0: 22 80 00 0d be,a 4000bff4 <_Thread_Handler+0x90> <== NEVER TAKEN
4000bfc4: c2 04 60 9c ld [ %l1 + 0x9c ], %g1 <== NOT EXECUTED
4000bfc8: 2a 80 00 09 bcs,a 4000bfec <_Thread_Handler+0x88> <== ALWAYS TAKEN
4000bfcc: c2 04 60 9c ld [ %l1 + 0x9c ], %g1
4000bfd0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
4000bfd4: 02 80 00 0d be 4000c008 <_Thread_Handler+0xa4> <== NOT EXECUTED
4000bfd8: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
4000bfdc: 12 80 00 14 bne 4000c02c <_Thread_Handler+0xc8> <== NOT EXECUTED
4000bfe0: 01 00 00 00 nop <== NOT EXECUTED
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
4000bfe4: 10 80 00 0d b 4000c018 <_Thread_Handler+0xb4> <== NOT EXECUTED
4000bfe8: c2 04 60 9c ld [ %l1 + 0x9c ], %g1 <== NOT EXECUTED
__main ();
#endif
switch ( executing->Start.prototype ) {
case THREAD_START_NUMERIC:
executing->Wait.return_argument =
4000bfec: 10 80 00 03 b 4000bff8 <_Thread_Handler+0x94>
4000bff0: d0 04 60 a8 ld [ %l1 + 0xa8 ], %o0
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
break;
case THREAD_START_POINTER:
executing->Wait.return_argument =
4000bff4: d0 04 60 a4 ld [ %l1 + 0xa4 ], %o0 <== NOT EXECUTED
4000bff8: 9f c0 40 00 call %g1
4000bffc: 01 00 00 00 nop
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
4000c000: 10 80 00 0b b 4000c02c <_Thread_Handler+0xc8>
4000c004: d0 24 60 28 st %o0, [ %l1 + 0x28 ]
(*(Thread_Entry_pointer) executing->Start.entry_point)(
executing->Start.pointer_argument
);
break;
case THREAD_START_BOTH_POINTER_FIRST:
executing->Wait.return_argument =
4000c008: c2 04 60 9c ld [ %l1 + 0x9c ], %g1 <== NOT EXECUTED
4000c00c: d0 04 60 a4 ld [ %l1 + 0xa4 ], %o0 <== NOT EXECUTED
4000c010: 10 80 00 04 b 4000c020 <_Thread_Handler+0xbc> <== NOT EXECUTED
4000c014: d2 04 60 a8 ld [ %l1 + 0xa8 ], %o1 <== NOT EXECUTED
executing->Start.pointer_argument,
executing->Start.numeric_argument
);
break;
case THREAD_START_BOTH_NUMERIC_FIRST:
executing->Wait.return_argument =
4000c018: d0 04 60 a8 ld [ %l1 + 0xa8 ], %o0 <== NOT EXECUTED
4000c01c: d2 04 60 a4 ld [ %l1 + 0xa4 ], %o1 <== NOT EXECUTED
4000c020: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000c024: 01 00 00 00 nop <== NOT EXECUTED
4000c028: d0 24 60 28 st %o0, [ %l1 + 0x28 ] <== NOT EXECUTED
* was placed in return_argument. This assumed that if it returned
* anything (which is not supporting in all APIs), then it would be
* able to fit in a (void *).
*/
_User_extensions_Thread_exitted( executing );
4000c02c: 7f ff f1 2b call 400084d8 <_User_extensions_Thread_exitted>
4000c030: 90 10 00 11 mov %l1, %o0
_Internal_error_Occurred(
4000c034: 90 10 20 00 clr %o0
4000c038: 92 10 20 01 mov 1, %o1
4000c03c: 7f ff e9 64 call 400065cc <_Internal_error_Occurred>
4000c040: 94 10 20 06 mov 6, %o2
40007620 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
40007620: 9d e3 bf 98 save %sp, -104, %sp
40007624: c2 07 a0 6c ld [ %fp + 0x6c ], %g1
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
40007628: 80 a6 a0 00 cmp %i2, 0
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
4000762c: e4 00 40 00 ld [ %g1 ], %l2
40007630: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
40007634: 12 80 00 0e bne 4000766c <_Thread_Initialize+0x4c> <== NEVER TAKEN
40007638: e0 0f a0 5f ldub [ %fp + 0x5f ], %l0
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
4000763c: 90 10 00 19 mov %i1, %o0
40007640: 40 00 02 a3 call 400080cc <_Thread_Stack_Allocate>
40007644: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
40007648: 80 a2 20 00 cmp %o0, 0
4000764c: 02 80 00 1e be 400076c4 <_Thread_Initialize+0xa4>
40007650: 80 a2 00 1b cmp %o0, %i3
40007654: 0a 80 00 1c bcs 400076c4 <_Thread_Initialize+0xa4> <== NEVER TAKEN
40007658: 01 00 00 00 nop
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = TRUE;
4000765c: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
if ( !actual_stack_size || actual_stack_size < stack_size )
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
40007660: f4 06 60 cc ld [ %i1 + 0xcc ], %i2
the_thread->Start.core_allocated_stack = TRUE;
40007664: 10 80 00 04 b 40007674 <_Thread_Initialize+0x54>
40007668: c2 2e 60 c0 stb %g1, [ %i1 + 0xc0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = FALSE;
4000766c: c0 2e 60 c0 clrb [ %i1 + 0xc0 ] <== NOT EXECUTED
40007670: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
40007674: 03 10 00 5f sethi %hi(0x40017c00), %g1
40007678: c2 00 63 70 ld [ %g1 + 0x370 ], %g1 ! 40017f70 <_Thread_Maximum_extensions>
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
4000767c: f4 26 60 c8 st %i2, [ %i1 + 0xc8 ]
the_stack->size = size;
40007680: d0 26 60 c4 st %o0, [ %i1 + 0xc4 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40007684: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
40007688: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
4000768c: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
40007690: c0 26 60 6c clr [ %i1 + 0x6c ]
/*
* Clear the libc reent hook.
*/
the_thread->libc_reent = NULL;
40007694: c0 26 61 58 clr [ %i1 + 0x158 ]
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
40007698: 80 a0 60 00 cmp %g1, 0
4000769c: 02 80 00 0c be 400076cc <_Thread_Initialize+0xac>
400076a0: b6 10 20 00 clr %i3
extensions_area = _Workspace_Allocate(
400076a4: 90 00 60 01 add %g1, 1, %o0
400076a8: 40 00 04 b3 call 40008974 <_Workspace_Allocate>
400076ac: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
400076b0: b6 92 20 00 orcc %o0, 0, %i3
400076b4: 12 80 00 07 bne 400076d0 <_Thread_Initialize+0xb0> <== ALWAYS TAKEN
400076b8: 80 a6 e0 00 cmp %i3, 0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
400076bc: 40 00 02 9c call 4000812c <_Thread_Stack_Free> <== NOT EXECUTED
400076c0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400076c4: 81 c7 e0 08 ret
400076c8: 91 e8 20 00 restore %g0, 0, %o0
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
400076cc: 80 a6 e0 00 cmp %i3, 0
400076d0: 02 80 00 0d be 40007704 <_Thread_Initialize+0xe4>
400076d4: f6 26 61 68 st %i3, [ %i1 + 0x168 ]
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
400076d8: 03 10 00 5f sethi %hi(0x40017c00), %g1
400076dc: c2 00 63 70 ld [ %g1 + 0x370 ], %g1 ! 40017f70 <_Thread_Maximum_extensions>
400076e0: 86 10 20 00 clr %g3
400076e4: 10 80 00 05 b 400076f8 <_Thread_Initialize+0xd8>
400076e8: 88 00 60 01 add %g1, 1, %g4
the_thread->extensions[i] = NULL;
400076ec: 83 28 e0 02 sll %g3, 2, %g1
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
400076f0: 86 00 e0 01 inc %g3
the_thread->extensions[i] = NULL;
400076f4: c0 20 80 01 clr [ %g2 + %g1 ]
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
400076f8: 80 a0 c0 04 cmp %g3, %g4
400076fc: 2a bf ff fc bcs,a 400076ec <_Thread_Initialize+0xcc>
40007700: c4 06 61 68 ld [ %i1 + 0x168 ], %g2
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
40007704: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
40007708: e0 2e 60 ac stb %l0, [ %i1 + 0xac ]
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
4000770c: c2 26 60 b4 st %g1, [ %i1 + 0xb4 ]
switch ( budget_algorithm ) {
40007710: 80 a4 60 02 cmp %l1, 2
40007714: 12 80 00 05 bne 40007728 <_Thread_Initialize+0x108> <== ALWAYS TAKEN
40007718: e2 26 60 b0 st %l1, [ %i1 + 0xb0 ]
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
break;
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000771c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40007720: c2 00 62 28 ld [ %g1 + 0x228 ], %g1 ! 40017e28 <_Thread_Ticks_per_timeslice><== NOT EXECUTED
40007724: c2 26 60 78 st %g1, [ %i1 + 0x78 ] <== NOT EXECUTED
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
40007728: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
the_thread->suspend_count = 0;
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
4000772c: 92 10 00 1d mov %i5, %o1
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
40007730: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ]
the_thread->current_state = STATES_DORMANT;
40007734: 82 10 20 01 mov 1, %g1
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
the_thread->suspend_count = 0;
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
40007738: 90 10 00 19 mov %i1, %o0
break;
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
4000773c: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
40007740: c0 26 60 44 clr [ %i1 + 0x44 ]
the_thread->resource_count = 0;
40007744: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->suspend_count = 0;
40007748: c0 26 60 70 clr [ %i1 + 0x70 ]
the_thread->real_priority = priority;
4000774c: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
40007750: 40 00 01 be call 40007e48 <_Thread_Set_priority>
40007754: fa 26 60 bc st %i5, [ %i1 + 0xbc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40007758: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000775c: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
40007760: 03 00 00 3f sethi %hi(0xfc00), %g1
40007764: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40007768: 84 08 80 01 and %g2, %g1, %g2
4000776c: 85 28 a0 02 sll %g2, 2, %g2
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40007770: e4 26 60 0c st %l2, [ %i1 + 0xc ]
/*
* Initialize the CPU usage statistics
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
the_thread->cpu_time_used.tv_sec = 0;
40007774: c0 26 60 84 clr [ %i1 + 0x84 ]
the_thread->cpu_time_used.tv_nsec = 0;
40007778: c0 26 60 88 clr [ %i1 + 0x88 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000777c: f2 20 c0 02 st %i1, [ %g3 + %g2 ]
* enabled when we get here. We want to be able to run the
* user extensions with dispatching enabled. The Allocator
* Mutex provides sufficient protection to let the user extensions
* run safely.
*/
extension_status = _User_extensions_Thread_create( the_thread );
40007780: 90 10 00 19 mov %i1, %o0
40007784: 40 00 03 79 call 40008568 <_User_extensions_Thread_create>
40007788: b0 10 20 01 mov 1, %i0
if ( !extension_status ) {
4000778c: 80 8a 20 ff btst 0xff, %o0
40007790: 12 80 00 09 bne 400077b4 <_Thread_Initialize+0x194> <== ALWAYS TAKEN
40007794: 80 a6 e0 00 cmp %i3, 0
if ( extensions_area )
40007798: 02 80 00 05 be 400077ac <_Thread_Initialize+0x18c> <== NOT EXECUTED
4000779c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
(void) _Workspace_Free( extensions_area );
400077a0: 40 00 04 6e call 40008958 <_Workspace_Free> <== NOT EXECUTED
400077a4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
(void) _Workspace_Free( fp_area );
#endif
_Thread_Stack_Free( the_thread );
400077a8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400077ac: 40 00 02 60 call 4000812c <_Thread_Stack_Free> <== NOT EXECUTED
400077b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
return FALSE;
}
return TRUE;
}
400077b4: 81 c7 e0 08 ret
400077b8: 81 e8 00 00 restore
4000c348 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
4000c348: 9d e3 bf 98 save %sp, -104, %sp
the_thread->resource_count = 0;
the_thread->suspend_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
4000c34c: c4 1e 20 b0 ldd [ %i0 + 0xb0 ], %g2
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
the_thread->suspend_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000c350: c2 0e 20 ac ldub [ %i0 + 0xac ], %g1
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
4000c354: c4 26 20 7c st %g2, [ %i0 + 0x7c ]
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
the_thread->suspend_count = 0;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
4000c358: c2 2e 20 76 stb %g1, [ %i0 + 0x76 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
4000c35c: c6 26 20 80 st %g3, [ %i0 + 0x80 ]
the_thread->Start.pointer_argument = pointer_argument;
4000c360: f2 26 20 a4 st %i1, [ %i0 + 0xa4 ]
the_thread->Start.numeric_argument = numeric_argument;
4000c364: f4 26 20 a8 st %i2, [ %i0 + 0xa8 ]
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
the_thread->resource_count = 0;
4000c368: c0 26 20 1c clr [ %i0 + 0x1c ]
the_thread->suspend_count = 0;
4000c36c: c0 26 20 70 clr [ %i0 + 0x70 ]
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 ) ) {
4000c370: 7f ff f1 4a call 40008898 <_Thread_queue_Extract_with_proxy>
4000c374: 90 10 00 18 mov %i0, %o0
4000c378: 80 8a 20 ff btst 0xff, %o0
4000c37c: 32 80 00 09 bne,a 4000c3a0 <_Thread_Reset+0x58>
4000c380: f2 06 20 bc ld [ %i0 + 0xbc ], %i1
if ( _Watchdog_Is_active( &the_thread->Timer ) )
4000c384: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
4000c388: 80 a0 60 02 cmp %g1, 2
4000c38c: 32 80 00 05 bne,a 4000c3a0 <_Thread_Reset+0x58> <== ALWAYS TAKEN
4000c390: f2 06 20 bc ld [ %i0 + 0xbc ], %i1
(void) _Watchdog_Remove( &the_thread->Timer );
4000c394: 7f ff f4 3f call 40009490 <_Watchdog_Remove> <== NOT EXECUTED
4000c398: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
4000c39c: f2 06 20 bc ld [ %i0 + 0xbc ], %i1 <== NOT EXECUTED
4000c3a0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
4000c3a4: 80 a0 40 19 cmp %g1, %i1
4000c3a8: 02 80 00 05 be 4000c3bc <_Thread_Reset+0x74>
4000c3ac: 01 00 00 00 nop
the_thread->real_priority = the_thread->Start.initial_priority;
4000c3b0: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
4000c3b4: 7f ff f1 b4 call 40008a84 <_Thread_Set_priority>
4000c3b8: 81 e8 00 00 restore
4000c3bc: 81 c7 e0 08 ret
4000c3c0: 81 e8 00 00 restore
4000b62c <_Thread_Reset_timeslice>:
* ready chain
* select heir
*/
void _Thread_Reset_timeslice( void )
{
4000b62c: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
4000b630: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000b634: e0 00 63 90 ld [ %g1 + 0x390 ], %l0 ! 40017f90 <_Thread_Executing>
ready = executing->ready;
_ISR_Disable( level );
4000b638: 7f ff d9 a9 call 40001cdc <sparc_disable_interrupts>
4000b63c: e2 04 20 8c ld [ %l0 + 0x8c ], %l1
4000b640: b0 10 00 08 mov %o0, %i0
if ( _Chain_Has_only_one_node( ready ) ) {
4000b644: c4 04 40 00 ld [ %l1 ], %g2
4000b648: c2 04 60 08 ld [ %l1 + 8 ], %g1
4000b64c: 80 a0 80 01 cmp %g2, %g1
4000b650: 32 80 00 03 bne,a 4000b65c <_Thread_Reset_timeslice+0x30>
4000b654: c6 04 00 00 ld [ %l0 ], %g3
_ISR_Enable( level );
4000b658: 30 80 00 18 b,a 4000b6b8 <_Thread_Reset_timeslice+0x8c>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000b65c: c4 04 20 04 ld [ %l0 + 4 ], %g2
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
4000b660: 82 04 60 04 add %l1, 4, %g1
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
4000b664: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
4000b668: c2 24 00 00 st %g1, [ %l0 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
4000b66c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
4000b670: c2 04 60 08 ld [ %l1 + 8 ], %g1
the_chain->last = the_node;
4000b674: e0 24 60 08 st %l0, [ %l1 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
4000b678: c2 24 20 04 st %g1, [ %l0 + 4 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
4000b67c: e0 20 40 00 st %l0, [ %g1 ]
return;
}
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
4000b680: 7f ff d9 9b call 40001cec <sparc_enable_interrupts>
4000b684: 01 00 00 00 nop
4000b688: 7f ff d9 95 call 40001cdc <sparc_disable_interrupts>
4000b68c: 01 00 00 00 nop
if ( _Thread_Is_heir( executing ) )
4000b690: 05 10 00 5f sethi %hi(0x40017c00), %g2
4000b694: c2 00 a3 5c ld [ %g2 + 0x35c ], %g1 ! 40017f5c <_Thread_Heir>
4000b698: 80 a4 00 01 cmp %l0, %g1
4000b69c: 32 80 00 05 bne,a 4000b6b0 <_Thread_Reset_timeslice+0x84><== NEVER TAKEN
4000b6a0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
_Thread_Heir = (Thread_Control *) ready->first;
4000b6a4: c2 04 40 00 ld [ %l1 ], %g1
4000b6a8: c2 20 a3 5c st %g1, [ %g2 + 0x35c ]
_Context_Switch_necessary = TRUE;
4000b6ac: 84 10 20 01 mov 1, %g2
4000b6b0: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000b6b4: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ] ! 40017fa0 <_Context_Switch_necessary>
_ISR_Enable( level );
4000b6b8: 7f ff d9 8d call 40001cec <sparc_enable_interrupts>
4000b6bc: 81 e8 00 00 restore
400097f8 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
400097f8: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
400097fc: 7f ff e4 ab call 40002aa8 <sparc_disable_interrupts>
40009800: 01 00 00 00 nop
40009804: a0 10 00 08 mov %o0, %l0
if ( force == TRUE )
40009808: 80 8e 60 ff btst 0xff, %i1
4000980c: 22 80 00 04 be,a 4000981c <_Thread_Resume+0x24> <== NEVER TAKEN
40009810: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED
the_thread->suspend_count = 0;
40009814: 10 80 00 04 b 40009824 <_Thread_Resume+0x2c>
40009818: c0 26 20 70 clr [ %i0 + 0x70 ]
else
the_thread->suspend_count--;
4000981c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40009820: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED
if ( the_thread->suspend_count > 0 ) {
40009824: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
40009828: 80 a0 60 00 cmp %g1, 0
4000982c: 22 80 00 03 be,a 40009838 <_Thread_Resume+0x40> <== ALWAYS TAKEN
40009830: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
_ISR_Enable( level );
40009834: 30 80 00 2e b,a 400098ec <_Thread_Resume+0xf4> <== NOT EXECUTED
return;
}
current_state = the_thread->current_state;
if ( current_state & STATES_SUSPENDED ) {
40009838: 80 88 60 02 btst 2, %g1
4000983c: 02 80 00 2c be 400098ec <_Thread_Resume+0xf4> <== NEVER TAKEN
40009840: 82 08 7f fd and %g1, -3, %g1
current_state =
the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);
if ( _States_Is_ready( current_state ) ) {
40009844: 80 a0 60 00 cmp %g1, 0
40009848: 12 80 00 29 bne 400098ec <_Thread_Resume+0xf4>
4000984c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
40009850: c8 06 20 90 ld [ %i0 + 0x90 ], %g4
40009854: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2
40009858: c2 11 00 00 lduh [ %g4 ], %g1
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
4000985c: c6 06 20 8c ld [ %i0 + 0x8c ], %g3
40009860: 82 10 40 02 or %g1, %g2, %g1
40009864: c2 31 00 00 sth %g1, [ %g4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
40009868: 82 00 e0 04 add %g3, 4, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
4000986c: 1b 10 00 91 sethi %hi(0x40024400), %o5
40009870: c2 26 00 00 st %g1, [ %i0 ]
40009874: c4 16 20 94 lduh [ %i0 + 0x94 ], %g2
old_last_node = the_chain->last;
40009878: c2 00 e0 08 ld [ %g3 + 8 ], %g1
4000987c: c8 13 60 64 lduh [ %o5 + 0x64 ], %g4
the_chain->last = the_node;
40009880: f0 20 e0 08 st %i0, [ %g3 + 8 ]
40009884: 84 10 80 04 or %g2, %g4, %g2
old_last_node->next = the_node;
the_node->previous = old_last_node;
40009888: c2 26 20 04 st %g1, [ %i0 + 4 ]
4000988c: c4 33 60 64 sth %g2, [ %o5 + 0x64 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
40009890: f0 20 40 00 st %i0, [ %g1 ]
_ISR_Flash( level );
40009894: 7f ff e4 89 call 40002ab8 <sparc_enable_interrupts>
40009898: 90 10 00 10 mov %l0, %o0
4000989c: 7f ff e4 83 call 40002aa8 <sparc_disable_interrupts>
400098a0: 01 00 00 00 nop
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
400098a4: 07 10 00 91 sethi %hi(0x40024400), %g3
400098a8: c2 00 e0 3c ld [ %g3 + 0x3c ], %g1 ! 4002443c <_Thread_Heir>
400098ac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
400098b0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400098b4: 80 a0 80 01 cmp %g2, %g1
400098b8: 1a 80 00 0d bcc 400098ec <_Thread_Resume+0xf4>
400098bc: 03 10 00 91 sethi %hi(0x40024400), %g1
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
400098c0: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 40024470 <_Thread_Executing>
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
_ISR_Flash( level );
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
400098c4: f0 20 e0 3c st %i0, [ %g3 + 0x3c ]
if ( _Thread_Executing->is_preemptible ||
400098c8: c2 08 60 76 ldub [ %g1 + 0x76 ], %g1
400098cc: 80 a0 60 00 cmp %g1, 0
400098d0: 32 80 00 05 bne,a 400098e4 <_Thread_Resume+0xec>
400098d4: 84 10 20 01 mov 1, %g2
400098d8: 80 a0 a0 00 cmp %g2, 0
400098dc: 12 80 00 04 bne 400098ec <_Thread_Resume+0xf4> <== ALWAYS TAKEN
400098e0: 84 10 20 01 mov 1, %g2
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
400098e4: 03 10 00 91 sethi %hi(0x40024400), %g1
400098e8: c4 28 60 80 stb %g2, [ %g1 + 0x80 ] ! 40024480 <_Context_Switch_necessary>
}
}
}
_ISR_Enable( level );
400098ec: 7f ff e4 73 call 40002ab8 <sparc_enable_interrupts>
400098f0: 91 e8 00 10 restore %g0, %l0, %o0
400080cc <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
400080cc: 9d e3 bf 98 save %sp, -104, %sp
400080d0: 03 10 00 5c sethi %hi(0x40017000), %g1
400080d4: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 40017200 <rtems_minimum_stack_size>
400080d8: 80 a6 40 01 cmp %i1, %g1
400080dc: 2a 80 00 02 bcs,a 400080e4 <_Thread_Stack_Allocate+0x18>
400080e0: b2 10 00 01 mov %g1, %i1
* Call ONLY the CPU table stack allocate hook, _or_ the
* the RTEMS workspace allocate. This is so the stack free
* routine can call the correct deallocation routine.
*/
if ( _Configuration_Table->stack_allocate_hook ) {
400080e4: 03 10 00 5f sethi %hi(0x40017c00), %g1
400080e8: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
400080ec: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
400080f0: 80 a0 60 00 cmp %g1, 0
400080f4: 22 80 00 06 be,a 4000810c <_Thread_Stack_Allocate+0x40> <== ALWAYS TAKEN
400080f8: b2 06 60 10 add %i1, 0x10, %i1
stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
400080fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
40008100: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
if ( !stack_addr )
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
40008104: 10 80 00 05 b 40008118 <_Thread_Stack_Allocate+0x4c> <== NOT EXECUTED
40008108: d0 26 20 cc st %o0, [ %i0 + 0xcc ] <== NOT EXECUTED
* get and keep the stack adjust factor, the stack alignment, and
* the context initialization sequence in sync.
*/
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
4000810c: 40 00 02 1a call 40008974 <_Workspace_Allocate>
40008110: 90 10 00 19 mov %i1, %o0
}
if ( !stack_addr )
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
40008114: d0 26 20 cc st %o0, [ %i0 + 0xcc ]
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
40008118: 80 a0 00 08 cmp %g0, %o0
4000811c: b0 60 20 00 subx %g0, 0, %i0
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
return the_stack_size;
}
40008120: b0 0e 40 18 and %i1, %i0, %i0
40008124: 81 c7 e0 08 ret
40008128: 81 e8 00 00 restore
4000812c <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
4000812c: 9d e3 bf 98 save %sp, -104, %sp
/*
* If the API provided the stack space, then don't free it.
*/
if ( !the_thread->Start.core_allocated_stack )
40008130: c2 0e 20 c0 ldub [ %i0 + 0xc0 ], %g1
40008134: 80 a0 60 00 cmp %g1, 0
40008138: 02 80 00 09 be 4000815c <_Thread_Stack_Free+0x30> <== NEVER TAKEN
4000813c: 03 10 00 5f sethi %hi(0x40017c00), %g1
* Call ONLY the CPU table stack free hook, or the
* the RTEMS workspace free. This is so the free
* routine properly matches the allocation of the stack.
*/
if ( _Configuration_Table->stack_free_hook )
40008140: c2 00 63 68 ld [ %g1 + 0x368 ], %g1 ! 40017f68 <_Configuration_Table>
40008144: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40008148: 80 a0 60 00 cmp %g1, 0
4000814c: 02 80 00 06 be 40008164 <_Thread_Stack_Free+0x38> <== ALWAYS TAKEN
40008150: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
(*_Configuration_Table->stack_free_hook)(
40008154: 9f c0 40 00 call %g1 <== NOT EXECUTED
40008158: 01 00 00 00 nop <== NOT EXECUTED
4000815c: 81 c7 e0 08 ret <== NOT EXECUTED
40008160: 81 e8 00 00 restore <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
40008164: 40 00 01 fd call 40008958 <_Workspace_Free>
40008168: 91 e8 00 08 restore %g0, %o0, %o0
400081fc <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
400081fc: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
executing = _Thread_Executing;
40008200: 03 10 00 5f sethi %hi(0x40017c00), %g1
40008204: e0 00 63 90 ld [ %g1 + 0x390 ], %l0 ! 40017f90 <_Thread_Executing>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
40008208: c2 0c 20 76 ldub [ %l0 + 0x76 ], %g1
4000820c: 80 a0 60 00 cmp %g1, 0
40008210: 02 80 00 23 be 4000829c <_Thread_Tickle_timeslice+0xa0>
40008214: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
40008218: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
4000821c: 80 a0 60 00 cmp %g1, 0
40008220: 12 80 00 1f bne 4000829c <_Thread_Tickle_timeslice+0xa0> <== NEVER TAKEN
40008224: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
40008228: c2 04 20 7c ld [ %l0 + 0x7c ], %g1
4000822c: 80 a0 60 01 cmp %g1, 1
40008230: 0a 80 00 12 bcs 40008278 <_Thread_Tickle_timeslice+0x7c>
40008234: 80 a0 60 02 cmp %g1, 2
40008238: 28 80 00 07 bleu,a 40008254 <_Thread_Tickle_timeslice+0x58><== ALWAYS TAKEN
4000823c: c2 04 20 78 ld [ %l0 + 0x78 ], %g1
40008240: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
40008244: 12 80 00 16 bne 4000829c <_Thread_Tickle_timeslice+0xa0> <== NOT EXECUTED
40008248: 01 00 00 00 nop <== NOT EXECUTED
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
4000824c: 10 80 00 0d b 40008280 <_Thread_Tickle_timeslice+0x84> <== NOT EXECUTED
40008250: c2 04 20 78 ld [ %l0 + 0x78 ], %g1 <== NOT EXECUTED
case THREAD_CPU_BUDGET_ALGORITHM_NONE:
break;
case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
if ( (int)(--executing->cpu_time_budget) <= 0 ) {
40008254: 82 00 7f ff add %g1, -1, %g1
40008258: 80 a0 60 00 cmp %g1, 0
4000825c: 14 80 00 07 bg 40008278 <_Thread_Tickle_timeslice+0x7c>
40008260: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
_Thread_Reset_timeslice();
40008264: 40 00 0c f2 call 4000b62c <_Thread_Reset_timeslice>
40008268: 01 00 00 00 nop
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000826c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40008270: c2 00 62 28 ld [ %g1 + 0x228 ], %g1 ! 40017e28 <_Thread_Ticks_per_timeslice>
40008274: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
40008278: 81 c7 e0 08 ret
4000827c: 81 e8 00 00 restore
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
40008280: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40008284: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40008288: 12 bf ff fc bne 40008278 <_Thread_Tickle_timeslice+0x7c> <== NOT EXECUTED
4000828c: c2 24 20 78 st %g1, [ %l0 + 0x78 ] <== NOT EXECUTED
(*executing->budget_callout)( executing );
40008290: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 <== NOT EXECUTED
40008294: 9f c0 40 00 call %g1 <== NOT EXECUTED
40008298: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000829c: 81 c7 e0 08 ret
400082a0: 81 e8 00 00 restore
400082a4 <_Thread_Yield_processor>:
* ready chain
* select heir
*/
void _Thread_Yield_processor( void )
{
400082a4: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
400082a8: 03 10 00 5f sethi %hi(0x40017c00), %g1
400082ac: e0 00 63 90 ld [ %g1 + 0x390 ], %l0 ! 40017f90 <_Thread_Executing>
ready = executing->ready;
_ISR_Disable( level );
400082b0: 7f ff e6 8b call 40001cdc <sparc_disable_interrupts>
400082b4: e2 04 20 8c ld [ %l0 + 0x8c ], %l1
400082b8: b0 10 00 08 mov %o0, %i0
if ( !_Chain_Has_only_one_node( ready ) ) {
400082bc: c4 04 40 00 ld [ %l1 ], %g2
400082c0: c2 04 60 08 ld [ %l1 + 8 ], %g1
400082c4: 80 a0 80 01 cmp %g2, %g1
400082c8: 02 80 00 17 be 40008324 <_Thread_Yield_processor+0x80>
400082cc: 25 10 00 5f sethi %hi(0x40017c00), %l2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400082d0: c6 04 00 00 ld [ %l0 ], %g3
previous = the_node->previous;
400082d4: c4 04 20 04 ld [ %l0 + 4 ], %g2
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
400082d8: 82 04 60 04 add %l1, 4, %g1
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
previous->next = next;
400082dc: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
400082e0: c2 24 00 00 st %g1, [ %l0 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
400082e4: c4 20 e0 04 st %g2, [ %g3 + 4 ]
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
400082e8: c2 04 60 08 ld [ %l1 + 8 ], %g1
the_chain->last = the_node;
400082ec: e0 24 60 08 st %l0, [ %l1 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
400082f0: c2 24 20 04 st %g1, [ %l0 + 4 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
400082f4: e0 20 40 00 st %l0, [ %g1 ]
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
400082f8: 7f ff e6 7d call 40001cec <sparc_enable_interrupts>
400082fc: 01 00 00 00 nop
40008300: 7f ff e6 77 call 40001cdc <sparc_disable_interrupts>
40008304: 01 00 00 00 nop
if ( _Thread_Is_heir( executing ) )
40008308: c2 04 a3 5c ld [ %l2 + 0x35c ], %g1
4000830c: 80 a4 00 01 cmp %l0, %g1
40008310: 12 80 00 09 bne 40008334 <_Thread_Yield_processor+0x90> <== NEVER TAKEN
40008314: 84 10 20 01 mov 1, %g2
_Thread_Heir = (Thread_Control *) ready->first;
40008318: c2 04 40 00 ld [ %l1 ], %g1
4000831c: 10 80 00 06 b 40008334 <_Thread_Yield_processor+0x90>
40008320: c2 24 a3 5c st %g1, [ %l2 + 0x35c ]
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
40008324: c2 04 a3 5c ld [ %l2 + 0x35c ], %g1
40008328: 80 a4 00 01 cmp %l0, %g1
4000832c: 02 80 00 04 be 4000833c <_Thread_Yield_processor+0x98> <== ALWAYS TAKEN
40008330: 84 10 20 01 mov 1, %g2
_Context_Switch_necessary = TRUE;
40008334: 03 10 00 5f sethi %hi(0x40017c00), %g1
40008338: c4 28 63 a0 stb %g2, [ %g1 + 0x3a0 ] ! 40017fa0 <_Context_Switch_necessary>
_ISR_Enable( level );
4000833c: 7f ff e6 6c call 40001cec <sparc_enable_interrupts>
40008340: 81 e8 00 00 restore
40007ad0 <_Thread_queue_Enqueue_priority>:
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
40007ad0: 9d e3 bf 98 save %sp, -104, %sp
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
40007ad4: e4 06 60 14 ld [ %i1 + 0x14 ], %l2
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40007ad8: 82 06 60 3c add %i1, 0x3c, %g1
the_chain->permanent_null = NULL;
40007adc: c0 26 60 3c clr [ %i1 + 0x3c ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40007ae0: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
40007ae4: 82 06 60 38 add %i1, 0x38, %g1
40007ae8: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
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 ) )
40007aec: 80 8c a0 20 btst 0x20, %l2
RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number (
Priority_Control the_priority
)
{
return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
40007af0: 83 34 a0 06 srl %l2, 6, %g1
_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;
40007af4: ec 06 20 38 ld [ %i0 + 0x38 ], %l6
_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 ];
40007af8: 85 28 60 04 sll %g1, 4, %g2
40007afc: 83 28 60 02 sll %g1, 2, %g1
40007b00: 84 20 80 01 sub %g2, %g1, %g2
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
40007b04: 12 80 00 31 bne 40007bc8 <_Thread_queue_Enqueue_priority+0xf8>
40007b08: a6 06 00 02 add %i0, %g2, %l3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
40007b0c: a8 04 e0 04 add %l3, 4, %l4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
40007b10: aa 10 00 02 mov %g2, %l5
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
40007b14: 7f ff e8 72 call 40001cdc <sparc_disable_interrupts>
40007b18: 01 00 00 00 nop
40007b1c: a6 10 00 08 mov %o0, %l3
search_thread = (Thread_Control *) header->first;
40007b20: a2 10 3f ff mov -1, %l1
40007b24: 10 80 00 18 b 40007b84 <_Thread_queue_Enqueue_priority+0xb4>
40007b28: e0 06 00 15 ld [ %i0 + %l5 ], %l0
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
40007b2c: 80 a4 80 11 cmp %l2, %l1
40007b30: 28 80 00 19 bleu,a 40007b94 <_Thread_queue_Enqueue_priority+0xc4>
40007b34: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
#if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE )
search_thread = (Thread_Control *) search_thread->Object.Node.next;
40007b38: e0 04 00 00 ld [ %l0 ], %l0
if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) )
40007b3c: 80 a4 00 14 cmp %l0, %l4
40007b40: 22 80 00 15 be,a 40007b94 <_Thread_queue_Enqueue_priority+0xc4>
40007b44: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
search_priority = search_thread->current_priority;
40007b48: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority <= search_priority )
40007b4c: 80 a4 80 11 cmp %l2, %l1
40007b50: 28 80 00 11 bleu,a 40007b94 <_Thread_queue_Enqueue_priority+0xc4>
40007b54: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
#endif
_ISR_Flash( level );
40007b58: 7f ff e8 65 call 40001cec <sparc_enable_interrupts>
40007b5c: 90 10 00 13 mov %l3, %o0
40007b60: 7f ff e8 5f call 40001cdc <sparc_disable_interrupts>
40007b64: 01 00 00 00 nop
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
40007b68: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
40007b6c: 80 8d 80 01 btst %l6, %g1
40007b70: 32 80 00 05 bne,a 40007b84 <_Thread_queue_Enqueue_priority+0xb4><== ALWAYS TAKEN
40007b74: e0 04 00 00 ld [ %l0 ], %l0
_ISR_Enable( level );
40007b78: 7f ff e8 5d call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40007b7c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40007b80: 30 bf ff e5 b,a 40007b14 <_Thread_queue_Enqueue_priority+0x44><== NOT EXECUTED
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
40007b84: 80 a4 00 14 cmp %l0, %l4
40007b88: 32 bf ff e9 bne,a 40007b2c <_Thread_queue_Enqueue_priority+0x5c>
40007b8c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
40007b90: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40007b94: 80 a0 60 01 cmp %g1, 1
40007b98: 12 80 00 48 bne 40007cb8 <_Thread_queue_Enqueue_priority+0x1e8><== NEVER TAKEN
40007b9c: 90 10 00 13 mov %l3, %o0
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
40007ba0: 80 a4 80 11 cmp %l2, %l1
40007ba4: 02 80 00 3a be 40007c8c <_Thread_queue_Enqueue_priority+0x1bc>
40007ba8: c0 26 20 30 clr [ %i0 + 0x30 ]
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
40007bac: c2 04 20 04 ld [ %l0 + 4 ], %g1
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
40007bb0: e0 26 40 00 st %l0, [ %i1 ]
the_node->previous = previous_node;
40007bb4: c2 26 60 04 st %g1, [ %i1 + 4 ]
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
40007bb8: f0 26 60 44 st %i0, [ %i1 + 0x44 ]
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
40007bbc: f2 20 40 00 st %i1, [ %g1 ]
search_node->previous = the_node;
40007bc0: f2 24 20 04 st %i1, [ %l0 + 4 ]
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
40007bc4: 30 80 00 39 b,a 40007ca8 <_Thread_queue_Enqueue_priority+0x1d8>
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
40007bc8: 03 10 00 5c sethi %hi(0x40017000), %g1
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
40007bcc: aa 10 00 13 mov %l3, %l5
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
40007bd0: ae 10 62 04 or %g1, 0x204, %l7
40007bd4: c2 0d c0 00 ldub [ %l7 ], %g1
_ISR_Disable( level );
40007bd8: 7f ff e8 41 call 40001cdc <sparc_disable_interrupts>
40007bdc: a2 00 60 01 add %g1, 1, %l1
40007be0: a8 10 00 08 mov %o0, %l4
search_thread = (Thread_Control *) header->last;
40007be4: 10 80 00 19 b 40007c48 <_Thread_queue_Enqueue_priority+0x178>
40007be8: e0 05 60 08 ld [ %l5 + 8 ], %l0
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
40007bec: 80 a4 80 11 cmp %l2, %l1
40007bf0: 3a 80 00 1a bcc,a 40007c58 <_Thread_queue_Enqueue_priority+0x188>
40007bf4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
#if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE )
search_thread = (Thread_Control *) search_thread->Object.Node.previous;
40007bf8: e0 04 20 04 ld [ %l0 + 4 ], %l0
if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) )
40007bfc: 80 a4 00 13 cmp %l0, %l3
40007c00: 22 80 00 16 be,a 40007c58 <_Thread_queue_Enqueue_priority+0x188>
40007c04: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
search_priority = search_thread->current_priority;
40007c08: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority >= search_priority )
40007c0c: 80 a4 80 11 cmp %l2, %l1
40007c10: 3a 80 00 12 bcc,a 40007c58 <_Thread_queue_Enqueue_priority+0x188>
40007c14: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
break;
#endif
_ISR_Flash( level );
40007c18: 7f ff e8 35 call 40001cec <sparc_enable_interrupts>
40007c1c: 90 10 00 14 mov %l4, %o0
40007c20: 7f ff e8 2f call 40001cdc <sparc_disable_interrupts>
40007c24: 01 00 00 00 nop
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
40007c28: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
40007c2c: 80 8d 80 01 btst %l6, %g1
40007c30: 32 80 00 06 bne,a 40007c48 <_Thread_queue_Enqueue_priority+0x178><== ALWAYS TAKEN
40007c34: e0 04 20 04 ld [ %l0 + 4 ], %l0
_ISR_Enable( level );
40007c38: 7f ff e8 2d call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40007c3c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
40007c40: 10 bf ff e6 b 40007bd8 <_Thread_queue_Enqueue_priority+0x108><== NOT EXECUTED
40007c44: c2 0d c0 00 ldub [ %l7 ], %g1 <== NOT EXECUTED
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
40007c48: 80 a4 00 13 cmp %l0, %l3
40007c4c: 32 bf ff e8 bne,a 40007bec <_Thread_queue_Enqueue_priority+0x11c>
40007c50: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
40007c54: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40007c58: 80 a0 60 01 cmp %g1, 1
40007c5c: 12 80 00 17 bne 40007cb8 <_Thread_queue_Enqueue_priority+0x1e8><== NEVER TAKEN
40007c60: 90 10 00 14 mov %l4, %o0
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
40007c64: 80 a4 80 11 cmp %l2, %l1
40007c68: 02 80 00 09 be 40007c8c <_Thread_queue_Enqueue_priority+0x1bc>
40007c6c: c0 26 20 30 clr [ %i0 + 0x30 ]
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
40007c70: c2 04 00 00 ld [ %l0 ], %g1
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
40007c74: e0 26 60 04 st %l0, [ %i1 + 4 ]
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
40007c78: c2 26 40 00 st %g1, [ %i1 ]
the_node->previous = search_node;
search_node->next = the_node;
next_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
40007c7c: f0 26 60 44 st %i0, [ %i1 + 0x44 ]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
next_node->previous = the_node;
40007c80: f2 20 60 04 st %i1, [ %g1 + 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;
40007c84: f2 24 00 00 st %i1, [ %l0 ]
next_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
40007c88: 30 80 00 08 b,a 40007ca8 <_Thread_queue_Enqueue_priority+0x1d8>
40007c8c: 82 04 20 3c add %l0, 0x3c, %g1
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;
40007c90: c4 00 60 04 ld [ %g1 + 4 ], %g2
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
40007c94: c2 26 40 00 st %g1, [ %i1 ]
the_node->previous = previous_node;
40007c98: c4 26 60 04 st %g2, [ %i1 + 4 ]
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
40007c9c: f0 26 60 44 st %i0, [ %i1 + 0x44 ]
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
40007ca0: f2 20 80 00 st %i1, [ %g2 ]
search_node->previous = the_node;
40007ca4: f2 20 60 04 st %i1, [ %g1 + 4 ]
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
40007ca8: 7f ff e8 11 call 40001cec <sparc_enable_interrupts>
40007cac: b0 10 20 01 mov 1, %i0
40007cb0: 81 c7 e0 08 ret
40007cb4: 81 e8 00 00 restore
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
return the_thread_queue->sync_state;
40007cb8: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 <== NOT EXECUTED
* 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;
40007cbc: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
return the_thread_queue->sync_state;
}
40007cc0: 81 c7 e0 08 ret <== NOT EXECUTED
40007cc4: 81 e8 00 00 restore <== NOT EXECUTED
4000c048 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
4000c048: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
_ISR_Disable( level );
4000c04c: 7f ff d7 24 call 40001cdc <sparc_disable_interrupts>
4000c050: b0 10 00 19 mov %i1, %i0
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000c054: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4000c058: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000c05c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
4000c060: 80 88 80 01 btst %g2, %g1
4000c064: 32 80 00 04 bne,a 4000c074 <_Thread_queue_Extract_fifo+0x2c><== ALWAYS TAKEN
4000c068: c2 06 40 00 ld [ %i1 ], %g1
_ISR_Enable( level );
4000c06c: 7f ff d7 20 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
4000c070: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
4000c074: c4 06 60 04 ld [ %i1 + 4 ], %g2
_Chain_Extract_unprotected( &the_thread->Object.Node );
the_thread->Wait.queue = NULL;
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4000c078: c6 06 60 50 ld [ %i1 + 0x50 ], %g3
next->previous = previous;
previous->next = next;
4000c07c: c2 20 80 00 st %g1, [ %g2 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
4000c080: c4 20 60 04 st %g2, [ %g1 + 4 ]
4000c084: 80 a0 e0 02 cmp %g3, 2
4000c088: 02 80 00 06 be 4000c0a0 <_Thread_queue_Extract_fifo+0x58>
4000c08c: c0 26 60 44 clr [ %i1 + 0x44 ]
_ISR_Enable( level );
4000c090: 7f ff d7 17 call 40001cec <sparc_enable_interrupts>
4000c094: 33 04 00 ff sethi %hi(0x1003fc00), %i1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
4000c098: 10 80 00 0a b 4000c0c0 <_Thread_queue_Extract_fifo+0x78>
4000c09c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
4000c0a0: 82 10 20 03 mov 3, %g1
4000c0a4: c2 26 60 50 st %g1, [ %i1 + 0x50 ]
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4000c0a8: 7f ff d7 11 call 40001cec <sparc_enable_interrupts>
4000c0ac: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_thread->Timer );
4000c0b0: 7f ff f1 d6 call 40008808 <_Watchdog_Remove>
4000c0b4: 90 06 60 48 add %i1, 0x48, %o0
4000c0b8: 33 04 00 ff sethi %hi(0x1003fc00), %i1
4000c0bc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
4000c0c0: 7f ff ec 24 call 40007150 <_Thread_Clear_state>
4000c0c4: 81 e8 00 00 restore
4000b3a8 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
bool requeuing
)
{
4000b3a8: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *new_first_node;
Chain_Node *new_second_node;
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
4000b3ac: 7f ff da 4c call 40001cdc <sparc_disable_interrupts>
4000b3b0: b0 10 00 19 mov %i1, %i0
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
4000b3b4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
4000b3b8: 03 00 00 ef sethi %hi(0x3bc00), %g1
4000b3bc: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
4000b3c0: 80 88 80 01 btst %g2, %g1
4000b3c4: 32 80 00 03 bne,a 4000b3d0 <_Thread_queue_Extract_priority_helper+0x28><== ALWAYS TAKEN
4000b3c8: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
_ISR_Enable( level );
4000b3cc: 30 80 00 1c b,a 4000b43c <_Thread_queue_Extract_priority_helper+0x94><== NOT EXECUTED
*/
next_node = the_node->next;
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
4000b3d0: 82 06 60 3c add %i1, 0x3c, %g1
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
4000b3d4: c4 06 40 00 ld [ %i1 ], %g2
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
4000b3d8: 80 a0 c0 01 cmp %g3, %g1
4000b3dc: 02 80 00 13 be 4000b428 <_Thread_queue_Extract_priority_helper+0x80>
4000b3e0: c2 06 60 04 ld [ %i1 + 4 ], %g1
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
4000b3e4: da 06 60 40 ld [ %i1 + 0x40 ], %o5
new_second_node = new_first_node->next;
4000b3e8: c8 00 c0 00 ld [ %g3 ], %g4
previous_node->next = new_first_node;
next_node->previous = new_first_node;
4000b3ec: c6 20 a0 04 st %g3, [ %g2 + 4 ]
new_first_node = the_thread->Wait.Block2n.first;
new_first_thread = (Thread_Control *) new_first_node;
last_node = the_thread->Wait.Block2n.last;
new_second_node = new_first_node->next;
previous_node->next = new_first_node;
4000b3f0: c6 20 40 00 st %g3, [ %g1 ]
next_node->previous = new_first_node;
new_first_node->next = next_node;
4000b3f4: c4 20 c0 00 st %g2, [ %g3 ]
new_first_node->previous = previous_node;
4000b3f8: c2 20 e0 04 st %g1, [ %g3 + 4 ]
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
4000b3fc: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
4000b400: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
4000b404: 80 a0 80 01 cmp %g2, %g1
4000b408: 02 80 00 0a be 4000b430 <_Thread_queue_Extract_priority_helper+0x88>
4000b40c: 82 00 e0 38 add %g3, 0x38, %g1
/* > two threads on 2-n */
new_second_node->previous =
4000b410: c2 21 20 04 st %g1, [ %g4 + 4 ]
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
4000b414: c8 20 e0 38 st %g4, [ %g3 + 0x38 ]
new_first_thread->Wait.Block2n.last = last_node;
4000b418: da 20 e0 40 st %o5, [ %g3 + 0x40 ]
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
4000b41c: 82 00 e0 3c add %g3, 0x3c, %g1
4000b420: 10 80 00 04 b 4000b430 <_Thread_queue_Extract_priority_helper+0x88>
4000b424: c2 23 40 00 st %g1, [ %o5 ]
}
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
4000b428: c2 20 a0 04 st %g1, [ %g2 + 4 ]
new_first_thread->Wait.Block2n.last = last_node;
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
}
} else {
previous_node->next = next_node;
4000b42c: c4 20 40 00 st %g2, [ %g1 ]
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
4000b430: 80 8e a0 ff btst 0xff, %i2
4000b434: 22 80 00 04 be,a 4000b444 <_Thread_queue_Extract_priority_helper+0x9c>
4000b438: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
_ISR_Enable( level );
4000b43c: 7f ff da 2c call 40001cec <sparc_enable_interrupts>
4000b440: 91 e8 00 08 restore %g0, %o0, %o0
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
4000b444: 80 a0 60 02 cmp %g1, 2
4000b448: 02 80 00 06 be 4000b460 <_Thread_queue_Extract_priority_helper+0xb8><== NEVER TAKEN
4000b44c: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
4000b450: 7f ff da 27 call 40001cec <sparc_enable_interrupts>
4000b454: 33 04 00 ff sethi %hi(0x1003fc00), %i1
4000b458: 10 80 00 08 b 4000b478 <_Thread_queue_Extract_priority_helper+0xd0>
4000b45c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_SIZE+0xfc3fff8>
4000b460: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
4000b464: 7f ff da 22 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
4000b468: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
4000b46c: 7f ff f4 e7 call 40008808 <_Watchdog_Remove> <== NOT EXECUTED
4000b470: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED
4000b474: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED
4000b478: 7f ff ef 36 call 40007150 <_Thread_Clear_state>
4000b47c: 81 e8 00 00 restore
4000b484 <_Thread_queue_Process_timeout>:
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
4000b484: c4 02 20 44 ld [ %o0 + 0x44 ], %g2
* 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 &&
4000b488: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3
4000b48c: 80 a0 e0 00 cmp %g3, 0
4000b490: 02 80 00 0f be 4000b4cc <_Thread_queue_Process_timeout+0x48>
4000b494: 92 10 00 08 mov %o0, %o1
4000b498: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000b49c: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
4000b4a0: 80 a2 00 01 cmp %o0, %g1
4000b4a4: 32 80 00 0b bne,a 4000b4d0 <_Thread_queue_Process_timeout+0x4c><== NEVER TAKEN
4000b4a8: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
4000b4ac: 80 a0 e0 03 cmp %g3, 3
4000b4b0: 02 80 00 0d be 4000b4e4 <_Thread_queue_Process_timeout+0x60><== NEVER TAKEN
4000b4b4: 01 00 00 00 nop
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4000b4b8: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1
4000b4bc: c2 22 20 34 st %g1, [ %o0 + 0x34 ]
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
4000b4c0: 82 10 20 02 mov 2, %g1
4000b4c4: 81 c3 e0 08 retl
4000b4c8: c2 20 a0 30 st %g1, [ %g2 + 0x30 ]
}
} else {
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
4000b4cc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
4000b4d0: d0 02 60 44 ld [ %o1 + 0x44 ], %o0
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;
4000b4d4: c2 22 60 34 st %g1, [ %o1 + 0x34 ]
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
4000b4d8: 82 13 c0 00 mov %o7, %g1
4000b4dc: 7f ff ff a8 call 4000b37c <_Thread_queue_Extract>
4000b4e0: 9e 10 40 00 mov %g1, %o7
4000b4e4: 81 c3 e0 08 retl <== NOT EXECUTED
40007d94 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
40007d94: 9d e3 bf 90 save %sp, -112, %sp
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
40007d98: 80 a6 20 00 cmp %i0, 0
40007d9c: 02 80 00 19 be 40007e00 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
40007da0: 01 00 00 00 nop
/*
* 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 ) {
40007da4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
40007da8: 80 a4 20 01 cmp %l0, 1
40007dac: 12 80 00 15 bne 40007e00 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
40007db0: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
40007db4: 7f ff e7 ca call 40001cdc <sparc_disable_interrupts>
40007db8: 01 00 00 00 nop
40007dbc: a2 10 00 08 mov %o0, %l1
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
40007dc0: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
40007dc4: 03 00 00 ef sethi %hi(0x3bc00), %g1
40007dc8: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
40007dcc: 80 88 80 01 btst %g2, %g1
40007dd0: 02 80 00 0a be 40007df8 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
40007dd4: 94 10 20 01 mov 1, %o2
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
40007dd8: 90 10 00 18 mov %i0, %o0
40007ddc: 92 10 00 19 mov %i1, %o1
40007de0: 40 00 0d 72 call 4000b3a8 <_Thread_queue_Extract_priority_helper>
40007de4: e0 26 20 30 st %l0, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
40007de8: 90 10 00 18 mov %i0, %o0
40007dec: 92 10 00 19 mov %i1, %o1
40007df0: 7f ff ff 38 call 40007ad0 <_Thread_queue_Enqueue_priority>
40007df4: 94 07 bf f4 add %fp, -12, %o2
}
_ISR_Enable( level );
40007df8: 7f ff e7 bd call 40001cec <sparc_enable_interrupts>
40007dfc: 90 10 00 11 mov %l1, %o0
40007e00: 81 c7 e0 08 ret
40007e04: 81 e8 00 00 restore
40007e08 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored
)
{
40007e08: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
40007e0c: 90 10 00 18 mov %i0, %o0
40007e10: 7f ff fd d8 call 40007570 <_Thread_Get>
40007e14: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40007e18: c2 07 bf f4 ld [ %fp + -12 ], %g1
40007e1c: 80 a0 60 00 cmp %g1, 0
40007e20: 12 80 00 08 bne 40007e40 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
40007e24: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
40007e28: 40 00 0d 97 call 4000b484 <_Thread_queue_Process_timeout>
40007e2c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
40007e30: 05 10 00 5f sethi %hi(0x40017c00), %g2
40007e34: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
40007e38: 82 00 7f ff add %g1, -1, %g1
40007e3c: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
40007e40: 81 c7 e0 08 ret
40007e44: 81 e8 00 00 restore
40011a58 <_Timer_Server_body>:
* @param[in] ignored is the the task argument that is ignored
*/
Thread _Timer_Server_body(
uint32_t ignored
)
{
40011a58: 9d e3 bf 88 save %sp, -120, %sp
40011a5c: 07 10 00 c6 sethi %hi(0x40031800), %g3
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
40011a60: 09 10 00 c6 sethi %hi(0x40031800), %g4
40011a64: c4 01 23 84 ld [ %g4 + 0x384 ], %g2 ! 40031b84 <_Watchdog_Ticks_since_boot>
40011a68: c2 00 e2 30 ld [ %g3 + 0x230 ], %g1
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
40011a6c: 1b 10 00 c6 sethi %hi(0x40031800), %o5
40011a70: d8 03 62 c0 ld [ %o5 + 0x2c0 ], %o4 ! 40031ac0 <_TOD_Now>
40011a74: 82 00 60 01 inc %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
40011a78: ac 07 bf ec add %fp, -20, %l6
40011a7c: c2 20 e2 30 st %g1, [ %g3 + 0x230 ]
40011a80: b6 07 bf f0 add %fp, -16, %i3
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
40011a84: 03 10 00 c6 sethi %hi(0x40031800), %g1
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
40011a88: c0 27 bf f0 clr [ %fp + -16 ]
40011a8c: c4 20 61 3c st %g2, [ %g1 + 0x13c ]
the_chain->last = _Chain_Head(the_chain);
40011a90: ec 27 bf f4 st %l6, [ %fp + -12 ]
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
40011a94: 05 10 00 c6 sethi %hi(0x40031800), %g2
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40011a98: f6 27 bf ec st %i3, [ %fp + -20 ]
40011a9c: d8 20 a1 38 st %o4, [ %g2 + 0x138 ]
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
40011aa0: 82 10 61 3c or %g1, 0x13c, %g1
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
40011aa4: 84 10 a1 38 or %g2, 0x138, %g2
40011aa8: 86 10 e2 30 or %g3, 0x230, %g3
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
if ( snapshot >= _Timer_Server_ticks_last_time )
40011aac: b8 10 00 01 mov %g1, %i4
40011ab0: a4 10 00 03 mov %g3, %l2
/*
* Insert the timers that were inserted before we got to run.
* This should be done with dispatching disabled.
*/
_Thread_Disable_dispatch();
_Timer_Server_process_insertions();
40011ab4: 7f ff ff cc call 400119e4 <_Timer_Server_process_insertions>
40011ab8: ba 10 00 02 mov %g2, %i5
_Thread_Enable_dispatch();
40011abc: 40 00 0b 4c call 400147ec <_Thread_Enable_dispatch>
40011ac0: ae 10 00 16 mov %l6, %l7
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
40011ac4: 03 10 00 c7 sethi %hi(0x40031c00), %g1
40011ac8: aa 10 61 94 or %g1, 0x194, %l5 ! 40031d94 <_Timer_Server>
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
40011acc: 03 10 00 c6 sethi %hi(0x40031800), %g1
40011ad0: a8 10 61 2c or %g1, 0x12c, %l4 ! 4003192c <_Timer_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40011ad4: 03 10 00 c6 sethi %hi(0x40031800), %g1
40011ad8: a2 10 61 40 or %g1, 0x140, %l1 ! 40031940 <_Timer_Seconds_chain>
40011adc: 03 10 00 c6 sethi %hi(0x40031800), %g1
40011ae0: a6 10 61 58 or %g1, 0x158, %l3 ! 40031958 <_Timer_Seconds_timer>
_Timer_Server_reset_ticks_timer();
40011ae4: b2 05 20 04 add %l4, 4, %i1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40011ae8: 03 10 00 c6 sethi %hi(0x40031800), %g1
_Timer_Server_reset_seconds_timer();
40011aec: b4 04 60 04 add %l1, 4, %i2
40011af0: b0 10 63 04 or %g1, 0x304, %i0
40011af4: c2 04 80 00 ld [ %l2 ], %g1
40011af8: 82 00 60 01 inc %g1
40011afc: c2 24 80 00 st %g1, [ %l2 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
40011b00: d0 05 40 00 ld [ %l5 ], %o0
40011b04: 40 00 0d f2 call 400152cc <_Thread_Set_state>
40011b08: 92 10 20 08 mov 8, %o1
40011b0c: c2 05 00 00 ld [ %l4 ], %g1
_Timer_Server_reset_ticks_timer();
40011b10: 80 a0 40 19 cmp %g1, %i1
40011b14: 02 80 00 08 be 40011b34 <_Timer_Server_body+0xdc>
40011b18: 11 10 00 c6 sethi %hi(0x40031800), %o0
40011b1c: d2 05 40 00 ld [ %l5 ], %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40011b20: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40011b24: c2 22 60 54 st %g1, [ %o1 + 0x54 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40011b28: 90 12 23 10 or %o0, 0x310, %o0
40011b2c: 40 00 10 db call 40015e98 <_Watchdog_Insert>
40011b30: 92 02 60 48 add %o1, 0x48, %o1
40011b34: c2 04 40 00 ld [ %l1 ], %g1
_Timer_Server_reset_seconds_timer();
40011b38: 80 a0 40 1a cmp %g1, %i2
40011b3c: 02 80 00 07 be 40011b58 <_Timer_Server_body+0x100>
40011b40: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40011b44: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40011b48: 90 10 00 18 mov %i0, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40011b4c: c2 24 e0 0c st %g1, [ %l3 + 0xc ]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40011b50: 40 00 10 d2 call 40015e98 <_Watchdog_Insert>
40011b54: 92 10 00 13 mov %l3, %o1
_Thread_Enable_dispatch();
40011b58: 40 00 0b 25 call 400147ec <_Thread_Enable_dispatch>
40011b5c: 01 00 00 00 nop
40011b60: c2 04 80 00 ld [ %l2 ], %g1
40011b64: 82 00 60 01 inc %g1
40011b68: c2 24 80 00 st %g1, [ %l2 ]
/*
* At this point, at least one of the timers this task relies
* upon has fired. Stop them both while we process any outstanding
* timers. Before we block, we will restart them.
*/
_Timer_Server_stop_ticks_timer();
40011b6c: d0 05 40 00 ld [ %l5 ], %o0
40011b70: 40 00 11 24 call 40016000 <_Watchdog_Remove>
40011b74: 90 02 20 48 add %o0, 0x48, %o0
_Timer_Server_stop_seconds_timer();
40011b78: 40 00 11 22 call 40016000 <_Watchdog_Remove>
40011b7c: 90 10 00 13 mov %l3, %o0
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
if ( snapshot >= _Timer_Server_ticks_last_time )
40011b80: c4 07 00 00 ld [ %i4 ], %g2
)
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
40011b84: 03 10 00 c6 sethi %hi(0x40031800), %g1
40011b88: 82 10 63 84 or %g1, 0x384, %g1 ! 40031b84 <_Watchdog_Ticks_since_boot>
40011b8c: c6 00 40 00 ld [ %g1 ], %g3
if ( snapshot >= _Timer_Server_ticks_last_time )
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
40011b90: 82 38 00 02 xnor %g0, %g2, %g1
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
if ( snapshot >= _Timer_Server_ticks_last_time )
40011b94: 80 a0 c0 02 cmp %g3, %g2
40011b98: 0a 80 00 03 bcs 40011ba4 <_Timer_Server_body+0x14c> <== NEVER TAKEN
40011b9c: 92 00 40 03 add %g1, %g3, %o1
ticks = snapshot - _Timer_Server_ticks_last_time;
40011ba0: 92 20 c0 02 sub %g3, %g2, %o1
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
_Timer_Server_ticks_last_time = snapshot;
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
40011ba4: 94 10 00 17 mov %l7, %o2
if ( snapshot >= _Timer_Server_ticks_last_time )
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
_Timer_Server_ticks_last_time = snapshot;
40011ba8: c6 27 00 00 st %g3, [ %i4 ]
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
40011bac: 40 00 10 86 call 40015dc4 <_Watchdog_Adjust_to_chain>
40011bb0: 90 10 00 14 mov %l4, %o0
/*
* 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 _Timer_Seconds_chain to indicate this.
*/
snapshot = _TOD_Seconds_since_epoch;
40011bb4: 03 10 00 c6 sethi %hi(0x40031800), %g1
if ( snapshot > _Timer_Server_seconds_last_time ) {
40011bb8: d4 07 40 00 ld [ %i5 ], %o2
/*
* 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 _Timer_Seconds_chain to indicate this.
*/
snapshot = _TOD_Seconds_since_epoch;
40011bbc: 82 10 62 c0 or %g1, 0x2c0, %g1
40011bc0: e0 00 40 00 ld [ %g1 ], %l0
if ( snapshot > _Timer_Server_seconds_last_time ) {
40011bc4: 80 a4 00 0a cmp %l0, %o2
40011bc8: 08 80 00 06 bleu 40011be0 <_Timer_Server_body+0x188>
40011bcc: 92 24 00 0a sub %l0, %o2, %o1
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
ticks = snapshot - _Timer_Server_seconds_last_time;
_Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
40011bd0: 90 10 00 11 mov %l1, %o0
40011bd4: 40 00 10 7c call 40015dc4 <_Watchdog_Adjust_to_chain>
40011bd8: 94 10 00 17 mov %l7, %o2
40011bdc: 30 80 00 06 b,a 40011bf4 <_Timer_Server_body+0x19c>
} else if ( snapshot < _Timer_Server_seconds_last_time ) {
40011be0: 1a 80 00 05 bcc 40011bf4 <_Timer_Server_body+0x19c>
40011be4: 94 22 80 10 sub %o2, %l0, %o2
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
ticks = _Timer_Server_seconds_last_time - snapshot;
_Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks );
40011be8: 90 10 00 11 mov %l1, %o0
40011bec: 40 00 10 4f call 40015d28 <_Watchdog_Adjust>
40011bf0: 92 10 20 01 mov 1, %o1
_Timer_Server_process_seconds_chain( &to_fire );
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
40011bf4: 7f ff ff 7c call 400119e4 <_Timer_Server_process_insertions>
40011bf8: e0 27 40 00 st %l0, [ %i5 ]
/*
* Enable dispatching to process the set that are ready "to fire."
*/
_Thread_Enable_dispatch();
40011bfc: 40 00 0a fc call 400147ec <_Thread_Enable_dispatch>
40011c00: 01 00 00 00 nop
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
40011c04: 7f ff e6 24 call 4000b494 <sparc_disable_interrupts>
40011c08: 01 00 00 00 nop
40011c0c: 84 10 00 08 mov %o0, %g2
40011c10: e0 07 bf ec ld [ %fp + -20 ], %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
40011c14: 80 a4 00 1b cmp %l0, %i3
40011c18: 02 80 00 06 be 40011c30 <_Timer_Server_body+0x1d8>
40011c1c: 80 a4 20 00 cmp %l0, 0
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
40011c20: c2 04 00 00 ld [ %l0 ], %g1
the_chain->first = new_first;
40011c24: c2 27 bf ec st %g1, [ %fp + -20 ]
watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
if ( watch == NULL ) {
40011c28: 12 80 00 05 bne 40011c3c <_Timer_Server_body+0x1e4> <== ALWAYS TAKEN
40011c2c: ec 20 60 04 st %l6, [ %g1 + 4 ]
_ISR_Enable( level );
40011c30: 7f ff e6 1d call 4000b4a4 <sparc_enable_interrupts>
40011c34: 90 10 00 02 mov %g2, %o0
40011c38: 30 bf ff af b,a 40011af4 <_Timer_Server_body+0x9c>
break;
}
watch->state = WATCHDOG_INACTIVE;
40011c3c: c0 24 20 08 clr [ %l0 + 8 ]
_ISR_Enable( level );
40011c40: 7f ff e6 19 call 4000b4a4 <sparc_enable_interrupts>
40011c44: 01 00 00 00 nop
(*watch->routine)( watch->id, watch->user_data );
40011c48: d2 04 20 24 ld [ %l0 + 0x24 ], %o1
40011c4c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40011c50: 9f c0 40 00 call %g1
40011c54: d0 04 20 20 ld [ %l0 + 0x20 ], %o0
40011c58: 30 bf ff eb b,a 40011c04 <_Timer_Server_body+0x1ac>
400119e4 <_Timer_Server_process_insertions>:
* onto one of the Timer Server chains.
*
* @note It is only to be called from the Timer Server task.
*/
static void _Timer_Server_process_insertions(void)
{
400119e4: 9d e3 bf 98 save %sp, -104, %sp
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
400119e8: 03 10 00 c6 sethi %hi(0x40031800), %g1
400119ec: a4 10 61 4c or %g1, 0x14c, %l2 ! 4003194c <_Timer_To_be_inserted>
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
400119f0: 03 10 00 c6 sethi %hi(0x40031800), %g1
400119f4: a2 10 61 40 or %g1, 0x140, %l1 ! 40031940 <_Timer_Seconds_chain>
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
if ( the_timer == NULL )
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
400119f8: 03 10 00 c6 sethi %hi(0x40031800), %g1
400119fc: a0 10 61 2c or %g1, 0x12c, %l0 ! 4003192c <_Timer_Ticks_chain>
static void _Timer_Server_process_insertions(void)
{
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
40011a00: 40 00 02 86 call 40012418 <_Chain_Get>
40011a04: 90 10 00 12 mov %l2, %o0
if ( the_timer == NULL )
40011a08: 80 a2 20 00 cmp %o0, 0
40011a0c: 02 80 00 11 be 40011a50 <_Timer_Server_process_insertions+0x6c>
40011a10: 01 00 00 00 nop
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
40011a14: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40011a18: 80 a0 60 01 cmp %g1, 1
40011a1c: 12 80 00 05 bne 40011a30 <_Timer_Server_process_insertions+0x4c>
40011a20: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
40011a24: 92 02 20 10 add %o0, 0x10, %o1
40011a28: 10 80 00 05 b 40011a3c <_Timer_Server_process_insertions+0x58>
40011a2c: 90 10 00 10 mov %l0, %o0
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
40011a30: 12 80 00 05 bne 40011a44 <_Timer_Server_process_insertions+0x60><== NEVER TAKEN
40011a34: 92 02 20 10 add %o0, 0x10, %o1
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
40011a38: 90 10 00 11 mov %l1, %o0
40011a3c: 40 00 11 17 call 40015e98 <_Watchdog_Insert>
40011a40: 01 00 00 00 nop
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
40011a44: 7f ff ff e8 call 400119e4 <_Timer_Server_process_insertions>
40011a48: 01 00 00 00 nop
40011a4c: 30 bf ff ed b,a 40011a00 <_Timer_Server_process_insertions+0x1c>
40011a50: 81 c7 e0 08 ret
40011a54: 81 e8 00 00 restore
40009ff0 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
40009ff0: 9d e3 bf 98 save %sp, -104, %sp
* 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;
40009ff4: c2 06 40 00 ld [ %i1 ], %g1
right += rhs->tv_nsec;
40009ff8: de 06 60 04 ld [ %i1 + 4 ], %o7
* 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;
40009ffc: 91 38 60 1f sra %g1, 0x1f, %o0
4000a000: 92 10 00 01 mov %g1, %o1
4000a004: 83 30 60 1d srl %g1, 0x1d, %g1
4000a008: 87 2a 60 03 sll %o1, 3, %g3
4000a00c: 85 2a 20 03 sll %o0, 3, %g2
4000a010: 84 10 40 02 or %g1, %g2, %g2
4000a014: 83 30 e0 1b srl %g3, 0x1b, %g1
4000a018: 99 28 a0 05 sll %g2, 5, %o4
4000a01c: 9b 28 e0 05 sll %g3, 5, %o5
4000a020: 98 10 40 0c or %g1, %o4, %o4
4000a024: 9a a3 40 03 subcc %o5, %g3, %o5
4000a028: 83 33 60 1a srl %o5, 0x1a, %g1
4000a02c: 98 63 00 02 subx %o4, %g2, %o4
4000a030: 97 2b 60 06 sll %o5, 6, %o3
4000a034: 95 2b 20 06 sll %o4, 6, %o2
4000a038: 96 a2 c0 0d subcc %o3, %o5, %o3
4000a03c: 94 10 40 0a or %g1, %o2, %o2
4000a040: 94 62 80 0c subx %o2, %o4, %o2
4000a044: 96 82 c0 09 addcc %o3, %o1, %o3
4000a048: 94 42 80 08 addx %o2, %o0, %o2
4000a04c: 83 32 e0 1e srl %o3, 0x1e, %g1
4000a050: 85 2a a0 02 sll %o2, 2, %g2
4000a054: 84 10 40 02 or %g1, %g2, %g2
4000a058: 87 2a e0 02 sll %o3, 2, %g3
4000a05c: 96 82 c0 03 addcc %o3, %g3, %o3
4000a060: 94 42 80 02 addx %o2, %g2, %o2
4000a064: 83 32 e0 1e srl %o3, 0x1e, %g1
4000a068: 85 2a a0 02 sll %o2, 2, %g2
4000a06c: 84 10 40 02 or %g1, %g2, %g2
4000a070: 87 2a e0 02 sll %o3, 2, %g3
4000a074: 96 82 c0 03 addcc %o3, %g3, %o3
4000a078: 94 42 80 02 addx %o2, %g2, %o2
4000a07c: 83 32 e0 1e srl %o3, 0x1e, %g1
4000a080: 85 2a a0 02 sll %o2, 2, %g2
4000a084: 84 10 40 02 or %g1, %g2, %g2
4000a088: 87 2a e0 02 sll %o3, 2, %g3
4000a08c: 96 82 c0 03 addcc %o3, %g3, %o3
4000a090: 94 42 80 02 addx %o2, %g2, %o2
4000a094: 85 32 e0 17 srl %o3, 0x17, %g2
4000a098: 83 2a a0 09 sll %o2, 9, %g1
4000a09c: 9b 2a e0 09 sll %o3, 9, %o5
4000a0a0: 98 10 80 01 or %g2, %g1, %o4
right += rhs->tv_nsec;
4000a0a4: 96 83 40 0f addcc %o5, %o7, %o3
4000a0a8: 85 3b e0 1f sra %o7, 0x1f, %g2
/*
* 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;
4000a0ac: e4 06 20 04 ld [ %i0 + 4 ], %l2
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
4000a0b0: 94 43 00 02 addx %o4, %g2, %o2
if ( right == 0 ) {
4000a0b4: 80 92 80 0b orcc %o2, %o3, %g0
4000a0b8: 12 80 00 06 bne 4000a0d0 <_Timespec_Divide+0xe0> <== ALWAYS TAKEN
4000a0bc: d0 06 00 00 ld [ %i0 ], %o0
*ival_percentage = 0;
4000a0c0: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*fval_percentage = 0;
4000a0c4: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
4000a0c8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a0cc: 81 e8 00 00 restore <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000a0d0: 92 10 00 08 mov %o0, %o1
4000a0d4: 83 32 60 1d srl %o1, 0x1d, %g1
4000a0d8: 9b 2a 60 03 sll %o1, 3, %o5
4000a0dc: 91 3a 20 1f sra %o0, 0x1f, %o0
4000a0e0: 99 2a 20 03 sll %o0, 3, %o4
4000a0e4: 98 10 40 0c or %g1, %o4, %o4
4000a0e8: 83 33 60 1b srl %o5, 0x1b, %g1
4000a0ec: 85 2b 20 05 sll %o4, 5, %g2
4000a0f0: 87 2b 60 05 sll %o5, 5, %g3
4000a0f4: 84 10 40 02 or %g1, %g2, %g2
4000a0f8: 86 a0 c0 0d subcc %g3, %o5, %g3
4000a0fc: 83 30 e0 1a srl %g3, 0x1a, %g1
4000a100: 84 60 80 0c subx %g2, %o4, %g2
4000a104: 9b 28 e0 06 sll %g3, 6, %o5
4000a108: 99 28 a0 06 sll %g2, 6, %o4
4000a10c: 9a a3 40 03 subcc %o5, %g3, %o5
4000a110: 98 10 40 0c or %g1, %o4, %o4
4000a114: 98 63 00 02 subx %o4, %g2, %o4
4000a118: 9a 83 40 09 addcc %o5, %o1, %o5
4000a11c: 83 33 60 1e srl %o5, 0x1e, %g1
4000a120: 98 43 00 08 addx %o4, %o0, %o4
4000a124: 87 2b 60 02 sll %o5, 2, %g3
4000a128: 85 2b 20 02 sll %o4, 2, %g2
4000a12c: 9a 83 40 03 addcc %o5, %g3, %o5
4000a130: 84 10 40 02 or %g1, %g2, %g2
4000a134: 83 33 60 1e srl %o5, 0x1e, %g1
4000a138: 98 43 00 02 addx %o4, %g2, %o4
4000a13c: 87 2b 60 02 sll %o5, 2, %g3
4000a140: 85 2b 20 02 sll %o4, 2, %g2
4000a144: 9a 83 40 03 addcc %o5, %g3, %o5
4000a148: 84 10 40 02 or %g1, %g2, %g2
4000a14c: 83 33 60 1e srl %o5, 0x1e, %g1
4000a150: 98 43 00 02 addx %o4, %g2, %o4
4000a154: 87 2b 60 02 sll %o5, 2, %g3
4000a158: 85 2b 20 02 sll %o4, 2, %g2
4000a15c: 9a 83 40 03 addcc %o5, %g3, %o5
4000a160: 84 10 40 02 or %g1, %g2, %g2
4000a164: 98 43 00 02 addx %o4, %g2, %o4
4000a168: 83 2b 20 09 sll %o4, 9, %g1
4000a16c: 85 33 60 17 srl %o5, 0x17, %g2
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
4000a170: a6 10 00 12 mov %l2, %l3
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
4000a174: a0 10 80 01 or %g2, %g1, %l0
4000a178: a3 2b 60 09 sll %o5, 9, %l1
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
4000a17c: a2 84 40 13 addcc %l1, %l3, %l1
4000a180: 83 34 60 1e srl %l1, 0x1e, %g1
4000a184: 87 2c 60 02 sll %l1, 2, %g3
4000a188: a5 3c a0 1f sra %l2, 0x1f, %l2
4000a18c: a0 44 00 12 addx %l0, %l2, %l0
4000a190: 85 2c 20 02 sll %l0, 2, %g2
4000a194: 84 10 40 02 or %g1, %g2, %g2
4000a198: 83 30 e0 1b srl %g3, 0x1b, %g1
4000a19c: 99 28 a0 05 sll %g2, 5, %o4
4000a1a0: 9b 28 e0 05 sll %g3, 5, %o5
4000a1a4: 98 10 40 0c or %g1, %o4, %o4
4000a1a8: 9a a3 40 03 subcc %o5, %g3, %o5
4000a1ac: 98 63 00 02 subx %o4, %g2, %o4
4000a1b0: 9a 83 40 11 addcc %o5, %l1, %o5
4000a1b4: 83 33 60 1e srl %o5, 0x1e, %g1
4000a1b8: 98 43 00 10 addx %o4, %l0, %o4
4000a1bc: 87 2b 60 02 sll %o5, 2, %g3
4000a1c0: 85 2b 20 02 sll %o4, 2, %g2
4000a1c4: 9a 83 40 03 addcc %o5, %g3, %o5
4000a1c8: 84 10 40 02 or %g1, %g2, %g2
4000a1cc: 83 33 60 1e srl %o5, 0x1e, %g1
4000a1d0: 87 2b 60 02 sll %o5, 2, %g3
4000a1d4: 98 43 00 02 addx %o4, %g2, %o4
4000a1d8: 9a 83 40 03 addcc %o5, %g3, %o5
4000a1dc: 85 2b 20 02 sll %o4, 2, %g2
4000a1e0: 84 10 40 02 or %g1, %g2, %g2
4000a1e4: 83 33 60 1b srl %o5, 0x1b, %g1
4000a1e8: 98 43 00 02 addx %o4, %g2, %o4
4000a1ec: 99 2b 20 05 sll %o4, 5, %o4
4000a1f0: 98 10 40 0c or %g1, %o4, %o4
4000a1f4: 93 2b 60 05 sll %o5, 5, %o1
4000a1f8: 40 00 32 ff call 40016df4 <__udivdi3>
4000a1fc: 90 10 00 0c mov %o4, %o0
*ival_percentage = answer / 1000;
4000a200: 94 10 20 00 clr %o2
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
4000a204: a0 10 00 08 mov %o0, %l0
4000a208: a2 10 00 09 mov %o1, %l1
*ival_percentage = answer / 1000;
4000a20c: 96 10 23 e8 mov 0x3e8, %o3
4000a210: 40 00 32 f9 call 40016df4 <__udivdi3>
4000a214: 90 10 00 10 mov %l0, %o0
*fval_percentage = answer % 1000;
4000a218: 90 10 00 10 mov %l0, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
4000a21c: d2 26 80 00 st %o1, [ %i2 ]
*fval_percentage = answer % 1000;
4000a220: 94 10 20 00 clr %o2
4000a224: 92 10 00 11 mov %l1, %o1
4000a228: 40 00 33 cf call 40017164 <__umoddi3>
4000a22c: 96 10 23 e8 mov 0x3e8, %o3
4000a230: d2 26 c0 00 st %o1, [ %i3 ]
4000a234: 81 c7 e0 08 ret
4000a238: 81 e8 00 00 restore
4000a3a0 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
4000a3a0: c4 02 00 00 ld [ %o0 ], %g2
4000a3a4: c2 02 40 00 ld [ %o1 ], %g1
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
4000a3a8: 86 10 00 08 mov %o0, %g3
if ( lhs->tv_sec > rhs->tv_sec )
4000a3ac: 80 a0 80 01 cmp %g2, %g1
4000a3b0: 14 80 00 0b bg 4000a3dc <_Timespec_Greater_than+0x3c> <== NEVER TAKEN
4000a3b4: 90 10 20 01 mov 1, %o0
return TRUE;
if ( lhs->tv_sec < rhs->tv_sec )
4000a3b8: 80 a0 80 01 cmp %g2, %g1
4000a3bc: 06 80 00 08 bl 4000a3dc <_Timespec_Greater_than+0x3c> <== NEVER TAKEN
4000a3c0: 90 10 20 00 clr %o0
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
4000a3c4: c4 00 e0 04 ld [ %g3 + 4 ], %g2
4000a3c8: c2 02 60 04 ld [ %o1 + 4 ], %g1
4000a3cc: 80 a0 80 01 cmp %g2, %g1
4000a3d0: 14 80 00 03 bg 4000a3dc <_Timespec_Greater_than+0x3c>
4000a3d4: 90 10 20 01 mov 1, %o0
4000a3d8: 90 10 20 00 clr %o0
return TRUE;
return FALSE;
}
4000a3dc: 81 c3 e0 08 retl
4000a3e4 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
4000a3e4: c4 02 00 00 ld [ %o0 ], %g2
4000a3e8: c2 02 40 00 ld [ %o1 ], %g1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
4000a3ec: 86 10 00 08 mov %o0, %g3
if ( lhs->tv_sec < rhs->tv_sec )
4000a3f0: 80 a0 80 01 cmp %g2, %g1
4000a3f4: 06 80 00 0b bl 4000a420 <_Timespec_Less_than+0x3c>
4000a3f8: 90 10 20 01 mov 1, %o0
return TRUE;
if ( lhs->tv_sec > rhs->tv_sec )
4000a3fc: 80 a0 80 01 cmp %g2, %g1
4000a400: 14 80 00 08 bg 4000a420 <_Timespec_Less_than+0x3c> <== NEVER TAKEN
4000a404: 90 10 20 00 clr %o0
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
4000a408: c4 00 e0 04 ld [ %g3 + 4 ], %g2
4000a40c: c2 02 60 04 ld [ %o1 + 4 ], %g1
4000a410: 80 a0 80 01 cmp %g2, %g1
4000a414: 06 80 00 03 bl 4000a420 <_Timespec_Less_than+0x3c>
4000a418: 90 10 20 01 mov 1, %o0
4000a41c: 90 10 20 00 clr %o0
return TRUE;
return FALSE;
}
4000a420: 81 c3 e0 08 retl
4000b6c4 <_User_extensions_Add_API_set>:
*/
void _User_extensions_Add_API_set (
User_extensions_Control *the_extension
)
{
4000b6c4: 9d e3 bf 98 save %sp, -104, %sp
_Chain_Append( &_User_extensions_List, &the_extension->Node );
4000b6c8: 11 10 00 60 sethi %hi(0x40018000), %o0
4000b6cc: 92 10 00 18 mov %i0, %o1
4000b6d0: 7f ff e9 df call 40005e4c <_Chain_Append>
4000b6d4: 90 12 21 08 or %o0, 0x108, %o0
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
4000b6d8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000b6dc: 80 a0 60 00 cmp %g1, 0
4000b6e0: 02 80 00 06 be 4000b6f8 <_User_extensions_Add_API_set+0x34><== NEVER TAKEN
4000b6e4: b2 06 20 08 add %i0, 8, %i1
the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
4000b6e8: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
_Chain_Append(
4000b6ec: 31 10 00 5f sethi %hi(0x40017c00), %i0
4000b6f0: 7f ff e9 d7 call 40005e4c <_Chain_Append>
4000b6f4: 91 ee 22 d4 restore %i0, 0x2d4, %o0
4000b6f8: 81 c7 e0 08 ret <== NOT EXECUTED
4000b6fc: 81 e8 00 00 restore <== NOT EXECUTED
4000a748 <_User_extensions_Remove_set>:
*/
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
4000a748: 9d e3 bf 98 save %sp, -104, %sp
_Chain_Extract( &the_extension->Node );
4000a74c: 40 00 0a 53 call 4000d098 <_Chain_Extract>
4000a750: 90 10 00 18 mov %i0, %o0
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
4000a754: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000a758: 80 a0 60 00 cmp %g1, 0
4000a75c: 02 80 00 04 be 4000a76c <_User_extensions_Remove_set+0x24><== ALWAYS TAKEN
4000a760: 01 00 00 00 nop
_Chain_Extract( &the_extension->Switch.Node );
4000a764: 40 00 0a 4d call 4000d098 <_Chain_Extract>
4000a768: 91 ee 20 08 restore %i0, 8, %o0
4000a76c: 81 c7 e0 08 ret
4000a770: 81 e8 00 00 restore
40008568 <_User_extensions_Thread_create>:
*/
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
40008568: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
4000856c: 03 10 00 60 sethi %hi(0x40018000), %g1
40008570: e0 00 61 08 ld [ %g1 + 0x108 ], %l0 ! 40018108 <_User_extensions_List>
40008574: 82 10 61 08 or %g1, 0x108, %g1
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
40008578: a4 00 60 04 add %g1, 4, %l2
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)(
4000857c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40008580: 10 80 00 0d b 400085b4 <_User_extensions_Thread_create+0x4c>
40008584: a2 10 63 90 or %g1, 0x390, %l1 ! 40017f90 <_Thread_Executing>
!_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 ) {
40008588: 80 a0 60 00 cmp %g1, 0
4000858c: 02 80 00 09 be 400085b0 <_User_extensions_Thread_create+0x48>
40008590: 92 10 00 18 mov %i0, %o1
status = (*the_extension->Callouts.thread_create)(
40008594: 9f c0 40 00 call %g1
40008598: d0 04 40 00 ld [ %l1 ], %o0
_Thread_Executing,
the_thread
);
if ( !status )
4000859c: 80 8a 20 ff btst 0xff, %o0
400085a0: 32 80 00 05 bne,a 400085b4 <_User_extensions_Thread_create+0x4c><== ALWAYS TAKEN
400085a4: e0 04 00 00 ld [ %l0 ], %l0
400085a8: 81 c7 e0 08 ret <== NOT EXECUTED
400085ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
400085b0: e0 04 00 00 ld [ %l0 ], %l0
Chain_Node *the_node;
User_extensions_Control *the_extension;
bool status;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
400085b4: 80 a4 00 12 cmp %l0, %l2
400085b8: 32 bf ff f4 bne,a 40008588 <_User_extensions_Thread_create+0x20>
400085bc: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
return FALSE;
}
}
return TRUE;
}
400085c0: 81 c7 e0 08 ret
400085c4: 91 e8 20 01 restore %g0, 1, %o0
4000a580 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
4000a580: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
_ISR_Disable( level );
4000a584: 7f ff e1 49 call 40002aa8 <sparc_disable_interrupts>
4000a588: a0 10 00 1a mov %i2, %l0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
4000a58c: c4 06 00 00 ld [ %i0 ], %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
4000a590: a2 06 20 04 add %i0, 4, %l1
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
4000a594: 80 a0 80 11 cmp %g2, %l1
4000a598: 02 80 00 1e be 4000a610 <_Watchdog_Adjust+0x90>
4000a59c: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
4000a5a0: 02 80 00 19 be 4000a604 <_Watchdog_Adjust+0x84>
4000a5a4: a4 10 20 01 mov 1, %l2
4000a5a8: 80 a6 60 01 cmp %i1, 1
4000a5ac: 12 80 00 19 bne 4000a610 <_Watchdog_Adjust+0x90> <== NEVER TAKEN
4000a5b0: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
4000a5b4: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
4000a5b8: 10 80 00 07 b 4000a5d4 <_Watchdog_Adjust+0x54>
4000a5bc: 82 00 40 1a add %g1, %i2, %g1
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
4000a5c0: f4 00 a0 10 ld [ %g2 + 0x10 ], %i2
4000a5c4: 80 a4 00 1a cmp %l0, %i2
4000a5c8: 3a 80 00 05 bcc,a 4000a5dc <_Watchdog_Adjust+0x5c>
4000a5cc: e4 20 a0 10 st %l2, [ %g2 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
4000a5d0: 82 26 80 10 sub %i2, %l0, %g1
4000a5d4: 10 80 00 0f b 4000a610 <_Watchdog_Adjust+0x90>
4000a5d8: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
4000a5dc: 7f ff e1 37 call 40002ab8 <sparc_enable_interrupts>
4000a5e0: 01 00 00 00 nop
_Watchdog_Tickle( header );
4000a5e4: 40 00 00 92 call 4000a82c <_Watchdog_Tickle>
4000a5e8: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
4000a5ec: 7f ff e1 2f call 40002aa8 <sparc_disable_interrupts>
4000a5f0: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
4000a5f4: c2 06 00 00 ld [ %i0 ], %g1
4000a5f8: 80 a0 40 11 cmp %g1, %l1
4000a5fc: 02 80 00 05 be 4000a610 <_Watchdog_Adjust+0x90>
4000a600: a0 24 00 1a sub %l0, %i2, %l0
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
4000a604: 80 a4 20 00 cmp %l0, 0
4000a608: 32 bf ff ee bne,a 4000a5c0 <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
4000a60c: c4 06 00 00 ld [ %i0 ], %g2
}
break;
}
}
_ISR_Enable( level );
4000a610: 7f ff e1 2a call 40002ab8 <sparc_enable_interrupts>
4000a614: 91 e8 00 08 restore %g0, %o0, %o0
40015dc4 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
40015dc4: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval units = units_arg;
ISR_Level level;
Chain_Node *node;
if ( !units ) {
40015dc8: 80 a6 60 00 cmp %i1, 0
40015dcc: 02 80 00 31 be 40015e90 <_Watchdog_Adjust_to_chain+0xcc>
40015dd0: 01 00 00 00 nop
return;
}
_ISR_Disable( level );
40015dd4: 7f ff d5 b0 call 4000b494 <sparc_disable_interrupts>
40015dd8: 01 00 00 00 nop
40015ddc: a4 10 00 08 mov %o0, %l2
if ( !_Chain_Is_empty( header ) ) {
40015de0: c2 06 00 00 ld [ %i0 ], %g1
40015de4: a2 06 20 04 add %i0, 4, %l1
40015de8: 80 a0 40 11 cmp %g1, %l1
40015dec: 02 80 00 27 be 40015e88 <_Watchdog_Adjust_to_chain+0xc4>
40015df0: 01 00 00 00 nop
40015df4: a6 06 a0 04 add %i2, 4, %l3
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
40015df8: c4 06 00 00 ld [ %i0 ], %g2
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
40015dfc: e0 00 a0 10 ld [ %g2 + 0x10 ], %l0
40015e00: 80 a6 40 10 cmp %i1, %l0
40015e04: 3a 80 00 05 bcc,a 40015e18 <_Watchdog_Adjust_to_chain+0x54>
40015e08: c0 20 a0 10 clr [ %g2 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
40015e0c: 82 24 00 19 sub %l0, %i1, %g1
40015e10: 10 80 00 1e b 40015e88 <_Watchdog_Adjust_to_chain+0xc4>
40015e14: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
40015e18: c4 06 00 00 ld [ %i0 ], %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
40015e1c: 80 a0 80 11 cmp %g2, %l1
40015e20: 32 80 00 04 bne,a 40015e30 <_Watchdog_Adjust_to_chain+0x6c><== ALWAYS TAKEN
40015e24: c2 00 80 00 ld [ %g2 ], %g1
40015e28: 10 80 00 04 b 40015e38 <_Watchdog_Adjust_to_chain+0x74> <== NOT EXECUTED
40015e2c: 84 10 20 00 clr %g2 <== NOT EXECUTED
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
40015e30: c2 26 00 00 st %g1, [ %i0 ]
new_first->previous = _Chain_Head(the_chain);
40015e34: f0 20 60 04 st %i0, [ %g1 + 4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
40015e38: e6 20 80 00 st %l3, [ %g2 ]
old_last_node = the_chain->last;
40015e3c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
the_chain->last = the_node;
40015e40: c4 26 a0 08 st %g2, [ %i2 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
40015e44: c2 20 a0 04 st %g1, [ %g2 + 4 ]
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
old_last_node = the_chain->last;
the_chain->last = the_node;
old_last_node->next = the_node;
40015e48: c4 20 40 00 st %g2, [ %g1 ]
do {
node = _Chain_Get_unprotected( header );
_Chain_Append_unprotected( to_fire, node );
_ISR_Flash( level );
40015e4c: 7f ff d5 96 call 4000b4a4 <sparc_enable_interrupts>
40015e50: 90 10 00 12 mov %l2, %o0
40015e54: 7f ff d5 90 call 4000b494 <sparc_disable_interrupts>
40015e58: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
40015e5c: c2 06 00 00 ld [ %i0 ], %g1
} while ( !_Chain_Is_empty( header ) &&
_Watchdog_First( header )->delta_interval == 0 );
40015e60: 80 a0 40 11 cmp %g1, %l1
40015e64: 02 80 00 09 be 40015e88 <_Watchdog_Adjust_to_chain+0xc4>
40015e68: 01 00 00 00 nop
40015e6c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
40015e70: 80 a0 60 00 cmp %g1, 0
40015e74: 22 bf ff ea be,a 40015e1c <_Watchdog_Adjust_to_chain+0x58>
40015e78: c4 06 00 00 ld [ %i0 ], %g2
return;
}
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
40015e7c: b2 a6 40 10 subcc %i1, %l0, %i1
40015e80: 32 bf ff df bne,a 40015dfc <_Watchdog_Adjust_to_chain+0x38><== NEVER TAKEN
40015e84: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
break;
}
}
}
_ISR_Enable( level );
40015e88: 7f ff d5 87 call 4000b4a4 <sparc_enable_interrupts>
40015e8c: 91 e8 00 12 restore %g0, %l2, %o0
40015e90: 81 c7 e0 08 ret
40015e94: 81 e8 00 00 restore
400086a0 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
400086a0: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
400086a4: 03 10 00 5f sethi %hi(0x40017c00), %g1
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
400086a8: aa 10 00 18 mov %i0, %l5
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
400086ac: e6 00 63 6c ld [ %g1 + 0x36c ], %l3
_ISR_Disable( level );
400086b0: 7f ff e5 8b call 40001cdc <sparc_disable_interrupts>
400086b4: 01 00 00 00 nop
400086b8: b0 10 00 08 mov %o0, %i0
/*
* 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 ) {
400086bc: c2 06 60 08 ld [ %i1 + 8 ], %g1
400086c0: 80 a0 60 00 cmp %g1, 0
400086c4: 02 80 00 03 be 400086d0 <_Watchdog_Insert+0x30> <== ALWAYS TAKEN
400086c8: 07 10 00 60 sethi %hi(0x40018000), %g3
_ISR_Enable( level );
400086cc: 30 80 00 39 b,a 400087b0 <_Watchdog_Insert+0x110> <== NOT EXECUTED
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
400086d0: c2 00 e0 20 ld [ %g3 + 0x20 ], %g1 ! 40018020 <_Watchdog_Sync_count>
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
400086d4: 84 10 20 01 mov 1, %g2
_Watchdog_Sync_count++;
400086d8: 82 00 60 01 inc %g1
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
400086dc: c4 26 60 08 st %g2, [ %i1 + 8 ]
_Watchdog_Sync_count++;
400086e0: c2 20 e0 20 st %g1, [ %g3 + 0x20 ]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
400086e4: 03 10 00 5f sethi %hi(0x40017c00), %g1
400086e8: a8 10 63 8c or %g1, 0x38c, %l4 ! 40017f8c <_Watchdog_Sync_level>
400086ec: ac 10 00 14 mov %l4, %l6
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
400086f0: e4 06 60 0c ld [ %i1 + 0xc ], %l2
* cache *header!!
*
* Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc)
*
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
400086f4: e2 05 40 00 ld [ %l5 ], %l1
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
400086f8: 80 a4 a0 00 cmp %l2, 0
400086fc: 22 80 00 1c be,a 4000876c <_Watchdog_Insert+0xcc>
40008700: c4 04 60 04 ld [ %l1 + 4 ], %g2
40008704: c2 04 40 00 ld [ %l1 ], %g1
40008708: 80 a0 60 00 cmp %g1, 0
4000870c: 22 80 00 18 be,a 4000876c <_Watchdog_Insert+0xcc>
40008710: c4 04 60 04 ld [ %l1 + 4 ], %g2
break;
if ( delta_interval < after->delta_interval ) {
40008714: e0 04 60 10 ld [ %l1 + 0x10 ], %l0
40008718: 80 a4 80 10 cmp %l2, %l0
4000871c: 1a 80 00 04 bcc 4000872c <_Watchdog_Insert+0x8c>
40008720: 82 24 00 12 sub %l0, %l2, %g1
after->delta_interval -= delta_interval;
40008724: 10 80 00 11 b 40008768 <_Watchdog_Insert+0xc8>
40008728: c2 24 60 10 st %g1, [ %l1 + 0x10 ]
* used around this flash point allowed interrupts to execute
* which violated the design assumptions. The critical section
* mechanism used here WAS redesigned to address this.
*/
_ISR_Flash( level );
4000872c: 7f ff e5 70 call 40001cec <sparc_enable_interrupts>
40008730: 90 10 00 18 mov %i0, %o0
40008734: 7f ff e5 6a call 40001cdc <sparc_disable_interrupts>
40008738: 01 00 00 00 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
4000873c: c2 06 60 08 ld [ %i1 + 8 ], %g1
40008740: 80 a0 60 01 cmp %g1, 1
40008744: 12 80 00 15 bne 40008798 <_Watchdog_Insert+0xf8> <== NEVER TAKEN
40008748: a4 24 80 10 sub %l2, %l0, %l2
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
4000874c: c2 05 00 00 ld [ %l4 ], %g1
40008750: 80 a0 40 13 cmp %g1, %l3
40008754: 28 bf ff e9 bleu,a 400086f8 <_Watchdog_Insert+0x58>
40008758: e2 04 40 00 ld [ %l1 ], %l1
_Watchdog_Sync_level = insert_isr_nest_level;
4000875c: e6 25 80 00 st %l3, [ %l6 ]
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
40008760: 10 bf ff e5 b 400086f4 <_Watchdog_Insert+0x54>
40008764: e4 06 60 0c ld [ %i1 + 0xc ], %l2
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
40008768: c4 04 60 04 ld [ %l1 + 4 ], %g2
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
4000876c: 03 10 00 60 sethi %hi(0x40018000), %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
40008770: c6 00 80 00 ld [ %g2 ], %g3
40008774: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
after_node->next = the_node;
40008778: f2 20 80 00 st %i1, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
4000877c: c4 26 60 04 st %g2, [ %i1 + 4 ]
40008780: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
40008784: e4 26 60 10 st %l2, [ %i1 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
40008788: 82 10 20 02 mov 2, %g1
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
before_node->previous = the_node;
4000878c: f2 20 e0 04 st %i1, [ %g3 + 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;
40008790: c6 26 40 00 st %g3, [ %i1 ]
40008794: c2 26 60 08 st %g1, [ %i1 + 8 ]
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
40008798: 03 10 00 5f sethi %hi(0x40017c00), %g1
_Watchdog_Sync_count--;
4000879c: 05 10 00 60 sethi %hi(0x40018000), %g2
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
exit_insert:
_Watchdog_Sync_level = insert_isr_nest_level;
400087a0: e6 20 63 8c st %l3, [ %g1 + 0x38c ]
_Watchdog_Sync_count--;
400087a4: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
400087a8: 82 00 7f ff add %g1, -1, %g1
400087ac: c2 20 a0 20 st %g1, [ %g2 + 0x20 ]
_ISR_Enable( level );
400087b0: 7f ff e5 4f call 40001cec <sparc_enable_interrupts>
400087b4: 81 e8 00 00 restore
40008808 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
40008808: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
4000880c: 7f ff e5 34 call 40001cdc <sparc_disable_interrupts>
40008810: 01 00 00 00 nop
previous_state = the_watchdog->state;
40008814: e0 06 20 08 ld [ %i0 + 8 ], %l0
switch ( previous_state ) {
40008818: 80 a4 20 01 cmp %l0, 1
4000881c: 22 80 00 1e be,a 40008894 <_Watchdog_Remove+0x8c> <== NEVER TAKEN
40008820: c0 26 20 08 clr [ %i0 + 8 ] <== NOT EXECUTED
40008824: 0a 80 00 1d bcs 40008898 <_Watchdog_Remove+0x90>
40008828: 03 10 00 60 sethi %hi(0x40018000), %g1
4000882c: 80 a4 20 03 cmp %l0, 3
40008830: 18 80 00 1a bgu 40008898 <_Watchdog_Remove+0x90> <== NEVER TAKEN
40008834: 01 00 00 00 nop
40008838: c6 06 00 00 ld [ %i0 ], %g3
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
4000883c: c0 26 20 08 clr [ %i0 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
40008840: c2 00 c0 00 ld [ %g3 ], %g1
40008844: 80 a0 60 00 cmp %g1, 0
40008848: 02 80 00 07 be 40008864 <_Watchdog_Remove+0x5c>
4000884c: 03 10 00 60 sethi %hi(0x40018000), %g1
next_watchdog->delta_interval += the_watchdog->delta_interval;
40008850: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
40008854: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40008858: 82 00 40 02 add %g1, %g2, %g1
4000885c: c2 20 e0 10 st %g1, [ %g3 + 0x10 ]
if ( _Watchdog_Sync_count )
40008860: 03 10 00 60 sethi %hi(0x40018000), %g1
40008864: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40018020 <_Watchdog_Sync_count>
40008868: 80 a0 60 00 cmp %g1, 0
4000886c: 22 80 00 07 be,a 40008888 <_Watchdog_Remove+0x80> <== ALWAYS TAKEN
40008870: c4 06 00 00 ld [ %i0 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
40008874: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40008878: c4 00 63 6c ld [ %g1 + 0x36c ], %g2 ! 40017f6c <_ISR_Nest_level><== NOT EXECUTED
4000887c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40008880: c4 20 63 8c st %g2, [ %g1 + 0x38c ] ! 40017f8c <_Watchdog_Sync_level><== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40008884: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
previous = the_node->previous;
40008888: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
previous->next = next;
4000888c: c4 20 40 00 st %g2, [ %g1 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
40008890: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
40008894: 03 10 00 60 sethi %hi(0x40018000), %g1
40008898: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 ! 40018024 <_Watchdog_Ticks_since_boot>
4000889c: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( level );
400088a0: 7f ff e5 13 call 40001cec <sparc_enable_interrupts>
400088a4: b0 10 00 10 mov %l0, %i0
return( previous_state );
}
400088a8: 81 c7 e0 08 ret
400088ac: 81 e8 00 00 restore
400088b0 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
400088b0: 9d e3 bf 98 save %sp, -104, %sp
* 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 );
400088b4: 7f ff e5 0a call 40001cdc <sparc_disable_interrupts>
400088b8: a4 10 00 18 mov %i0, %l2
400088bc: b0 10 00 08 mov %o0, %i0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
400088c0: c4 04 80 00 ld [ %l2 ], %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
400088c4: a6 04 a0 04 add %l2, 4, %l3
if ( _Chain_Is_empty( header ) )
400088c8: 80 a0 80 13 cmp %g2, %l3
400088cc: 02 80 00 20 be 4000894c <_Watchdog_Tickle+0x9c>
400088d0: 01 00 00 00 nop
* 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) {
400088d4: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
400088d8: 80 a0 60 00 cmp %g1, 0
400088dc: 02 80 00 07 be 400088f8 <_Watchdog_Tickle+0x48> <== NEVER TAKEN
400088e0: a2 10 00 02 mov %g2, %l1
the_watchdog->delta_interval--;
400088e4: 82 00 7f ff add %g1, -1, %g1
400088e8: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
if ( the_watchdog->delta_interval != 0 )
400088ec: 80 a0 60 00 cmp %g1, 0
400088f0: 12 80 00 17 bne 4000894c <_Watchdog_Tickle+0x9c>
400088f4: 01 00 00 00 nop
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
400088f8: 7f ff ff c4 call 40008808 <_Watchdog_Remove>
400088fc: 90 10 00 11 mov %l1, %o0
40008900: a0 10 00 08 mov %o0, %l0
_ISR_Enable( level );
40008904: 7f ff e4 fa call 40001cec <sparc_enable_interrupts>
40008908: 90 10 00 18 mov %i0, %o0
switch( watchdog_state ) {
4000890c: 80 a4 20 02 cmp %l0, 2
40008910: 12 80 00 06 bne 40008928 <_Watchdog_Tickle+0x78> <== NEVER TAKEN
40008914: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
40008918: d2 04 60 24 ld [ %l1 + 0x24 ], %o1
4000891c: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
40008920: 9f c0 40 00 call %g1
40008924: d0 04 60 20 ld [ %l1 + 0x20 ], %o0
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
40008928: 7f ff e4 ed call 40001cdc <sparc_disable_interrupts>
4000892c: 01 00 00 00 nop
40008930: b0 10 00 08 mov %o0, %i0
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
40008934: c2 04 80 00 ld [ %l2 ], %g1
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
40008938: 80 a0 40 13 cmp %g1, %l3
4000893c: 02 80 00 04 be 4000894c <_Watchdog_Tickle+0x9c>
40008940: a2 10 00 01 mov %g1, %l1
40008944: 10 bf ff ea b 400088ec <_Watchdog_Tickle+0x3c>
40008948: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
leave:
_ISR_Enable(level);
4000894c: 7f ff e4 e8 call 40001cec <sparc_enable_interrupts>
40008950: 81 e8 00 00 restore
400089c0 <_Workspace_Handler_initialization>:
*/
void _Workspace_Handler_initialization(
void *starting_address,
size_t size
)
{
400089c0: 9d e3 bf 98 save %sp, -104, %sp
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
400089c4: 80 a6 20 00 cmp %i0, 0
400089c8: 02 80 00 04 be 400089d8 <_Workspace_Handler_initialization+0x18>
400089cc: 80 8e 20 07 btst 7, %i0
400089d0: 02 80 00 06 be 400089e8 <_Workspace_Handler_initialization+0x28><== ALWAYS TAKEN
400089d4: 03 10 00 5f sethi %hi(0x40017c00), %g1
_Internal_error_Occurred(
400089d8: 90 10 20 00 clr %o0
400089dc: 92 10 20 01 mov 1, %o1
400089e0: 10 80 00 15 b 40008a34 <_Workspace_Handler_initialization+0x74>
400089e4: 94 10 20 02 mov 2, %o2
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
400089e8: c2 00 63 68 ld [ %g1 + 0x368 ], %g1
400089ec: c2 08 60 28 ldub [ %g1 + 0x28 ], %g1
400089f0: 80 a0 60 00 cmp %g1, 0
400089f4: 02 80 00 07 be 40008a10 <_Workspace_Handler_initialization+0x50><== ALWAYS TAKEN
400089f8: 92 10 00 18 mov %i0, %o1
memset( starting_address, 0, size );
400089fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40008a00: 92 10 20 00 clr %o1 <== NOT EXECUTED
40008a04: 40 00 0f fd call 4000c9f8 <memset> <== NOT EXECUTED
40008a08: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
memory_available = _Heap_Initialize(
40008a0c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40008a10: 94 10 00 19 mov %i1, %o2
40008a14: 11 10 00 5f sethi %hi(0x40017c00), %o0
40008a18: 96 10 20 08 mov 8, %o3
40008a1c: 7f ff f6 62 call 400063a4 <_Heap_Initialize>
40008a20: 90 12 22 f4 or %o0, 0x2f4, %o0
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
40008a24: 80 a2 20 00 cmp %o0, 0
40008a28: 12 80 00 05 bne 40008a3c <_Workspace_Handler_initialization+0x7c><== ALWAYS TAKEN
40008a2c: 92 10 20 01 mov 1, %o1
_Internal_error_Occurred(
40008a30: 94 10 20 03 mov 3, %o2 <== NOT EXECUTED
40008a34: 7f ff f6 e6 call 400065cc <_Internal_error_Occurred>
40008a38: 01 00 00 00 nop
40008a3c: 81 c7 e0 08 ret
40008a40: 81 e8 00 00 restore
40001e80 <__assert>:
void __assert(
const char *file,
int line,
const char *failedexpr
)
{
40001e80: 96 10 00 0a mov %o2, %o3 <== NOT EXECUTED
__assert_func (file, line, NULL, failedexpr);
40001e84: 94 10 20 00 clr %o2 <== NOT EXECUTED
40001e88: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40001e8c: 7f ff ff eb call 40001e38 <__assert_func> <== NOT EXECUTED
40001e90: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40001e38 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
40001e38: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
40001e3c: 03 10 00 58 sethi %hi(0x40016000), %g1 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
40001e40: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
40001e44: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40001e48: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40001e4c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
40001e50: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40001e54: 12 80 00 05 bne 40001e68 <__assert_func+0x30> <== NOT EXECUTED
40001e58: 98 10 63 c8 or %g1, 0x3c8, %o4 <== NOT EXECUTED
40001e5c: 03 10 00 58 sethi %hi(0x40016000), %g1 <== NOT EXECUTED
40001e60: 9a 10 62 d0 or %g1, 0x2d0, %o5 ! 400162d0 <__func__.4755+0x148><== NOT EXECUTED
40001e64: 98 10 00 0d mov %o5, %o4 <== NOT EXECUTED
40001e68: 11 10 00 58 sethi %hi(0x40016000), %o0 <== NOT EXECUTED
40001e6c: 40 00 03 87 call 40002c88 <printk> <== NOT EXECUTED
40001e70: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 400163d8 <__func__.4755+0x250><== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
40001e74: 40 00 0f 1d call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40001e78: 90 10 20 00 clr %o0 <== NOT EXECUTED
40018d7c <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
40018d7c: 81 c3 e0 08 retl <== NOT EXECUTED
40018d80: 90 10 20 00 clr %o0 <== NOT EXECUTED
400155c4 <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
_fini();
400155c4: 9d e3 bf 98 save %sp, -104, %sp
400155c8: 40 00 06 db call 40017134 <_fini>
400155cc: 01 00 00 00 nop
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
400155d0: 7f ff ff e1 call 40015554 <libc_wrapup>
400155d4: 01 00 00 00 nop
rtems_shutdown_executive(status);
400155d8: 40 00 00 4e call 40015710 <rtems_shutdown_executive>
400155dc: 90 10 00 18 mov %i0, %o0
400155e0: 30 80 00 00 b,a 400155e0 <_exit+0x1c> <== NOT EXECUTED
40018c00 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr
)
{
return getpid();
}
40018c00: 81 c3 e0 08 retl <== NOT EXECUTED
40018c04: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
4000a0a8 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
4000a0a8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4000a0ac: 7f ff ff e6 call 4000a044 <gettimeofday> <== NOT EXECUTED
4000a0b0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40018d74 <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
40018d74: 81 c3 e0 08 retl <== NOT EXECUTED
40018d78: 90 10 20 00 clr %o0 <== NOT EXECUTED
40015524 <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
40015524: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40015528: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4001552c: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
40015530: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40015534: 7f ff ff bf call 40015430 <lseek> <== NOT EXECUTED
40015538: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4000291c <_open_r>:
const char *buf,
int flags,
int mode
)
{
return open( buf, flags, mode );
4000291c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
40002920: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
40002924: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
40002928: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4000292c: 7f ff ff 40 call 4000262c <open> <== NOT EXECUTED
40002930: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400156c0 <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
400156c0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
400156c4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
400156c8: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
400156cc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400156d0: 7f ff ff c5 call 400155e4 <read> <== NOT EXECUTED
400156d4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400156dc <_realloc_r>:
struct _reent *ignored,
void *ptr,
size_t size
)
{
return realloc( ptr, size );
400156dc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
400156e0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
400156e4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
400156e8: 40 00 00 17 call 40015744 <realloc> <== NOT EXECUTED
400156ec: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
40009d80 <calloc>:
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
40009d80: 9d e3 bf 98 save %sp, -104, %sp
40009d84: 05 10 00 5f sethi %hi(0x40017c00), %g2
40009d88: 84 10 a1 58 or %g2, 0x158, %g2 ! 40017d58 <rtems_malloc_statistics>
40009d8c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
length = nelem * elsize;
40009d90: 92 10 00 18 mov %i0, %o1
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
40009d94: 82 00 60 01 inc %g1
length = nelem * elsize;
40009d98: 90 10 00 19 mov %i1, %o0
40009d9c: 40 00 24 82 call 40012fa4 <.umul>
40009da0: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
cptr = malloc( length );
40009da4: 40 00 01 a1 call 4000a428 <malloc>
40009da8: b2 10 00 08 mov %o0, %i1
if ( cptr )
40009dac: b0 92 20 00 orcc %o0, 0, %i0
40009db0: 02 80 00 04 be 40009dc0 <calloc+0x40> <== NEVER TAKEN
40009db4: 94 10 00 19 mov %i1, %o2
memset( cptr, '\0', length );
40009db8: 40 00 0b 10 call 4000c9f8 <memset>
40009dbc: 92 10 20 00 clr %o1
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
40009dc0: 05 10 00 5f sethi %hi(0x40017c00), %g2
40009dc4: 84 10 a1 58 or %g2, 0x158, %g2 ! 40017d58 <rtems_malloc_statistics>
40009dc8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40009dcc: 82 00 7f ff add %g1, -1, %g1
40009dd0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return cptr;
}
40009dd4: 81 c7 e0 08 ret
40009dd8: 81 e8 00 00 restore
40009ddc <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
40009ddc: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
40009de0: 03 10 00 5c sethi %hi(0x40017000), %g1
40009de4: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40017158 <rtems_libio_number_iops>
40009de8: 80 a6 00 01 cmp %i0, %g1
40009dec: 1a 80 00 0e bcc 40009e24 <close+0x48> <== NEVER TAKEN
40009df0: 01 00 00 00 nop
iop = rtems_libio_iop(fd);
40009df4: 03 10 00 5f sethi %hi(0x40017c00), %g1
40009df8: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops>
40009dfc: 85 2e 20 02 sll %i0, 2, %g2
40009e00: 83 2e 20 04 sll %i0, 4, %g1
40009e04: 82 20 40 02 sub %g1, %g2, %g1
40009e08: 82 00 40 18 add %g1, %i0, %g1
40009e0c: 83 28 60 02 sll %g1, 2, %g1
40009e10: b0 00 c0 01 add %g3, %g1, %i0
rtems_libio_check_is_open(iop);
40009e14: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40009e18: 80 88 61 00 btst 0x100, %g1
40009e1c: 32 80 00 08 bne,a 40009e3c <close+0x60> <== ALWAYS TAKEN
40009e20: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40009e24: 40 00 08 ca call 4000c14c <__errno> <== NOT EXECUTED
40009e28: 01 00 00 00 nop <== NOT EXECUTED
40009e2c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
40009e30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40009e34: 10 80 00 16 b 40009e8c <close+0xb0> <== NOT EXECUTED
40009e38: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
40009e3c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40009e40: 80 a0 60 00 cmp %g1, 0
40009e44: 02 80 00 05 be 40009e58 <close+0x7c> <== NEVER TAKEN
40009e48: a0 10 20 00 clr %l0
rc = (*iop->handlers->close_h)( iop );
40009e4c: 9f c0 40 00 call %g1
40009e50: 90 10 00 18 mov %i0, %o0
40009e54: a0 10 00 08 mov %o0, %l0
rtems_filesystem_freenode( &iop->pathinfo );
40009e58: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40009e5c: 80 a0 60 00 cmp %g1, 0
40009e60: 02 80 00 08 be 40009e80 <close+0xa4> <== NEVER TAKEN
40009e64: 01 00 00 00 nop
40009e68: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40009e6c: 80 a0 60 00 cmp %g1, 0
40009e70: 02 80 00 04 be 40009e80 <close+0xa4> <== ALWAYS TAKEN
40009e74: 01 00 00 00 nop
40009e78: 9f c0 40 00 call %g1 <== NOT EXECUTED
40009e7c: 90 06 20 10 add %i0, 0x10, %o0 <== NOT EXECUTED
rtems_libio_free( iop );
40009e80: 40 00 00 e8 call 4000a220 <rtems_libio_free>
40009e84: 90 10 00 18 mov %i0, %o0
return rc;
40009e88: 90 10 00 10 mov %l0, %o0
}
40009e8c: 81 c7 e0 08 ret
40009e90: 91 e8 00 08 restore %g0, %o0, %o0
4000b89c <device_close>:
*/
int device_close(
rtems_libio_t *iop
)
{
4000b89c: 9d e3 bf 88 save %sp, -120, %sp
rtems_libio_open_close_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
4000b8a0: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
args.iop = iop;
4000b8a4: f0 27 bf ec st %i0, [ %fp + -20 ]
args.flags = 0;
4000b8a8: c0 27 bf f0 clr [ %fp + -16 ]
args.mode = 0;
4000b8ac: c0 27 bf f4 clr [ %fp + -12 ]
status = rtems_io_close(
4000b8b0: d2 00 60 50 ld [ %g1 + 0x50 ], %o1
4000b8b4: d0 00 60 4c ld [ %g1 + 0x4c ], %o0
4000b8b8: 94 07 bf ec add %fp, -20, %o2
4000b8bc: 40 00 01 26 call 4000bd54 <rtems_io_close>
4000b8c0: b0 10 20 00 clr %i0
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
4000b8c4: 80 a2 20 00 cmp %o0, 0
4000b8c8: 02 80 00 05 be 4000b8dc <device_close+0x40> <== ALWAYS TAKEN
4000b8cc: 01 00 00 00 nop
return rtems_deviceio_errno(status);
4000b8d0: 7f ff ff a3 call 4000b75c <rtems_deviceio_errno> <== NOT EXECUTED
4000b8d4: 01 00 00 00 nop <== NOT EXECUTED
4000b8d8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
return 0;
}
4000b8dc: 81 c7 e0 08 ret
4000b8e0: 81 e8 00 00 restore
4000b754 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000b754: 81 c3 e0 08 retl <== NOT EXECUTED
4000b758: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000b790 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
4000b790: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
the_jnode = iop->file_info;
4000b794: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
args.command = command;
4000b798: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED
args.buffer = buffer;
4000b79c: f4 27 bf f0 st %i2, [ %fp + -16 ] <== NOT EXECUTED
{
rtems_libio_ioctl_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
4000b7a0: f0 27 bf e8 st %i0, [ %fp + -24 ] <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
the_jnode = iop->file_info;
status = rtems_io_control(
4000b7a4: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 <== NOT EXECUTED
4000b7a8: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 <== NOT EXECUTED
4000b7ac: 40 00 01 80 call 4000bdac <rtems_io_control> <== NOT EXECUTED
4000b7b0: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
4000b7b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000b7b8: 22 80 00 06 be,a 4000b7d0 <device_ioctl+0x40> <== NOT EXECUTED
4000b7bc: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
4000b7c0: 7f ff ff e7 call 4000b75c <rtems_deviceio_errno> <== NOT EXECUTED
4000b7c4: 01 00 00 00 nop <== NOT EXECUTED
return args.ioctl_return;
}
4000b7c8: 81 c7 e0 08 ret <== NOT EXECUTED
4000b7cc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000b7d0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000b7d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000b7d8: 81 e8 00 00 restore <== NOT EXECUTED
4000b74c <device_lseek>:
off_t offset,
int whence
)
{
return offset;
}
4000b74c: 81 c3 e0 08 retl <== NOT EXECUTED
4000b750: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
4000b8e4 <device_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
4000b8e4: 9d e3 bf 88 save %sp, -120, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.flags = iop->flags;
4000b8e8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
{
rtems_libio_open_close_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
4000b8ec: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
args.iop = iop;
4000b8f0: f0 27 bf ec st %i0, [ %fp + -20 ]
args.flags = iop->flags;
4000b8f4: c2 27 bf f0 st %g1, [ %fp + -16 ]
args.mode = mode;
4000b8f8: f6 27 bf f4 st %i3, [ %fp + -12 ]
status = rtems_io_open(
4000b8fc: d2 00 a0 50 ld [ %g2 + 0x50 ], %o1
4000b900: d0 00 a0 4c ld [ %g2 + 0x4c ], %o0
4000b904: 94 07 bf ec add %fp, -20, %o2
4000b908: 40 00 01 3f call 4000be04 <rtems_io_open>
4000b90c: b0 10 20 00 clr %i0
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
4000b910: 80 a2 20 00 cmp %o0, 0
4000b914: 02 80 00 05 be 4000b928 <device_open+0x44> <== ALWAYS TAKEN
4000b918: 01 00 00 00 nop
return rtems_deviceio_errno(status);
4000b91c: 7f ff ff 90 call 4000b75c <rtems_deviceio_errno> <== NOT EXECUTED
4000b920: 01 00 00 00 nop <== NOT EXECUTED
4000b924: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
return 0;
}
4000b928: 81 c7 e0 08 ret
4000b92c: 81 e8 00 00 restore
4000b930: 40 00 b9 e8 call 4003a0d0 <__end+0x21d18> <== NOT EXECUTED
4000b934: 40 00 ba 0c call 4003a164 <__end+0x21dac> <== NOT EXECUTED
4000b938: 40 00 ba 00 call 4003a138 <__end+0x21d80> <== NOT EXECUTED
4000b93c: 40 00 ba 00 call 4003a13c <__end+0x21d84> <== NOT EXECUTED
4000b940: 40 00 ba 28 call 4003a1e0 <__end+0x21e28> <== NOT EXECUTED
4000b944: 40 00 ba 20 call 4003a1c4 <__end+0x21e0c> <== NOT EXECUTED
4000b83c <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000b83c: 9d e3 bf 80 save %sp, -128, %sp <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
4000b840: c4 06 20 0c ld [ %i0 + 0xc ], %g2 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
4000b844: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
4000b848: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
4000b84c: f2 27 bf e8 st %i1, [ %fp + -24 ] <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
4000b850: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
4000b854: f4 27 bf ec st %i2, [ %fp + -20 ] <== NOT EXECUTED
args.flags = iop->flags;
4000b858: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
4000b85c: f0 27 bf e0 st %i0, [ %fp + -32 ] <== NOT EXECUTED
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
4000b860: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
status = rtems_io_read(
4000b864: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 <== NOT EXECUTED
4000b868: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 <== NOT EXECUTED
4000b86c: 40 00 01 7c call 4000be5c <rtems_io_read> <== NOT EXECUTED
4000b870: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
4000b874: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000b878: 22 80 00 06 be,a 4000b890 <device_read+0x54> <== NOT EXECUTED
4000b87c: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
4000b880: 7f ff ff b7 call 4000b75c <rtems_deviceio_errno> <== NOT EXECUTED
4000b884: 01 00 00 00 nop <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
4000b888: 81 c7 e0 08 ret <== NOT EXECUTED
4000b88c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000b890: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
4000b894: 81 c7 e0 08 ret <== NOT EXECUTED
4000b898: 81 e8 00 00 restore <== NOT EXECUTED
4000b7dc <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000b7dc: 9d e3 bf 80 save %sp, -128, %sp
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
4000b7e0: c4 06 20 0c ld [ %i0 + 0xc ], %g2
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
4000b7e4: c2 06 20 08 ld [ %i0 + 8 ], %g1
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
4000b7e8: c6 06 20 2c ld [ %i0 + 0x2c ], %g3
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
4000b7ec: f2 27 bf e8 st %i1, [ %fp + -24 ]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
4000b7f0: c2 27 bf e4 st %g1, [ %fp + -28 ]
args.buffer = (void *) buffer;
args.count = count;
4000b7f4: f4 27 bf ec st %i2, [ %fp + -20 ]
args.flags = iop->flags;
4000b7f8: c4 27 bf f0 st %g2, [ %fp + -16 ]
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
4000b7fc: f0 27 bf e0 st %i0, [ %fp + -32 ]
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
4000b800: c0 27 bf f4 clr [ %fp + -12 ]
status = rtems_io_write(
4000b804: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1
4000b808: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0
4000b80c: 40 00 01 aa call 4000beb4 <rtems_io_write>
4000b810: 94 07 bf e0 add %fp, -32, %o2
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
4000b814: 80 a2 20 00 cmp %o0, 0
4000b818: 22 80 00 06 be,a 4000b830 <device_write+0x54> <== ALWAYS TAKEN
4000b81c: d0 07 bf f4 ld [ %fp + -12 ], %o0
return rtems_deviceio_errno(status);
4000b820: 7f ff ff cf call 4000b75c <rtems_deviceio_errno> <== NOT EXECUTED
4000b824: 01 00 00 00 nop <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
4000b828: 81 c7 e0 08 ret <== NOT EXECUTED
4000b82c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000b830: b0 10 00 08 mov %o0, %i0
4000b834: 81 c7 e0 08 ret
4000b838: 81 e8 00 00 restore
40003b14 <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
40003b14: 9d e3 bf 98 save %sp, -104, %sp
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
40003b18: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
40003b1c: 80 a0 60 00 cmp %g1, 0
40003b20: 02 80 00 1a be 40003b88 <drainOutput+0x74> <== ALWAYS TAKEN
40003b24: 01 00 00 00 nop
rtems_interrupt_disable (level);
40003b28: 7f ff f8 6d call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40003b2c: 01 00 00 00 nop <== NOT EXECUTED
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
40003b30: 10 80 00 0f b 40003b6c <drainOutput+0x58> <== NOT EXECUTED
40003b34: a0 10 20 02 mov 2, %l0 ! 2 <PROM_START+0x2> <== NOT EXECUTED
rtems_interrupt_enable (level);
40003b38: 7f ff f8 6d call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40003b3c: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
40003b40: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
40003b44: 92 10 20 00 clr %o1 <== NOT EXECUTED
40003b48: 40 00 06 28 call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003b4c: 94 10 20 00 clr %o2 <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40003b50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003b54: 02 80 00 04 be 40003b64 <drainOutput+0x50> <== NOT EXECUTED
40003b58: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40003b5c: 40 00 07 e3 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40003b60: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
40003b64: 7f ff f8 5e call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40003b68: 01 00 00 00 nop <== 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) {
40003b6c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
40003b70: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
40003b74: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003b78: 32 bf ff f0 bne,a 40003b38 <drainOutput+0x24> <== NOT EXECUTED
40003b7c: e0 26 20 94 st %l0, [ %i0 + 0x94 ] <== NOT EXECUTED
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
40003b80: 7f ff f8 5b call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40003b84: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40003b88: 81 c7 e0 08 ret
40003b8c: 81 e8 00 00 restore
40003580 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
40003580: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
40003584: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40003588: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
4000358c: 02 80 00 1b be 400035f8 <echo+0x78> <== NOT EXECUTED
40003590: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40003594: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40003598: c2 00 62 c8 ld [ %g1 + 0x2c8 ], %g1 ! 400176c8 <__ctype_ptr><== NOT EXECUTED
4000359c: 84 0e 20 ff and %i0, 0xff, %g2 <== NOT EXECUTED
400035a0: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 <== NOT EXECUTED
400035a4: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400035a8: 22 80 00 15 be,a 400035fc <echo+0x7c> <== NOT EXECUTED
400035ac: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
400035b0: 80 a0 a0 09 cmp %g2, 9 <== NOT EXECUTED
400035b4: 02 80 00 11 be 400035f8 <echo+0x78> <== NOT EXECUTED
400035b8: 80 a0 a0 0a cmp %g2, 0xa <== NOT EXECUTED
400035bc: 02 80 00 10 be 400035fc <echo+0x7c> <== NOT EXECUTED
400035c0: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
400035c4: 82 1e 20 40 xor %i0, 0x40, %g1 <== NOT EXECUTED
400035c8: c2 2f bf f1 stb %g1, [ %fp + -15 ] <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
400035cc: 82 10 20 5e mov 0x5e, %g1 <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
400035d0: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
400035d4: c2 2f bf f0 stb %g1, [ %fp + -16 ] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
400035d8: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
400035dc: 7f ff ff 3b call 400032c8 <rtems_termios_puts> <== NOT EXECUTED
400035e0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
tty->column += 2;
400035e4: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
400035e8: 82 00 60 02 add %g1, 2, %g1 <== NOT EXECUTED
400035ec: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
400035f0: 81 c7 e0 08 ret <== NOT EXECUTED
400035f4: 81 e8 00 00 restore <== NOT EXECUTED
}
else {
oproc (c, tty);
400035f8: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
400035fc: 7f ff ff 7f call 400033f8 <oproc> <== NOT EXECUTED
40003600: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40003604: 81 c7 e0 08 ret <== NOT EXECUTED
40003608: 81 e8 00 00 restore <== NOT EXECUTED
4000360c <erase>:
* 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)
{
4000360c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
if (tty->ccount == 0)
40003610: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
40003614: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003618: 02 80 00 0a be 40003640 <erase+0x34> <== NOT EXECUTED
4000361c: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
return;
if (lineFlag) {
40003620: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40003624: 02 80 00 78 be 40003804 <erase+0x1f8> <== NOT EXECUTED
40003628: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
4000362c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
40003630: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
40003634: 32 80 00 05 bne,a 40003648 <erase+0x3c> <== NOT EXECUTED
40003638: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
tty->ccount = 0;
4000363c: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
40003640: 81 c7 e0 08 ret <== NOT EXECUTED
40003644: 81 e8 00 00 restore <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
40003648: 12 80 00 6f bne 40003804 <erase+0x1f8> <== NOT EXECUTED
4000364c: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
40003650: d0 0e 20 44 ldub [ %i0 + 0x44 ], %o0 <== NOT EXECUTED
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
40003654: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
40003658: 7f ff ff ca call 40003580 <echo> <== NOT EXECUTED
4000365c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
40003660: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
echo ('\n', tty);
40003664: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
40003668: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
4000366c: 02 bf ff f5 be 40003640 <erase+0x34> <== NOT EXECUTED
40003670: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
40003674: 30 80 00 0f b,a 400036b0 <erase+0xa4> <== NOT EXECUTED
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
40003678: c4 04 20 3c ld [ %l0 + 0x3c ], %g2 <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
4000367c: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
40003680: c6 24 20 20 st %g3, [ %l0 + 0x20 ] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
40003684: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED
40003688: 02 80 00 5a be 400037f0 <erase+0x1e4> <== NOT EXECUTED
4000368c: c2 08 40 03 ldub [ %g1 + %g3 ], %g1 <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
40003690: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40003694: 12 80 00 09 bne 400036b8 <erase+0xac> <== NOT EXECUTED
40003698: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
4000369c: 80 88 a0 10 btst 0x10, %g2 <== NOT EXECUTED
400036a0: 12 80 00 07 bne 400036bc <erase+0xb0> <== NOT EXECUTED
400036a4: 80 a6 20 09 cmp %i0, 9 <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
400036a8: f0 0c 20 43 ldub [ %l0 + 0x43 ], %i0 <== NOT EXECUTED
400036ac: b2 10 00 10 mov %l0, %i1 <== NOT EXECUTED
400036b0: 7f ff ff b4 call 40003580 <echo> <== NOT EXECUTED
400036b4: 81 e8 00 00 restore <== NOT EXECUTED
}
else if (c == '\t') {
400036b8: 80 a6 20 09 cmp %i0, 9 <== NOT EXECUTED
400036bc: 32 80 00 29 bne,a 40003760 <erase+0x154> <== NOT EXECUTED
400036c0: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
400036c4: 9a 08 a2 00 and %g2, 0x200, %o5 <== 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;
400036c8: f0 04 20 2c ld [ %l0 + 0x2c ], %i0 <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
400036cc: c8 04 40 00 ld [ %l1 ], %g4 <== NOT EXECUTED
400036d0: 10 80 00 12 b 40003718 <erase+0x10c> <== NOT EXECUTED
400036d4: 84 10 20 00 clr %g2 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
400036d8: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 <== NOT EXECUTED
400036dc: 80 a0 60 09 cmp %g1, 9 <== NOT EXECUTED
400036e0: 32 80 00 05 bne,a 400036f4 <erase+0xe8> <== NOT EXECUTED
400036e4: c2 09 00 01 ldub [ %g4 + %g1 ], %g1 <== NOT EXECUTED
col = (col | 7) + 1;
400036e8: 82 16 20 07 or %i0, 7, %g1 <== NOT EXECUTED
400036ec: 10 80 00 0a b 40003714 <erase+0x108> <== NOT EXECUTED
400036f0: b0 00 60 01 add %g1, 1, %i0 <== NOT EXECUTED
}
else if (iscntrl (c)) {
400036f4: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400036f8: 22 80 00 07 be,a 40003714 <erase+0x108> <== NOT EXECUTED
400036fc: b0 06 20 01 inc %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
40003700: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
40003704: 32 80 00 04 bne,a 40003714 <erase+0x108> <== NOT EXECUTED
40003708: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
4000370c: 10 80 00 03 b 40003718 <erase+0x10c> <== NOT EXECUTED
40003710: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40003714: 84 00 a0 01 inc %g2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
40003718: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000371c: 32 bf ff ef bne,a 400036d8 <erase+0xcc> <== NOT EXECUTED
40003720: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40003724: 10 80 00 08 b 40003744 <erase+0x138> <== NOT EXECUTED
40003728: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
4000372c: 7f ff fe e7 call 400032c8 <rtems_termios_puts> <== NOT EXECUTED
40003730: 01 00 00 00 nop <== NOT EXECUTED
tty->column--;
40003734: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
40003738: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000373c: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
40003740: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
40003744: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
40003748: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
4000374c: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
40003750: 14 bf ff f7 bg 4000372c <erase+0x120> <== NOT EXECUTED
40003754: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
40003758: 10 80 00 27 b 400037f4 <erase+0x1e8> <== NOT EXECUTED
4000375c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
40003760: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED
40003764: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40003768: 22 80 00 10 be,a 400037a8 <erase+0x19c> <== NOT EXECUTED
4000376c: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
40003770: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED
40003774: 22 80 00 0d be,a 400037a8 <erase+0x19c> <== NOT EXECUTED
40003778: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
4000377c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40003780: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
40003784: 7f ff fe d1 call 400032c8 <rtems_termios_puts> <== NOT EXECUTED
40003788: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if (tty->column)
4000378c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
40003790: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003794: 22 80 00 05 be,a 400037a8 <erase+0x19c> <== NOT EXECUTED
40003798: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
tty->column--;
4000379c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400037a0: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
400037a4: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED
400037a8: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED
400037ac: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400037b0: 02 80 00 07 be 400037cc <erase+0x1c0> <== NOT EXECUTED
400037b4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400037b8: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
400037bc: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
400037c0: 02 80 00 0d be 400037f4 <erase+0x1e8> <== NOT EXECUTED
400037c4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
400037c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
400037cc: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
400037d0: 7f ff fe be call 400032c8 <rtems_termios_puts> <== NOT EXECUTED
400037d4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if (tty->column)
400037d8: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
400037dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400037e0: 02 80 00 05 be 400037f4 <erase+0x1e8> <== NOT EXECUTED
400037e4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
tty->column--;
400037e8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400037ec: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
}
}
}
if (!lineFlag)
400037f0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400037f4: 32 80 00 0a bne,a 4000381c <erase+0x210> <== NOT EXECUTED
400037f8: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED
400037fc: 81 c7 e0 08 ret <== NOT EXECUTED
40003800: 81 e8 00 00 restore <== NOT EXECUTED
40003804: a2 10 62 c8 or %g1, 0x2c8, %l1 <== 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);
40003808: 03 10 00 59 sethi %hi(0x40016400), %g1 <== NOT EXECUTED
4000380c: a4 10 60 50 or %g1, 0x50, %l2 ! 40016450 <__func__.4755+0x2c8><== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
40003810: 03 10 00 59 sethi %hi(0x40016400), %g1 <== NOT EXECUTED
40003814: a6 10 60 48 or %g1, 0x48, %l3 ! 40016448 <__func__.4755+0x2c0><== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
40003818: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED
4000381c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40003820: 32 bf ff 96 bne,a 40003678 <erase+0x6c> <== NOT EXECUTED
40003824: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
40003828: 81 c7 e0 08 ret <== NOT EXECUTED
4000382c: 81 e8 00 00 restore <== NOT EXECUTED
40009ea8 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
40009ea8: 9d e3 bf 98 save %sp, -104, %sp
40009eac: 05 10 00 5f sethi %hi(0x40017c00), %g2
40009eb0: 84 10 a1 58 or %g2, 0x158, %g2 ! 40017d58 <rtems_malloc_statistics>
40009eb4: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
40009eb8: b2 10 00 18 mov %i0, %i1
40009ebc: 82 00 60 01 inc %g1
if ( !ptr )
40009ec0: 80 a6 20 00 cmp %i0, 0
40009ec4: 02 80 00 21 be 40009f48 <free+0xa0>
40009ec8: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
40009ecc: 03 10 00 60 sethi %hi(0x40018000), %g1
40009ed0: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
40009ed4: 80 a0 60 03 cmp %g1, 3
40009ed8: 12 80 00 09 bne 40009efc <free+0x54> <== NEVER TAKEN
40009edc: 03 10 00 5e sethi %hi(0x40017800), %g1
40009ee0: 40 00 01 2b call 4000a38c <malloc_is_system_state_OK>
40009ee4: 01 00 00 00 nop
40009ee8: 80 8a 20 ff btst 0xff, %o0
40009eec: 12 80 00 04 bne 40009efc <free+0x54> <== ALWAYS TAKEN
40009ef0: 03 10 00 5e sethi %hi(0x40017800), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
40009ef4: 40 00 01 39 call 4000a3d8 <malloc_deferred_free> <== NOT EXECUTED
40009ef8: 81 e8 00 00 restore <== NOT EXECUTED
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
40009efc: c2 00 63 74 ld [ %g1 + 0x374 ], %g1
40009f00: 80 a0 60 00 cmp %g1, 0
40009f04: 02 80 00 06 be 40009f1c <free+0x74> <== ALWAYS TAKEN
40009f08: 37 10 00 5f sethi %hi(0x40017c00), %i3
(*rtems_malloc_statistics_helpers->at_free)(ptr);
40009f0c: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
40009f10: 9f c0 40 00 call %g1 <== NOT EXECUTED
40009f14: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {
40009f18: 37 10 00 5f sethi %hi(0x40017c00), %i3 <== NOT EXECUTED
40009f1c: 92 10 00 19 mov %i1, %o1
40009f20: 40 00 04 c1 call 4000b224 <_Protected_heap_Free>
40009f24: 90 16 e1 00 or %i3, 0x100, %o0
40009f28: 80 8a 20 ff btst 0xff, %o0
40009f2c: 12 80 00 07 bne 40009f48 <free+0xa0> <== ALWAYS TAKEN
40009f30: 82 16 e1 00 or %i3, 0x100, %g1
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
40009f34: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
40009f38: f4 00 60 18 ld [ %g1 + 0x18 ], %i2 <== NOT EXECUTED
40009f3c: 31 10 00 59 sethi %hi(0x40016400), %i0 <== NOT EXECUTED
40009f40: 7f ff e3 52 call 40002c88 <printk> <== NOT EXECUTED
40009f44: 91 ee 23 c8 restore %i0, 0x3c8, %o0 <== NOT EXECUTED
40009f48: 81 c7 e0 08 ret
40009f4c: 81 e8 00 00 restore
4001530c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
4001530c: 9d e3 bf 98 save %sp, -104, %sp
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
40015310: 80 a6 60 00 cmp %i1, 0
40015314: 32 80 00 06 bne,a 4001532c <fstat+0x20> <== ALWAYS TAKEN
40015318: 03 10 00 5c sethi %hi(0x40017000), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
4001531c: 7f ff db 8c call 4000c14c <__errno> <== NOT EXECUTED
40015320: 01 00 00 00 nop <== NOT EXECUTED
40015324: 10 80 00 2a b 400153cc <fstat+0xc0> <== NOT EXECUTED
40015328: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
4001532c: c2 00 61 58 ld [ %g1 + 0x158 ], %g1
40015330: 80 a6 00 01 cmp %i0, %g1
40015334: 1a 80 00 23 bcc 400153c0 <fstat+0xb4> <== NEVER TAKEN
40015338: 03 10 00 5f sethi %hi(0x40017c00), %g1
4001533c: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops>
40015340: 85 2e 20 02 sll %i0, 2, %g2
40015344: 83 2e 20 04 sll %i0, 4, %g1
40015348: 82 20 40 02 sub %g1, %g2, %g1
4001534c: 82 00 40 18 add %g1, %i0, %g1
40015350: 83 28 60 02 sll %g1, 2, %g1
40015354: b0 00 c0 01 add %g3, %g1, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
40015358: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4001535c: 80 88 61 00 btst 0x100, %g1
40015360: 02 80 00 18 be 400153c0 <fstat+0xb4> <== NEVER TAKEN
40015364: 01 00 00 00 nop
if ( !iop->handlers )
40015368: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
4001536c: 80 a0 60 00 cmp %g1, 0
40015370: 02 80 00 14 be 400153c0 <fstat+0xb4> <== NEVER TAKEN
40015374: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
40015378: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
4001537c: 80 a0 60 00 cmp %g1, 0
40015380: 12 80 00 06 bne 40015398 <fstat+0x8c> <== ALWAYS TAKEN
40015384: 92 10 20 00 clr %o1
rtems_set_errno_and_return_minus_one( ENOTSUP );
40015388: 7f ff db 71 call 4000c14c <__errno> <== NOT EXECUTED
4001538c: 01 00 00 00 nop <== NOT EXECUTED
40015390: 10 80 00 0f b 400153cc <fstat+0xc0> <== NOT EXECUTED
40015394: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
40015398: 94 10 20 50 mov 0x50, %o2
4001539c: 7f ff dd 97 call 4000c9f8 <memset>
400153a0: 90 10 00 19 mov %i1, %o0
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
400153a4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
400153a8: 90 06 20 10 add %i0, 0x10, %o0
400153ac: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400153b0: 9f c0 40 00 call %g1
400153b4: 92 10 00 19 mov %i1, %o1
}
400153b8: 81 c7 e0 08 ret
400153bc: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
400153c0: 7f ff db 63 call 4000c14c <__errno> <== NOT EXECUTED
400153c4: 01 00 00 00 nop <== NOT EXECUTED
400153c8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
400153cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400153d0: 10 bf ff fa b 400153b8 <fstat+0xac> <== NOT EXECUTED
400153d4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
40009f50 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
40009f50: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
40009f54: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED
40009f58: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40017158 <rtems_libio_number_iops><== NOT EXECUTED
40009f5c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
40009f60: 1a 80 00 0e bcc 40009f98 <ftruncate+0x48> <== NOT EXECUTED
40009f64: 01 00 00 00 nop <== NOT EXECUTED
iop = rtems_libio_iop( fd );
40009f68: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40009f6c: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops><== NOT EXECUTED
40009f70: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
40009f74: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
40009f78: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40009f7c: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
40009f80: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
40009f84: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
40009f88: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
40009f8c: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40009f90: 12 80 00 06 bne 40009fa8 <ftruncate+0x58> <== NOT EXECUTED
40009f94: a0 07 bf e8 add %fp, -24, %l0 <== NOT EXECUTED
40009f98: 40 00 08 6d call 4000c14c <__errno> <== NOT EXECUTED
40009f9c: 01 00 00 00 nop <== NOT EXECUTED
40009fa0: 10 80 00 22 b 4000a028 <ftruncate+0xd8> <== NOT EXECUTED
40009fa4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
40009fa8: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED
40009fac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40009fb0: 40 00 0a 59 call 4000c914 <memcpy> <== NOT EXECUTED
40009fb4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
if ( !loc.ops->node_type_h )
40009fb8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
40009fbc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
40009fc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40009fc4: 02 80 00 16 be 4000a01c <ftruncate+0xcc> <== NOT EXECUTED
40009fc8: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
40009fcc: 9f c0 40 00 call %g1 <== NOT EXECUTED
40009fd0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40009fd4: 80 a2 20 01 cmp %o0, 1 <== NOT EXECUTED
40009fd8: 32 80 00 06 bne,a 40009ff0 <ftruncate+0xa0> <== NOT EXECUTED
40009fdc: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
40009fe0: 40 00 08 5b call 4000c14c <__errno> <== NOT EXECUTED
40009fe4: 01 00 00 00 nop <== NOT EXECUTED
40009fe8: 10 80 00 10 b 4000a028 <ftruncate+0xd8> <== NOT EXECUTED
40009fec: 82 10 20 15 mov 0x15, %g1 ! 15 <PROM_START+0x15> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
40009ff0: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
40009ff4: 32 80 00 06 bne,a 4000a00c <ftruncate+0xbc> <== NOT EXECUTED
40009ff8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
40009ffc: 40 00 08 54 call 4000c14c <__errno> <== NOT EXECUTED
4000a000: 01 00 00 00 nop <== NOT EXECUTED
4000a004: 10 80 00 09 b 4000a028 <ftruncate+0xd8> <== NOT EXECUTED
4000a008: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
4000a00c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 <== NOT EXECUTED
4000a010: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a014: 32 80 00 08 bne,a 4000a034 <ftruncate+0xe4> <== NOT EXECUTED
4000a018: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
4000a01c: 40 00 08 4c call 4000c14c <__errno> <== NOT EXECUTED
4000a020: 01 00 00 00 nop <== NOT EXECUTED
4000a024: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
4000a028: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a02c: 10 80 00 04 b 4000a03c <ftruncate+0xec> <== NOT EXECUTED
4000a030: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
return (*iop->handlers->ftruncate_h)( iop, length );
4000a034: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a038: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
4000a03c: 81 c7 e0 08 ret <== NOT EXECUTED
4000a040: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40018bf8 <getpid>:
*/
pid_t getpid( void )
{
return _Objects_Local_node;
}
40018bf8: 81 c3 e0 08 retl <== NOT EXECUTED
40018bfc: 90 10 20 01 mov 1, %o0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
4000a044 <gettimeofday>:
int gettimeofday(
struct timeval *tp,
void * __tz
)
{
4000a044: 9d e3 bf 90 save %sp, -112, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
4000a048: 80 a6 20 00 cmp %i0, 0
4000a04c: 12 80 00 08 bne 4000a06c <gettimeofday+0x28> <== ALWAYS TAKEN
4000a050: 01 00 00 00 nop
errno = EFAULT;
4000a054: 40 00 08 3e call 4000c14c <__errno> <== NOT EXECUTED
4000a058: b0 10 3f ff mov -1, %i0 ! ffffffff <LEON_REG+0x7fffffff> <== NOT EXECUTED
4000a05c: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
4000a060: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a064: 81 c7 e0 08 ret <== NOT EXECUTED
4000a068: 81 e8 00 00 restore <== NOT EXECUTED
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
4000a06c: 7f ff df 1c call 40001cdc <sparc_disable_interrupts>
4000a070: 01 00 00 00 nop
4000a074: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
4000a078: 7f ff f0 81 call 4000627c <_TOD_Get>
4000a07c: 90 07 bf f0 add %fp, -16, %o0
_ISR_Enable(level);
4000a080: 7f ff df 1b call 40001cec <sparc_enable_interrupts>
4000a084: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
4000a088: d0 07 bf f4 ld [ %fp + -12 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
4000a08c: c2 07 bf f0 ld [ %fp + -16 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
4000a090: 92 10 23 e8 mov 0x3e8, %o1
4000a094: 40 00 23 fe call 4001308c <.udiv>
4000a098: c2 26 00 00 st %g1, [ %i0 ]
4000a09c: d0 26 20 04 st %o0, [ %i0 + 4 ]
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
}
4000a0a0: 81 c7 e0 08 ret
4000a0a4: 91 e8 20 00 restore %g0, 0, %o0
40003830 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
40003830: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
40003834: c4 06 60 30 ld [ %i1 + 0x30 ], %g2 <== NOT EXECUTED
40003838: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED
4000383c: 02 80 00 03 be 40003848 <iproc+0x18> <== NOT EXECUTED
40003840: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
c &= 0x7f;
40003844: a0 0e 20 7f and %i0, 0x7f, %l0 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
40003848: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED
4000384c: 02 80 00 0b be 40003878 <iproc+0x48> <== NOT EXECUTED
40003850: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
c = tolower (c);
40003854: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40003858: c2 00 62 c8 ld [ %g1 + 0x2c8 ], %g1 ! 400176c8 <__ctype_ptr><== NOT EXECUTED
4000385c: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
40003860: c2 08 40 08 ldub [ %g1 + %o0 ], %g1 <== NOT EXECUTED
40003864: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40003868: 32 80 00 02 bne,a 40003870 <iproc+0x40> <== NOT EXECUTED
4000386c: 90 02 20 20 add %o0, 0x20, %o0 <== NOT EXECUTED
40003870: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
if (c == '\r') {
40003874: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
40003878: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED
4000387c: 12 80 00 09 bne 400038a0 <iproc+0x70> <== NOT EXECUTED
40003880: 80 a0 60 0a cmp %g1, 0xa <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
40003884: 80 88 a0 80 btst 0x80, %g2 <== NOT EXECUTED
40003888: 12 80 00 5d bne 400039fc <iproc+0x1cc> <== NOT EXECUTED
4000388c: 80 88 a1 00 btst 0x100, %g2 <== NOT EXECUTED
return 0;
if (tty->termios.c_iflag & ICRNL)
40003890: 32 80 00 0d bne,a 400038c4 <iproc+0x94> <== NOT EXECUTED
40003894: a0 10 20 0a mov 0xa, %l0 <== NOT EXECUTED
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
40003898: 10 80 00 0c b 400038c8 <iproc+0x98> <== NOT EXECUTED
4000389c: c6 06 60 3c ld [ %i1 + 0x3c ], %g3 <== 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)) {
400038a0: 12 80 00 07 bne 400038bc <iproc+0x8c> <== NOT EXECUTED
400038a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400038a8: 80 88 a0 40 btst 0x40, %g2 <== NOT EXECUTED
400038ac: 32 80 00 06 bne,a 400038c4 <iproc+0x94> <== NOT EXECUTED
400038b0: a0 10 20 0d mov 0xd, %l0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
400038b4: 10 80 00 05 b 400038c8 <iproc+0x98> <== NOT EXECUTED
400038b8: c6 06 60 3c ld [ %i1 + 0x3c ], %g3 <== NOT EXECUTED
400038bc: 02 80 00 3c be 400039ac <iproc+0x17c> <== NOT EXECUTED
400038c0: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
400038c4: c6 06 60 3c ld [ %i1 + 0x3c ], %g3 <== NOT EXECUTED
400038c8: 80 88 e0 02 btst 2, %g3 <== NOT EXECUTED
400038cc: 02 80 00 38 be 400039ac <iproc+0x17c> <== NOT EXECUTED
400038d0: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
400038d4: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1 <== NOT EXECUTED
400038d8: 84 0c 20 ff and %l0, 0xff, %g2 <== NOT EXECUTED
erase (tty, 0);
400038dc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
400038e0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400038e4: 02 80 00 08 be 40003904 <iproc+0xd4> <== NOT EXECUTED
400038e8: 92 10 20 00 clr %o1 <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
400038ec: c2 0e 60 44 ldub [ %i1 + 0x44 ], %g1 <== NOT EXECUTED
400038f0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400038f4: 32 80 00 07 bne,a 40003910 <iproc+0xe0> <== NOT EXECUTED
400038f8: c2 0e 60 45 ldub [ %i1 + 0x45 ], %g1 <== NOT EXECUTED
erase (tty, 1);
400038fc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40003900: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
40003904: 7f ff ff 42 call 4000360c <erase> <== NOT EXECUTED
40003908: b0 10 20 00 clr %i0 <== NOT EXECUTED
4000390c: 30 80 00 3d b,a 40003a00 <iproc+0x1d0> <== NOT EXECUTED
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
40003910: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003914: 02 80 00 3b be 40003a00 <iproc+0x1d0> <== NOT EXECUTED
40003918: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
4000391c: 80 a0 a0 0a cmp %g2, 0xa <== NOT EXECUTED
40003920: 32 80 00 0f bne,a 4000395c <iproc+0x12c> <== NOT EXECUTED
40003924: c2 0e 60 4c ldub [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
40003928: 80 88 e0 48 btst 0x48, %g3 <== NOT EXECUTED
4000392c: 22 80 00 06 be,a 40003944 <iproc+0x114> <== NOT EXECUTED
40003930: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40003934: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
40003938: 7f ff ff 12 call 40003580 <echo> <== NOT EXECUTED
4000393c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40003940: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40003944: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
40003948: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
4000394c: c4 28 c0 01 stb %g2, [ %g3 + %g1 ] <== NOT EXECUTED
40003950: 82 00 60 01 inc %g1 <== NOT EXECUTED
40003954: 10 80 00 14 b 400039a4 <iproc+0x174> <== NOT EXECUTED
40003958: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
4000395c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003960: 02 80 00 07 be 4000397c <iproc+0x14c> <== NOT EXECUTED
40003964: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED
40003968: c2 0e 60 51 ldub [ %i1 + 0x51 ], %g1 <== NOT EXECUTED
4000396c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003970: 12 80 00 0f bne 400039ac <iproc+0x17c> <== NOT EXECUTED
40003974: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
40003978: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED
4000397c: 22 80 00 06 be,a 40003994 <iproc+0x164> <== NOT EXECUTED
40003980: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
40003984: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
40003988: 7f ff fe fe call 40003580 <echo> <== NOT EXECUTED
4000398c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
40003990: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40003994: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
40003998: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED
4000399c: e0 28 80 01 stb %l0, [ %g2 + %g1 ] <== NOT EXECUTED
400039a0: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED
400039a4: 81 c7 e0 08 ret <== NOT EXECUTED
400039a8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
400039ac: c4 06 60 20 ld [ %i1 + 0x20 ], %g2 <== NOT EXECUTED
400039b0: c2 00 62 6c ld [ %g1 + 0x26c ], %g1 <== NOT EXECUTED
400039b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
400039b8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
400039bc: 16 80 00 11 bge 40003a00 <iproc+0x1d0> <== NOT EXECUTED
400039c0: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
400039c4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
400039c8: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
400039cc: 22 80 00 06 be,a 400039e4 <iproc+0x1b4> <== NOT EXECUTED
400039d0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
400039d4: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
400039d8: 7f ff fe ea call 40003580 <echo> <== NOT EXECUTED
400039dc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
400039e0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
400039e4: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
400039e8: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED
400039ec: e0 28 80 01 stb %l0, [ %g2 + %g1 ] <== NOT EXECUTED
400039f0: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED
400039f4: 81 c7 e0 08 ret <== NOT EXECUTED
400039f8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
400039fc: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
return 0;
}
40003a00: 81 c7 e0 08 ret <== NOT EXECUTED
40003a04: 81 e8 00 00 restore <== NOT EXECUTED
400153f0 <isatty>:
#include <sys/stat.h>
int isatty(
int fd
)
{
400153f0: 9d e3 bf 48 save %sp, -184, %sp
struct stat buf;
if (fstat (fd, &buf) < 0)
400153f4: 90 10 00 18 mov %i0, %o0
400153f8: 92 07 bf a8 add %fp, -88, %o1
400153fc: 7f ff ff c4 call 4001530c <fstat>
40015400: b0 10 20 00 clr %i0
40015404: 80 a2 20 00 cmp %o0, 0
40015408: 06 80 00 08 bl 40015428 <isatty+0x38> <== NEVER TAKEN
4001540c: c2 17 bf b4 lduh [ %fp + -76 ], %g1
40015410: 05 00 00 3c sethi %hi(0xf000), %g2
40015414: 82 08 40 02 and %g1, %g2, %g1
40015418: 05 00 00 08 sethi %hi(0x2000), %g2
4001541c: 82 18 40 02 xor %g1, %g2, %g1
40015420: 80 a0 00 01 cmp %g0, %g1
40015424: b0 60 3f ff subx %g0, -1, %i0
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
40015428: 81 c7 e0 08 ret
4001542c: 81 e8 00 00 restore
40018d6c <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
40018d6c: 81 c3 e0 08 retl <== NOT EXECUTED
40018d70: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
40002434 <libc_create_hook>:
*/
bool libc_create_hook(
rtems_tcb *current_task,
rtems_tcb *creating_task
)
{
40002434: 9d e3 bf 98 save %sp, -104, %sp
ptr = (struct _reent *) calloc(1, sizeof(struct _reent));
#else
/* It is OK to allocate from the workspace because these
* hooks run with thread dispatching disabled.
*/
ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent));
40002438: 90 10 24 00 mov 0x400, %o0
4000243c: 40 00 19 4e call 40008974 <_Workspace_Allocate>
40002440: b0 10 20 00 clr %i0
#endif
if (ptr) {
40002444: a2 92 20 00 orcc %o0, 0, %l1
40002448: 02 80 00 5a be 400025b0 <libc_create_hook+0x17c> <== NEVER TAKEN
4000244c: 82 04 63 48 add %l1, 0x348, %g1
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
40002450: c2 24 60 08 st %g1, [ %l1 + 8 ]
40002454: 82 04 63 a4 add %l1, 0x3a4, %g1
40002458: a0 04 62 ec add %l1, 0x2ec, %l0
4000245c: 92 10 20 00 clr %o1
40002460: 94 10 20 19 mov 0x19, %o2
40002464: c2 24 60 0c st %g1, [ %l1 + 0xc ]
40002468: c0 24 40 00 clr [ %l1 ]
4000246c: c0 24 60 10 clr [ %l1 + 0x10 ]
40002470: e0 24 60 04 st %l0, [ %l1 + 4 ]
40002474: 40 00 29 61 call 4000c9f8 <memset>
40002478: 90 04 60 14 add %l1, 0x14, %o0
4000247c: 03 10 00 59 sethi %hi(0x40016400), %g1
40002480: 82 10 60 10 or %g1, 0x10, %g1 ! 40016410 <__func__.4755+0x288>
40002484: 92 10 20 00 clr %o1
40002488: 94 10 20 24 mov 0x24, %o2
4000248c: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
40002490: c0 24 60 30 clr [ %l1 + 0x30 ]
40002494: c0 24 60 38 clr [ %l1 + 0x38 ]
40002498: c0 24 60 3c clr [ %l1 + 0x3c ]
4000249c: c0 24 60 40 clr [ %l1 + 0x40 ]
400024a0: c0 24 60 44 clr [ %l1 + 0x44 ]
400024a4: c0 24 60 48 clr [ %l1 + 0x48 ]
400024a8: c0 24 60 4c clr [ %l1 + 0x4c ]
400024ac: c0 24 60 50 clr [ %l1 + 0x50 ]
400024b0: c0 24 60 54 clr [ %l1 + 0x54 ]
400024b4: c0 24 60 58 clr [ %l1 + 0x58 ]
400024b8: c0 24 60 5c clr [ %l1 + 0x5c ]
400024bc: c0 2c 60 60 clrb [ %l1 + 0x60 ]
400024c0: 40 00 29 4e call 4000c9f8 <memset>
400024c4: 90 04 60 7c add %l1, 0x7c, %o0
400024c8: 03 00 00 0c sethi %hi(0x3000), %g1
400024cc: 82 10 63 0e or %g1, 0x30e, %g1 ! 330e <PROM_START+0x330e>
400024d0: c2 34 60 b0 sth %g1, [ %l1 + 0xb0 ]
400024d4: 03 3f ff ea sethi %hi(0xffffa800), %g1
400024d8: 82 10 63 cd or %g1, 0x3cd, %g1 ! ffffabcd <LEON_REG+0x7fffabcd>
400024dc: c2 34 60 b2 sth %g1, [ %l1 + 0xb2 ]
400024e0: 03 00 00 04 sethi %hi(0x1000), %g1
400024e4: 82 10 62 34 or %g1, 0x234, %g1 ! 1234 <PROM_START+0x1234>
400024e8: c2 34 60 b4 sth %g1, [ %l1 + 0xb4 ]
400024ec: 03 3f ff f9 sethi %hi(0xffffe400), %g1
400024f0: 82 10 62 6d or %g1, 0x26d, %g1 ! ffffe66d <LEON_REG+0x7fffe66d>
400024f4: c2 34 60 b6 sth %g1, [ %l1 + 0xb6 ]
400024f8: 03 3f ff f7 sethi %hi(0xffffdc00), %g1
400024fc: 82 10 62 ec or %g1, 0x2ec, %g1 ! ffffdeec <LEON_REG+0x7fffdeec>
40002500: c2 34 60 b8 sth %g1, [ %l1 + 0xb8 ]
40002504: 82 10 20 05 mov 5, %g1
40002508: 84 10 20 00 clr %g2
4000250c: 86 10 20 01 mov 1, %g3
40002510: c2 34 60 ba sth %g1, [ %l1 + 0xba ]
40002514: c4 3c 60 a8 std %g2, [ %l1 + 0xa8 ]
40002518: 82 10 20 0b mov 0xb, %g1
4000251c: c0 24 60 a0 clr [ %l1 + 0xa0 ]
40002520: c2 34 60 bc sth %g1, [ %l1 + 0xbc ]
40002524: c0 24 60 c0 clr [ %l1 + 0xc0 ]
40002528: c0 24 60 c4 clr [ %l1 + 0xc4 ]
4000252c: c0 24 60 c8 clr [ %l1 + 0xc8 ]
40002530: c0 24 60 cc clr [ %l1 + 0xcc ]
40002534: c0 24 60 d0 clr [ %l1 + 0xd0 ]
40002538: c0 24 60 d4 clr [ %l1 + 0xd4 ]
4000253c: c0 24 60 fc clr [ %l1 + 0xfc ]
40002540: c0 24 61 00 clr [ %l1 + 0x100 ]
40002544: c0 24 61 04 clr [ %l1 + 0x104 ]
40002548: c0 24 61 08 clr [ %l1 + 0x108 ]
4000254c: c0 24 61 0c clr [ %l1 + 0x10c ]
40002550: c0 24 61 10 clr [ %l1 + 0x110 ]
40002554: c0 24 61 14 clr [ %l1 + 0x114 ]
40002558: c0 24 61 18 clr [ %l1 + 0x118 ]
4000255c: c0 24 61 1c clr [ %l1 + 0x11c ]
40002560: c0 24 61 20 clr [ %l1 + 0x120 ]
40002564: c0 2c 60 d8 clrb [ %l1 + 0xd8 ]
40002568: c0 2c 60 e0 clrb [ %l1 + 0xe0 ]
4000256c: c0 24 60 f8 clr [ %l1 + 0xf8 ]
40002570: c0 24 61 48 clr [ %l1 + 0x148 ]
40002574: c0 24 61 4c clr [ %l1 + 0x14c ]
40002578: c0 24 61 50 clr [ %l1 + 0x150 ]
4000257c: c0 24 61 54 clr [ %l1 + 0x154 ]
40002580: c0 24 62 d4 clr [ %l1 + 0x2d4 ]
40002584: c0 24 61 d4 clr [ %l1 + 0x1d4 ]
40002588: 90 10 00 10 mov %l0, %o0
4000258c: c0 24 62 dc clr [ %l1 + 0x2dc ]
40002590: c0 24 62 e0 clr [ %l1 + 0x2e0 ]
40002594: c0 24 62 e4 clr [ %l1 + 0x2e4 ]
40002598: c0 24 62 e8 clr [ %l1 + 0x2e8 ]
4000259c: 92 10 20 00 clr %o1
400025a0: 94 10 21 14 mov 0x114, %o2
400025a4: 40 00 29 15 call 4000c9f8 <memset>
400025a8: b0 10 20 01 mov 1, %i0
creating_task->libc_reent = ptr;
400025ac: e2 26 61 58 st %l1, [ %i1 + 0x158 ]
return true;
}
else
return false;
}
400025b0: 81 c7 e0 08 ret
400025b4: 81 e8 00 00 restore
40002378 <libc_delete_hook>:
rtems_extension libc_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
40002378: 9d e3 bf 98 save %sp, -104, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
4000237c: 80 a6 00 19 cmp %i0, %i1
40002380: 32 80 00 04 bne,a 40002390 <libc_delete_hook+0x18>
40002384: e0 06 61 58 ld [ %i1 + 0x158 ], %l0
ptr = _REENT;
40002388: 03 10 00 5d sethi %hi(0x40017400), %g1
4000238c: e0 00 62 d0 ld [ %g1 + 0x2d0 ], %l0 ! 400176d0 <_impure_ptr>
} else {
ptr = deleted_task->libc_reent;
}
if (ptr && ptr != &libc_global_reent) {
40002390: 80 a4 20 00 cmp %l0, 0
40002394: 02 80 00 0b be 400023c0 <libc_delete_hook+0x48> <== NEVER TAKEN
40002398: 03 10 00 5c sethi %hi(0x40017000), %g1
4000239c: 82 10 62 68 or %g1, 0x268, %g1 ! 40017268 <libc_global_reent>
400023a0: 80 a4 00 01 cmp %l0, %g1
400023a4: 02 80 00 07 be 400023c0 <libc_delete_hook+0x48>
400023a8: 13 10 00 08 sethi %hi(0x40002000), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
400023ac: 90 10 00 10 mov %l0, %o0
400023b0: 40 00 29 33 call 4000c87c <_fwalk>
400023b4: 92 12 63 dc or %o1, 0x3dc, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
400023b8: 40 00 19 68 call 40008958 <_Workspace_Free>
400023bc: 90 10 00 10 mov %l0, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
400023c0: 80 a6 00 19 cmp %i0, %i1
400023c4: 12 80 00 04 bne 400023d4 <libc_delete_hook+0x5c>
400023c8: c0 26 61 58 clr [ %i1 + 0x158 ]
_REENT = 0;
400023cc: 03 10 00 5d sethi %hi(0x40017400), %g1
400023d0: c0 20 62 d0 clr [ %g1 + 0x2d0 ] ! 400176d0 <_impure_ptr>
400023d4: 81 c7 e0 08 ret
400023d8: 81 e8 00 00 restore
40015554 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
40015554: 9d e3 bf 98 save %sp, -104, %sp
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
40015558: 03 10 00 60 sethi %hi(0x40018000), %g1
4001555c: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
40015560: 80 a0 60 03 cmp %g1, 3
40015564: 12 80 00 16 bne 400155bc <libc_wrapup+0x68> <== NEVER TAKEN
40015568: 31 10 00 5d sethi %hi(0x40017400), %i0
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != &libc_global_reent) {
4001556c: c4 06 22 d0 ld [ %i0 + 0x2d0 ], %g2 ! 400176d0 <_impure_ptr>
40015570: 03 10 00 5c sethi %hi(0x40017000), %g1
40015574: a0 10 62 68 or %g1, 0x268, %l0 ! 40017268 <libc_global_reent>
40015578: 80 a0 80 10 cmp %g2, %l0
4001557c: 22 80 00 06 be,a 40015594 <libc_wrapup+0x40>
40015580: 21 10 00 5d sethi %hi(0x40017400), %l0
_wrapup_reent(&libc_global_reent);
40015584: 40 00 01 c9 call 40015ca8 <_wrapup_reent>
40015588: 90 10 00 10 mov %l0, %o0
/* Don't reclaim this one, just in case we do printfs
* on the way out to ROM.
*/
_reclaim_reent(&libc_global_reent);
#endif
_REENT = &libc_global_reent;
4001558c: e0 26 22 d0 st %l0, [ %i0 + 0x2d0 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
40015590: 21 10 00 5d sethi %hi(0x40017400), %l0
40015594: c2 04 22 d0 ld [ %l0 + 0x2d0 ], %g1 ! 400176d0 <_impure_ptr>
40015598: 7f ff db 45 call 4000c2ac <fclose>
4001559c: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
400155a0: c2 04 22 d0 ld [ %l0 + 0x2d0 ], %g1
400155a4: 7f ff db 42 call 4000c2ac <fclose>
400155a8: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
400155ac: c2 04 22 d0 ld [ %l0 + 0x2d0 ], %g1
400155b0: f0 00 60 0c ld [ %g1 + 0xc ], %i0
400155b4: 7f ff db 3e call 4000c2ac <fclose>
400155b8: 81 e8 00 00 restore
400155bc: 81 c7 e0 08 ret <== NOT EXECUTED
400155c0: 81 e8 00 00 restore <== NOT EXECUTED
40015430 <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
40015430: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
40015434: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED
40015438: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40017158 <rtems_libio_number_iops><== NOT EXECUTED
off_t lseek(
int fd,
off_t offset,
int whence
)
{
4001543c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
40015440: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
40015444: 1a 80 00 0e bcc 4001547c <lseek+0x4c> <== NOT EXECUTED
40015448: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
iop = rtems_libio_iop( fd );
4001544c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40015450: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops><== NOT EXECUTED
40015454: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
40015458: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
4001545c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40015460: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
40015464: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
40015468: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
4001546c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
40015470: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40015474: 32 80 00 06 bne,a 4001548c <lseek+0x5c> <== NOT EXECUTED
40015478: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
4001547c: 7f ff db 34 call 4000c14c <__errno> <== NOT EXECUTED
40015480: 01 00 00 00 nop <== NOT EXECUTED
40015484: 10 80 00 1c b 400154f4 <lseek+0xc4> <== NOT EXECUTED
40015488: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
4001548c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
40015490: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40015494: 12 80 00 06 bne 400154ac <lseek+0x7c> <== NOT EXECUTED
40015498: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
4001549c: 7f ff db 2c call 4000c14c <__errno> <== NOT EXECUTED
400154a0: 01 00 00 00 nop <== NOT EXECUTED
400154a4: 10 80 00 14 b 400154f4 <lseek+0xc4> <== NOT EXECUTED
400154a8: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
400154ac: 02 80 00 09 be 400154d0 <lseek+0xa0> <== NOT EXECUTED
400154b0: f4 06 20 08 ld [ %i0 + 8 ], %i2 <== NOT EXECUTED
400154b4: 80 a2 a0 02 cmp %o2, 2 <== NOT EXECUTED
400154b8: 02 80 00 08 be 400154d8 <lseek+0xa8> <== NOT EXECUTED
400154bc: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED
400154c0: 12 80 00 0a bne 400154e8 <lseek+0xb8> <== NOT EXECUTED
400154c4: 01 00 00 00 nop <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
400154c8: 10 80 00 0e b 40015500 <lseek+0xd0> <== NOT EXECUTED
400154cc: f2 26 20 08 st %i1, [ %i0 + 8 ] <== NOT EXECUTED
break;
case SEEK_CUR:
iop->offset += offset;
400154d0: 10 80 00 04 b 400154e0 <lseek+0xb0> <== NOT EXECUTED
400154d4: 82 06 40 1a add %i1, %i2, %g1 <== NOT EXECUTED
break;
case SEEK_END:
iop->offset = iop->size + offset;
400154d8: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
400154dc: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
400154e0: 10 80 00 08 b 40015500 <lseek+0xd0> <== NOT EXECUTED
400154e4: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
400154e8: 7f ff db 19 call 4000c14c <__errno> <== NOT EXECUTED
400154ec: 01 00 00 00 nop <== NOT EXECUTED
400154f0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
400154f4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400154f8: 10 80 00 09 b 4001551c <lseek+0xec> <== NOT EXECUTED
400154fc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
40015500: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
40015504: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
40015508: 9f c0 40 00 call %g1 <== NOT EXECUTED
4001550c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( status == (off_t) -1 )
40015510: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40015514: 22 80 00 02 be,a 4001551c <lseek+0xec> <== NOT EXECUTED
40015518: f4 26 20 08 st %i2, [ %i0 + 8 ] <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
4001551c: 81 c7 e0 08 ret <== NOT EXECUTED
40015520: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
4000a428 <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
4000a428: 9d e3 bf 98 save %sp, -104, %sp
4000a42c: 05 10 00 5f sethi %hi(0x40017c00), %g2
4000a430: 84 10 a1 58 or %g2, 0x158, %g2 ! 40017d58 <rtems_malloc_statistics>
4000a434: c2 00 a0 04 ld [ %g2 + 4 ], %g1
4000a438: a0 10 00 18 mov %i0, %l0
4000a43c: 82 00 60 01 inc %g1
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
4000a440: 7f ff ff ed call 4000a3f4 <malloc_deferred_frees_process>
4000a444: c2 20 a0 04 st %g1, [ %g2 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
4000a448: 80 a6 20 00 cmp %i0, 0
4000a44c: 02 80 00 33 be 4000a518 <malloc+0xf0> <== NEVER TAKEN
4000a450: 03 10 00 60 sethi %hi(0x40018000), %g1
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
4000a454: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
4000a458: 80 a0 60 03 cmp %g1, 3
4000a45c: 12 80 00 07 bne 4000a478 <malloc+0x50>
4000a460: 11 10 00 5f sethi %hi(0x40017c00), %o0
4000a464: 7f ff ff ca call 4000a38c <malloc_is_system_state_OK>
4000a468: 01 00 00 00 nop
4000a46c: 80 8a 20 ff btst 0xff, %o0
4000a470: 02 80 00 2a be 4000a518 <malloc+0xf0> <== NEVER TAKEN
4000a474: 11 10 00 5f sethi %hi(0x40017c00), %o0
* Try to give a segment in the current heap if there is not
* enough space then try to grow the heap.
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size );
4000a478: 92 10 00 10 mov %l0, %o1
4000a47c: 40 00 03 5e call 4000b1f4 <_Protected_heap_Allocate>
4000a480: 90 12 21 00 or %o0, 0x100, %o0
if ( !return_this ) {
4000a484: b0 92 20 00 orcc %o0, 0, %i0
4000a488: 12 80 00 14 bne 4000a4d8 <malloc+0xb0> <== ALWAYS TAKEN
4000a48c: 03 10 00 5e sethi %hi(0x40017800), %g1
if (rtems_malloc_sbrk_helpers)
4000a490: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
4000a494: c2 00 63 78 ld [ %g1 + 0x378 ], %g1 ! 40017b78 <rtems_malloc_sbrk_helpers><== NOT EXECUTED
4000a498: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a49c: 02 80 00 08 be 4000a4bc <malloc+0x94> <== NOT EXECUTED
4000a4a0: 01 00 00 00 nop <== NOT EXECUTED
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
4000a4a4: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
4000a4a8: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a4ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if ( !return_this ) {
4000a4b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000a4b4: 32 80 00 08 bne,a 4000a4d4 <malloc+0xac> <== NOT EXECUTED
4000a4b8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
errno = ENOMEM;
4000a4bc: 40 00 07 24 call 4000c14c <__errno> <== NOT EXECUTED
4000a4c0: 01 00 00 00 nop <== NOT EXECUTED
4000a4c4: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000a4c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000a4cc: 81 c7 e0 08 ret <== NOT EXECUTED
4000a4d0: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
4000a4d4: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
4000a4d8: c2 00 63 7c ld [ %g1 + 0x37c ], %g1 ! 40017b7c <rtems_malloc_dirty_helper>
4000a4dc: 80 a0 60 00 cmp %g1, 0
4000a4e0: 02 80 00 04 be 4000a4f0 <malloc+0xc8> <== ALWAYS TAKEN
4000a4e4: 92 10 00 10 mov %l0, %o1
(*rtems_malloc_dirty_helper)( return_this, size );
4000a4e8: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a4ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
4000a4f0: 03 10 00 5e sethi %hi(0x40017800), %g1
4000a4f4: c2 00 63 74 ld [ %g1 + 0x374 ], %g1 ! 40017b74 <rtems_malloc_statistics_helpers>
4000a4f8: 80 a0 60 00 cmp %g1, 0
4000a4fc: 02 80 00 08 be 4000a51c <malloc+0xf4> <== ALWAYS TAKEN
4000a500: 01 00 00 00 nop
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
4000a504: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
4000a508: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a50c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a510: 81 c7 e0 08 ret <== NOT EXECUTED
4000a514: 81 e8 00 00 restore <== NOT EXECUTED
4000a518: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
4000a51c: 81 c7 e0 08 ret
4000a520: 81 e8 00 00 restore
4000a3d8 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
4000a3d8: 92 10 00 08 mov %o0, %o1 <== 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 );
4000a3dc: 11 10 00 60 sethi %hi(0x40018000), %o0 <== NOT EXECUTED
4000a3e0: 90 12 21 8c or %o0, 0x18c, %o0 ! 4001818c <RTEMS_Malloc_GC_list><== NOT EXECUTED
4000a3e4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4000a3e8: 7f ff ee 99 call 40005e4c <_Chain_Append> <== NOT EXECUTED
4000a3ec: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4000a3f4 <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
4000a3f4: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
4000a3f8: 03 10 00 60 sethi %hi(0x40018000), %g1
4000a3fc: 10 80 00 04 b 4000a40c <malloc_deferred_frees_process+0x18>
4000a400: a0 10 61 8c or %g1, 0x18c, %l0 ! 4001818c <RTEMS_Malloc_GC_list>
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
free(to_be_freed);
4000a404: 7f ff fe a9 call 40009ea8 <free> <== NOT EXECUTED
4000a408: 01 00 00 00 nop <== NOT EXECUTED
4000a40c: 40 00 02 3d call 4000ad00 <_Chain_Get>
4000a410: 90 10 00 10 mov %l0, %o0
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)
4000a414: 80 a2 20 00 cmp %o0, 0
4000a418: 12 bf ff fb bne 4000a404 <malloc_deferred_frees_process+0x10><== NEVER TAKEN
4000a41c: 01 00 00 00 nop
free(to_be_freed);
}
4000a420: 81 c7 e0 08 ret
4000a424: 81 e8 00 00 restore
4000a38c <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 )
4000a38c: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a390: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
4000a394: 80 a0 60 00 cmp %g1, 0
4000a398: 12 80 00 07 bne 4000a3b4 <malloc_is_system_state_OK+0x28> <== NEVER TAKEN
4000a39c: 90 10 20 00 clr %o0
return false;
if ( _ISR_Nest_level > 0 )
4000a3a0: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a3a4: c2 00 63 6c ld [ %g1 + 0x36c ], %g1 ! 40017f6c <_ISR_Nest_level>
4000a3a8: 80 a0 00 01 cmp %g0, %g1
4000a3ac: 82 60 3f ff subx %g0, -1, %g1
4000a3b0: 90 10 00 01 mov %g1, %o0
return false;
return true;
}
4000a3b4: 81 c3 e0 08 retl
40008f9c <miniIMFS_initialize>:
int miniIMFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
return IMFS_initialize_support(
40008f9c: 13 10 00 59 sethi %hi(0x40016400), %o1
40008fa0: 15 10 00 5f sethi %hi(0x40017c00), %o2
40008fa4: 92 12 62 18 or %o1, 0x218, %o1
40008fa8: 94 12 a0 8c or %o2, 0x8c, %o2
40008fac: 96 10 00 0a mov %o2, %o3
40008fb0: 82 13 c0 00 mov %o7, %g1
40008fb4: 40 00 02 6d call 40009968 <IMFS_initialize_support>
40008fb8: 9e 10 40 00 mov %g1, %o7
40008fbc: 01 00 00 00 nop
40008fc0: 40 00 90 0c call 4002cff0 <__end+0x14c38> <== NOT EXECUTED
40008fc4: 40 00 90 14 call 4002d014 <__end+0x14c5c> <== NOT EXECUTED
40008fc8: 40 00 90 20 call 4002d048 <__end+0x14c90> <== NOT EXECUTED
40008fcc: 40 00 90 20 call 4002d04c <__end+0x14c94> <== NOT EXECUTED
40008fd0: 40 00 90 2c call 4002d080 <__end+0x14cc8> <== NOT EXECUTED
40008fd4: 40 00 90 2c call 4002d084 <__end+0x14ccc> <== NOT EXECUTED
4000220c <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
4000220c: 9d e3 bf 80 save %sp, -128, %sp
rtems_filesystem_location_info_t temp_loc;
int i;
const char *name_start;
int result;
if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) )
40002210: 03 00 00 3c sethi %hi(0xf000), %g1
40002214: b3 2e 60 10 sll %i1, 0x10, %i1
40002218: b3 36 60 10 srl %i1, 0x10, %i1
4000221c: 84 8e 40 01 andcc %i1, %g1, %g2
40002220: 32 80 00 06 bne,a 40002238 <mknod+0x2c> <== ALWAYS TAKEN
40002224: 03 00 00 04 sethi %hi(0x1000), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40002228: 40 00 27 c9 call 4000c14c <__errno> <== NOT EXECUTED
4000222c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002230: 10 80 00 36 b 40002308 <mknod+0xfc> <== NOT EXECUTED
40002234: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
if ( S_ISFIFO(mode) )
40002238: 80 a0 80 01 cmp %g2, %g1
4000223c: 02 80 00 30 be 400022fc <mknod+0xf0> <== NEVER TAKEN
40002240: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
40002244: c2 4e 00 00 ldsb [ %i0 ], %g1
40002248: 80 a0 60 2f cmp %g1, 0x2f
4000224c: 02 80 00 06 be 40002264 <mknod+0x58> <== ALWAYS TAKEN
40002250: 80 a0 60 5c cmp %g1, 0x5c
40002254: 02 80 00 04 be 40002264 <mknod+0x58> <== NOT EXECUTED
40002258: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000225c: 12 80 00 0a bne 40002284 <mknod+0x78> <== NOT EXECUTED
40002260: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40002264: 03 10 00 5d sethi %hi(0x40017400), %g1
40002268: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 ! 4001767c <rtems_current_user_env>
4000226c: 90 07 bf e4 add %fp, -28, %o0
40002270: 92 02 60 14 add %o1, 0x14, %o1
40002274: 40 00 29 a8 call 4000c914 <memcpy>
40002278: 94 10 20 10 mov 0x10, %o2
4000227c: 10 80 00 08 b 4000229c <mknod+0x90>
40002280: 84 10 20 01 mov 1, %g2
40002284: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 <== NOT EXECUTED
40002288: 90 07 bf e4 add %fp, -28, %o0 <== NOT EXECUTED
4000228c: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
40002290: 40 00 29 a1 call 4000c914 <memcpy> <== NOT EXECUTED
40002294: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
40002298: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ( !temp_loc.ops->evalformake_h ) {
4000229c: c2 07 bf ec ld [ %fp + -20 ], %g1
400022a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
400022a4: 80 a0 60 00 cmp %g1, 0
400022a8: 02 80 00 15 be 400022fc <mknod+0xf0> <== NEVER TAKEN
400022ac: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
400022b0: 90 06 00 02 add %i0, %g2, %o0
400022b4: a0 07 bf e4 add %fp, -28, %l0
400022b8: 94 07 bf f4 add %fp, -12, %o2
400022bc: 92 10 00 10 mov %l0, %o1
400022c0: 9f c0 40 00 call %g1
400022c4: b0 10 3f ff mov -1, %i0
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
400022c8: 80 a2 20 00 cmp %o0, 0
400022cc: 12 80 00 10 bne 4000230c <mknod+0x100> <== NEVER TAKEN
400022d0: c2 07 bf ec ld [ %fp + -20 ], %g1
return -1;
if ( !temp_loc.ops->mknod_h ) {
400022d4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
400022d8: 80 a0 a0 00 cmp %g2, 0
400022dc: 12 80 00 0e bne 40002314 <mknod+0x108> <== ALWAYS TAKEN
400022e0: d0 07 bf f4 ld [ %fp + -12 ], %o0
rtems_filesystem_freenode( &temp_loc );
400022e4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
400022e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400022ec: 02 80 00 04 be 400022fc <mknod+0xf0> <== NOT EXECUTED
400022f0: 01 00 00 00 nop <== NOT EXECUTED
400022f4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400022f8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
400022fc: 40 00 27 94 call 4000c14c <__errno> <== NOT EXECUTED
40002300: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002304: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
40002308: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000230c: 81 c7 e0 08 ret <== NOT EXECUTED
40002310: 81 e8 00 00 restore <== NOT EXECUTED
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
40002314: 92 10 00 19 mov %i1, %o1
40002318: 94 10 00 1a mov %i2, %o2
4000231c: 96 10 00 1b mov %i3, %o3
40002320: 9f c0 80 00 call %g2
40002324: 98 10 00 10 mov %l0, %o4
rtems_filesystem_freenode( &temp_loc );
40002328: c2 07 bf ec ld [ %fp + -20 ], %g1
4000232c: 80 a0 60 00 cmp %g1, 0
40002330: 02 bf ff f7 be 4000230c <mknod+0x100> <== NEVER TAKEN
40002334: b0 10 00 08 mov %o0, %i0
40002338: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000233c: 80 a0 60 00 cmp %g1, 0
40002340: 02 80 00 04 be 40002350 <mknod+0x144> <== ALWAYS TAKEN
40002344: 01 00 00 00 nop
40002348: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000234c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return result;
}
40002350: 81 c7 e0 08 ret
40002354: 81 e8 00 00 restore
4000a56c <mount>:
const rtems_filesystem_operations_table *fs_ops,
rtems_filesystem_options_t options,
const char *device,
const char *mount_point
)
{
4000a56c: 9d e3 bf 88 save %sp, -120, %sp
/*
* Is there a file system operations table?
*/
if ( fs_ops == NULL ) {
4000a570: 80 a6 60 00 cmp %i1, 0
4000a574: 02 80 00 05 be 4000a588 <mount+0x1c> <== NEVER TAKEN
4000a578: a4 10 00 18 mov %i0, %l2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
4000a57c: 80 a6 a0 01 cmp %i2, 1
4000a580: 28 80 00 06 bleu,a 4000a598 <mount+0x2c> <== ALWAYS TAKEN
4000a584: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
options != RTEMS_FILESYSTEM_READ_WRITE ) {
errno = EINVAL;
4000a588: 40 00 06 f1 call 4000c14c <__errno> <== NOT EXECUTED
4000a58c: 01 00 00 00 nop <== NOT EXECUTED
4000a590: 10 80 00 15 b 4000a5e4 <mount+0x78> <== NOT EXECUTED
4000a594: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
4000a598: 80 a0 60 00 cmp %g1, 0
4000a59c: 12 80 00 05 bne 4000a5b0 <mount+0x44> <== ALWAYS TAKEN
4000a5a0: 80 a6 e0 00 cmp %i3, 0
errno = ENOTSUP;
4000a5a4: a2 10 20 00 clr %l1 <== NOT EXECUTED
4000a5a8: 10 80 00 47 b 4000a6c4 <mount+0x158> <== NOT EXECUTED
4000a5ac: b8 10 20 00 clr %i4 <== NOT EXECUTED
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
4000a5b0: 02 80 00 05 be 4000a5c4 <mount+0x58> <== ALWAYS TAKEN
4000a5b4: 90 10 20 64 mov 0x64, %o0
size += strlen( device ) + 1;
4000a5b8: 40 00 0c 07 call 4000d5d4 <strlen> <== NOT EXECUTED
4000a5bc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000a5c0: 90 02 20 65 add %o0, 0x65, %o0 <== NOT EXECUTED
temp_mt_entry = malloc( size );
4000a5c4: 7f ff ff 99 call 4000a428 <malloc>
4000a5c8: 01 00 00 00 nop
if ( !temp_mt_entry ) {
4000a5cc: a0 92 20 00 orcc %o0, 0, %l0
4000a5d0: 12 80 00 07 bne 4000a5ec <mount+0x80> <== ALWAYS TAKEN
4000a5d4: a2 10 00 10 mov %l0, %l1
errno = ENOMEM;
4000a5d8: 40 00 06 dd call 4000c14c <__errno> <== NOT EXECUTED
4000a5dc: 01 00 00 00 nop <== NOT EXECUTED
4000a5e0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
4000a5e4: 10 80 00 74 b 4000a7b4 <mount+0x248> <== NOT EXECUTED
4000a5e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;
temp_mt_entry->options = options;
4000a5ec: f4 24 20 28 st %i2, [ %l0 + 0x28 ]
if ( device ) {
4000a5f0: 80 a6 e0 00 cmp %i3, 0
4000a5f4: 02 80 00 08 be 4000a614 <mount+0xa8> <== ALWAYS TAKEN
4000a5f8: e0 24 20 24 st %l0, [ %l0 + 0x24 ]
temp_mt_entry->dev =
4000a5fc: 90 04 20 64 add %l0, 0x64, %o0 <== NOT EXECUTED
(char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t );
strcpy( temp_mt_entry->dev, device );
4000a600: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000a604: 40 00 0b d2 call 4000d54c <strcpy> <== NOT EXECUTED
4000a608: d0 24 20 60 st %o0, [ %l0 + 0x60 ] <== NOT EXECUTED
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( mount_point ) {
4000a60c: 10 80 00 04 b 4000a61c <mount+0xb0> <== NOT EXECUTED
4000a610: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
if ( device ) {
temp_mt_entry->dev =
(char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t );
strcpy( temp_mt_entry->dev, device );
} else
temp_mt_entry->dev = 0;
4000a614: c0 24 20 60 clr [ %l0 + 0x60 ]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( mount_point ) {
4000a618: 80 a7 20 00 cmp %i4, 0
4000a61c: 02 80 00 37 be 4000a6f8 <mount+0x18c> <== ALWAYS TAKEN
4000a620: 90 10 00 1c mov %i4, %o0
if ( rtems_filesystem_evaluate_path(
4000a624: 92 10 20 07 mov 7, %o1 <== NOT EXECUTED
4000a628: b8 07 bf e8 add %fp, -24, %i4 <== NOT EXECUTED
4000a62c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
4000a630: 7f ff de 47 call 40001f4c <rtems_filesystem_evaluate_path><== NOT EXECUTED
4000a634: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4000a638: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
4000a63c: 02 80 00 4e be 4000a774 <mount+0x208> <== NOT EXECUTED
4000a640: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
4000a644: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
4000a648: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a64c: 02 80 00 1e be 4000a6c4 <mount+0x158> <== NOT EXECUTED
4000a650: 01 00 00 00 nop <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
4000a654: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a658: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000a65c: 80 a2 20 01 cmp %o0, 1 <== NOT EXECUTED
4000a660: 02 80 00 07 be 4000a67c <mount+0x110> <== NOT EXECUTED
4000a664: 03 10 00 60 sethi %hi(0x40018000), %g1 <== NOT EXECUTED
errno = ENOTDIR;
4000a668: 40 00 06 b9 call 4000c14c <__errno> <== NOT EXECUTED
4000a66c: 01 00 00 00 nop <== NOT EXECUTED
4000a670: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
4000a674: 10 80 00 41 b 4000a778 <mount+0x20c> <== NOT EXECUTED
4000a678: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node;
if ( the_mount_entry->mt_fs_root.node_access == loc->node_access )
4000a67c: c8 07 bf e8 ld [ %fp + -24 ], %g4 <== NOT EXECUTED
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
4000a680: c4 00 61 98 ld [ %g1 + 0x198 ], %g2 <== NOT EXECUTED
4000a684: 82 10 61 98 or %g1, 0x198, %g1 <== NOT EXECUTED
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
4000a688: 10 80 00 06 b 4000a6a0 <mount+0x134> <== NOT EXECUTED
4000a68c: 86 00 60 04 add %g1, 4, %g3 <== NOT EXECUTED
the_node = the_node->next ) {
the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node;
if ( the_mount_entry->mt_fs_root.node_access == loc->node_access )
4000a690: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
4000a694: 02 80 00 08 be 4000a6b4 <mount+0x148> <== NOT EXECUTED
4000a698: 01 00 00 00 nop <== NOT EXECUTED
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
the_node = the_node->next ) {
4000a69c: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
4000a6a0: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000a6a4: 32 bf ff fb bne,a 4000a690 <mount+0x124> <== NOT EXECUTED
4000a6a8: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 <== NOT EXECUTED
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
temp_mt_entry->mt_point_node.handlers = loc.handlers;
4000a6ac: 10 80 00 45 b 4000a7c0 <mount+0x254> <== NOT EXECUTED
4000a6b0: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
/*
* You can only mount one file system onto a single mount point.
*/
if ( Is_node_fs_root( &loc ) ){
errno = EBUSY;
4000a6b4: 40 00 06 a6 call 4000c14c <__errno> <== NOT EXECUTED
4000a6b8: b8 07 bf e8 add %fp, -24, %i4 <== NOT EXECUTED
4000a6bc: 10 bf ff ee b 4000a674 <mount+0x108> <== NOT EXECUTED
4000a6c0: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
errno = ENOTSUP;
4000a6c4: 40 00 06 a2 call 4000c14c <__errno> <== NOT EXECUTED
4000a6c8: 01 00 00 00 nop <== NOT EXECUTED
4000a6cc: 10 bf ff ea b 4000a674 <mount+0x108> <== NOT EXECUTED
4000a6d0: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( temp_mt_entry ) ) {
4000a6d4: 9f c0 c0 00 call %g3 <== NOT EXECUTED
4000a6d8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000a6dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000a6e0: 02 80 00 04 be 4000a6f0 <mount+0x184> <== NOT EXECUTED
4000a6e4: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
4000a6e8: 10 80 00 24 b 4000a778 <mount+0x20c> <== NOT EXECUTED
4000a6ec: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
4000a6f0: 10 80 00 0a b 4000a718 <mount+0x1ac> <== NOT EXECUTED
4000a6f4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
* This is a mount of the base file system --> The
* mt_point_node.node_access will be set to null to indicate that this
* is the root of the entire file system.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
4000a6f8: c0 24 20 18 clr [ %l0 + 0x18 ]
temp_mt_entry->mt_fs_root.handlers = NULL;
4000a6fc: c0 24 20 1c clr [ %l0 + 0x1c ]
temp_mt_entry->mt_fs_root.ops = NULL;
4000a700: c0 24 20 20 clr [ %l0 + 0x20 ]
temp_mt_entry->mt_point_node.node_access = NULL;
4000a704: c0 24 20 08 clr [ %l0 + 8 ]
temp_mt_entry->mt_point_node.handlers = NULL;
4000a708: c0 24 20 0c clr [ %l0 + 0xc ]
temp_mt_entry->mt_point_node.ops = NULL;
4000a70c: c0 24 20 10 clr [ %l0 + 0x10 ]
temp_mt_entry->mt_point_node.mt_entry = NULL;
4000a710: c0 24 20 14 clr [ %l0 + 0x14 ]
4000a714: b8 10 20 00 clr %i4
}
if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {
4000a718: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
4000a71c: 9f c0 40 00 call %g1
4000a720: 90 10 00 10 mov %l0, %o0
4000a724: 80 a2 20 00 cmp %o0, 0
4000a728: 02 80 00 09 be 4000a74c <mount+0x1e0> <== ALWAYS TAKEN
4000a72c: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* try to undo the mount operation */
if ( loc.ops->unmount_h ) {
4000a730: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 <== NOT EXECUTED
4000a734: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a738: 02 80 00 10 be 4000a778 <mount+0x20c> <== NOT EXECUTED
4000a73c: 01 00 00 00 nop <== NOT EXECUTED
loc.ops->unmount_h( temp_mt_entry );
4000a740: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a744: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000a748: 30 80 00 0c b,a 4000a778 <mount+0x20c> <== 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 );
4000a74c: 11 10 00 60 sethi %hi(0x40018000), %o0
4000a750: 92 10 00 10 mov %l0, %o1
4000a754: 7f ff ed be call 40005e4c <_Chain_Append>
4000a758: 90 12 21 98 or %o0, 0x198, %o0
*/
rtems_chain_append( &rtems_filesystem_mount_table_control,
&temp_mt_entry->Node );
if ( mt_entry )
4000a75c: 80 a4 a0 00 cmp %l2, 0
4000a760: 02 80 00 03 be 4000a76c <mount+0x200> <== NEVER TAKEN
4000a764: b0 10 20 00 clr %i0
*mt_entry = temp_mt_entry;
4000a768: e0 24 80 00 st %l0, [ %l2 ]
4000a76c: 81 c7 e0 08 ret
4000a770: 81 e8 00 00 restore
4000a774: b8 10 20 00 clr %i4 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
4000a778: 7f ff fd cc call 40009ea8 <free> <== NOT EXECUTED
4000a77c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if ( loc_to_free )
4000a780: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000a784: 02 bf ff fa be 4000a76c <mount+0x200> <== NOT EXECUTED
4000a788: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
4000a78c: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
4000a790: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a794: 02 80 00 09 be 4000a7b8 <mount+0x24c> <== NOT EXECUTED
4000a798: 01 00 00 00 nop <== NOT EXECUTED
4000a79c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
4000a7a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a7a4: 02 80 00 05 be 4000a7b8 <mount+0x24c> <== NOT EXECUTED
4000a7a8: 01 00 00 00 nop <== NOT EXECUTED
4000a7ac: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000a7b0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000a7b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
4000a7b8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a7bc: 81 e8 00 00 restore <== NOT EXECUTED
* traverse the tree.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
temp_mt_entry->mt_point_node.handlers = loc.handlers;
temp_mt_entry->mt_point_node.ops = loc.ops;
4000a7c0: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
temp_mt_entry->mt_point_node.handlers = loc.handlers;
4000a7c4: c4 24 20 0c st %g2, [ %l0 + 0xc ] <== NOT EXECUTED
temp_mt_entry->mt_point_node.ops = loc.ops;
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
4000a7c8: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
4000a7cc: c6 00 60 20 ld [ %g1 + 0x20 ], %g3 <== NOT EXECUTED
* 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.
*/
temp_mt_entry->mt_point_node.node_access = loc.node_access;
4000a7d0: c8 24 20 08 st %g4, [ %l0 + 8 ] <== NOT EXECUTED
temp_mt_entry->mt_point_node.handlers = loc.handlers;
temp_mt_entry->mt_point_node.ops = loc.ops;
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
4000a7d4: c4 24 20 14 st %g2, [ %l0 + 0x14 ] <== NOT EXECUTED
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
4000a7d8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000a7dc: 12 bf ff be bne 4000a6d4 <mount+0x168> <== NOT EXECUTED
4000a7e0: c2 24 20 10 st %g1, [ %l0 + 0x10 ] <== NOT EXECUTED
errno = ENOTSUP;
4000a7e4: 10 bf ff b8 b 4000a6c4 <mount+0x158> <== NOT EXECUTED
4000a7e8: b8 07 bf e8 add %fp, -24, %i4 <== NOT EXECUTED
400023dc <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
400023dc: 9d e3 bf 98 save %sp, -104, %sp
switch ( fileno(fp) ) {
400023e0: 40 00 28 3c call 4000c4d0 <fileno>
400023e4: 90 10 00 18 mov %i0, %o0
400023e8: 80 a2 20 02 cmp %o0, 2
400023ec: 18 80 00 0e bgu 40002424 <newlib_free_buffers+0x48> <== NEVER TAKEN
400023f0: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
400023f4: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
400023f8: 80 88 60 80 btst 0x80, %g1
400023fc: 02 80 00 0c be 4000242c <newlib_free_buffers+0x50>
40002400: 01 00 00 00 nop
free( fp->_bf._base );
40002404: 40 00 1e a9 call 40009ea8 <free>
40002408: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
fp->_flags &= ~__SMBF;
4000240c: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40002410: c0 26 20 10 clr [ %i0 + 0x10 ]
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
40002414: 82 08 7f 7f and %g1, -129, %g1
fp->_bf._base = fp->_p = (unsigned char *) NULL;
40002418: c0 26 00 00 clr [ %i0 ]
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
4000241c: 10 80 00 04 b 4000242c <newlib_free_buffers+0x50>
40002420: c2 36 20 0c sth %g1, [ %i0 + 0xc ]
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
40002424: 40 00 27 a2 call 4000c2ac <fclose> <== NOT EXECUTED
40002428: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
4000242c: 81 c7 e0 08 ret
40002430: 91 e8 20 00 restore %g0, 0, %o0
400027d4 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
400027d4: 9d e3 bf 98 save %sp, -104, %sp
rtems_device_driver status;
if ( !initialized ) {
400027d8: 05 10 00 6d sethi %hi(0x4001b400), %g2
400027dc: c2 48 a3 b8 ldsb [ %g2 + 0x3b8 ], %g1 ! 4001b7b8 <initialized>
400027e0: 80 a0 60 00 cmp %g1, 0
400027e4: 12 80 00 0e bne 4000281c <null_initialize+0x48>
400027e8: 82 10 20 01 mov 1, %g1
initialized = 1;
status = rtems_io_register_name(
400027ec: 11 10 00 64 sethi %hi(0x40019000), %o0
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
400027f0: c2 28 a3 b8 stb %g1, [ %g2 + 0x3b8 ]
status = rtems_io_register_name(
400027f4: 90 12 22 30 or %o0, 0x230, %o0
400027f8: 92 10 00 18 mov %i0, %o1
400027fc: 40 00 00 4d call 40002930 <rtems_io_register_name>
40002800: 94 10 20 00 clr %o2
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
40002804: 80 a2 20 00 cmp %o0, 0
40002808: 02 80 00 04 be 40002818 <null_initialize+0x44> <== ALWAYS TAKEN
4000280c: 03 10 00 6e sethi %hi(0x4001b800), %g1
rtems_fatal_error_occurred(status);
40002810: 40 00 10 28 call 400068b0 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002814: 01 00 00 00 nop <== NOT EXECUTED
NULL_major = major;
40002818: f0 20 61 4c st %i0, [ %g1 + 0x14c ]
}
return RTEMS_SUCCESSFUL;
}
4000281c: 81 c7 e0 08 ret
40002820: 91 e8 20 00 restore %g0, 0, %o0
400027b0 <null_write>:
void *pargp
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
400027b0: 80 a2 a0 00 cmp %o2, 0
400027b4: 02 80 00 04 be 400027c4 <null_write+0x14> <== ALWAYS TAKEN
400027b8: 01 00 00 00 nop
rw_args->bytes_moved = rw_args->count;
400027bc: c2 02 a0 0c ld [ %o2 + 0xc ], %g1
400027c0: c2 22 a0 14 st %g1, [ %o2 + 0x14 ]
return NULL_SUCCESSFUL;
}
400027c4: 81 c3 e0 08 retl
400027c8: 90 10 20 00 clr %o0
4000262c <open>:
int open(
const char *pathname,
int flags,
...
)
{
4000262c: 9d e3 bf 80 save %sp, -128, %sp
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
40002630: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40002634: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40002638: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000263c: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
40002640: 82 06 60 01 add %i1, 1, %g1
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
40002644: 80 88 60 02 btst 2, %g1
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
40002648: 82 08 60 01 and %g1, 1, %g1
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
4000264c: 02 80 00 03 be 40002658 <open+0x2c>
40002650: a1 28 60 02 sll %g1, 2, %l0
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
40002654: a0 14 20 02 or %l0, 2, %l0
va_start(ap, flags);
mode = va_arg( ap, int );
40002658: 82 07 a0 50 add %fp, 0x50, %g1
4000265c: f4 07 a0 4c ld [ %fp + 0x4c ], %i2
40002660: c2 27 bf f4 st %g1, [ %fp + -12 ]
* 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();
40002664: 40 00 1f 07 call 4000a280 <rtems_libio_allocate>
40002668: ba 10 20 17 mov 0x17, %i5
if ( iop == 0 ) {
4000266c: b8 92 20 00 orcc %o0, 0, %i4
40002670: 02 80 00 93 be 400028bc <open+0x290>
40002674: 92 10 00 10 mov %l0, %o1
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
40002678: b6 07 bf e4 add %fp, -28, %i3
4000267c: 90 10 00 18 mov %i0, %o0
40002680: 94 10 00 1b mov %i3, %o2
40002684: 7f ff fe 32 call 40001f4c <rtems_filesystem_evaluate_path>
40002688: 96 10 20 01 mov 1, %o3
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
4000268c: 80 a2 3f ff cmp %o0, -1
40002690: 12 80 00 25 bne 40002724 <open+0xf8> <== ALWAYS TAKEN
40002694: 82 0e 6a 00 and %i1, 0xa00, %g1
if ( errno != ENOENT ) {
40002698: 40 00 26 ad call 4000c14c <__errno> <== NOT EXECUTED
4000269c: 01 00 00 00 nop <== NOT EXECUTED
400026a0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
400026a4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
400026a8: 12 80 00 11 bne 400026ec <open+0xc0> <== NOT EXECUTED
400026ac: 01 00 00 00 nop <== 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) ) {
400026b0: 80 8e 62 00 btst 0x200, %i1 <== NOT EXECUTED
400026b4: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
400026b8: 02 80 00 6f be 40002874 <open+0x248> <== NOT EXECUTED
400026bc: a0 10 20 00 clr %l0 <== NOT EXECUTED
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
400026c0: 13 3f ff e0 sethi %hi(0xffff8000), %o1 <== NOT EXECUTED
400026c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400026c8: 92 16 80 09 or %i2, %o1, %o1 <== NOT EXECUTED
400026cc: 94 10 20 00 clr %o2 <== NOT EXECUTED
400026d0: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
400026d4: 96 10 20 00 clr %o3 <== NOT EXECUTED
400026d8: 7f ff fe cd call 4000220c <mknod> <== NOT EXECUTED
400026dc: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
if ( rc ) {
400026e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400026e4: 02 80 00 06 be 400026fc <open+0xd0> <== NOT EXECUTED
400026e8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rc = errno;
400026ec: 40 00 26 98 call 4000c14c <__errno> <== NOT EXECUTED
400026f0: 01 00 00 00 nop <== NOT EXECUTED
400026f4: 10 80 00 5c b 40002864 <open+0x238> <== NOT EXECUTED
400026f8: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
400026fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40002700: 92 10 20 00 clr %o1 <== NOT EXECUTED
40002704: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
40002708: 7f ff fe 11 call 40001f4c <rtems_filesystem_evaluate_path><== NOT EXECUTED
4000270c: ba 10 20 0d mov 0xd, %i5 <== NOT EXECUTED
if ( status != 0 ) { /* The file did not exist */
40002710: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40002714: 12 80 00 58 bne 40002874 <open+0x248> <== NOT EXECUTED
40002718: a0 10 20 00 clr %l0 <== NOT EXECUTED
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
4000271c: 10 80 00 07 b 40002738 <open+0x10c> <== NOT EXECUTED
40002720: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
40002724: a0 10 00 1b mov %i3, %l0
40002728: 80 a0 6a 00 cmp %g1, 0xa00
4000272c: 02 80 00 52 be 40002874 <open+0x248> <== NEVER TAKEN
40002730: ba 10 20 11 mov 0x11, %i5
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
40002734: c2 07 bf e8 ld [ %fp + -24 ], %g1
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
40002738: e0 07 20 0c ld [ %i4 + 0xc ], %l0
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
4000273c: c2 27 20 30 st %g1, [ %i4 + 0x30 ]
iop->file_info = loc.node_access;
40002740: c2 07 bf e4 ld [ %fp + -28 ], %g1
iop->flags |= rtems_libio_fcntl_flags( flags );
40002744: 90 10 00 19 mov %i1, %o0
40002748: 40 00 1f 04 call 4000a358 <rtems_libio_fcntl_flags>
4000274c: c2 27 20 2c st %g1, [ %i4 + 0x2c ]
40002750: 90 12 00 10 or %o0, %l0, %o0
iop->pathinfo = loc;
40002754: 94 10 20 10 mov 0x10, %o2
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
40002758: d0 27 20 0c st %o0, [ %i4 + 0xc ]
iop->pathinfo = loc;
4000275c: a0 07 bf e4 add %fp, -28, %l0
40002760: 90 07 20 10 add %i4, 0x10, %o0
40002764: 40 00 28 6c call 4000c914 <memcpy>
40002768: 92 10 00 10 mov %l0, %o1
if ( !iop->handlers->open_h ) {
4000276c: c2 07 20 30 ld [ %i4 + 0x30 ], %g1
40002770: c2 00 40 00 ld [ %g1 ], %g1
40002774: 80 a0 60 00 cmp %g1, 0
40002778: 02 80 00 67 be 40002914 <open+0x2e8> <== NEVER TAKEN
4000277c: 92 10 00 18 mov %i0, %o1
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
40002780: 96 10 00 1a mov %i2, %o3
40002784: 90 10 00 1c mov %i4, %o0
40002788: 9f c0 40 00 call %g1
4000278c: 94 10 00 19 mov %i1, %o2
if ( rc )
40002790: ba 92 20 00 orcc %o0, 0, %i5
40002794: 12 80 00 39 bne 40002878 <open+0x24c> <== NEVER TAKEN
40002798: 80 a7 20 00 cmp %i4, 0
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
4000279c: 80 8e 64 00 btst 0x400, %i1
400027a0: 02 80 00 4c be 400028d0 <open+0x2a4> <== ALWAYS TAKEN
400027a4: 03 10 00 5f sethi %hi(0x40017c00), %g1
rc = ftruncate( iop - rtems_libio_iops, 0 );
400027a8: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40017cf0 <rtems_libio_iops><== NOT EXECUTED
400027ac: 92 10 20 00 clr %o1 <== NOT EXECUTED
400027b0: 84 27 00 02 sub %i4, %g2, %g2 <== NOT EXECUTED
400027b4: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED
400027b8: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
400027bc: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED
400027c0: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
400027c4: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED
400027c8: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
400027cc: 83 2a 20 0c sll %o0, 0xc, %g1 <== NOT EXECUTED
400027d0: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
400027d4: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED
400027d8: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED
400027dc: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
400027e0: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
400027e4: 40 00 1d db call 40009f50 <ftruncate> <== NOT EXECUTED
400027e8: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED
if ( rc ) {
400027ec: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
400027f0: 02 80 00 38 be 400028d0 <open+0x2a4> <== NOT EXECUTED
400027f4: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
if(errno) rc = errno;
400027f8: 40 00 26 55 call 4000c14c <__errno> <== NOT EXECUTED
400027fc: 01 00 00 00 nop <== NOT EXECUTED
40002800: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
40002804: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002808: 02 80 00 06 be 40002820 <open+0x1f4> <== NOT EXECUTED
4000280c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40002810: 40 00 26 4f call 4000c14c <__errno> <== NOT EXECUTED
40002814: 01 00 00 00 nop <== NOT EXECUTED
40002818: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
close( iop - rtems_libio_iops );
4000281c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40002820: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 40017cf0 <rtems_libio_iops><== NOT EXECUTED
40002824: 84 27 00 02 sub %i4, %g2, %g2 <== NOT EXECUTED
40002828: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED
4000282c: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
40002830: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED
40002834: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
40002838: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED
4000283c: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
40002840: 83 2a 20 0c sll %o0, 0xc, %g1 <== NOT EXECUTED
40002844: b8 10 20 00 clr %i4 <== NOT EXECUTED
40002848: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
4000284c: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED
40002850: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED
40002854: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
40002858: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
4000285c: 40 00 1d 60 call 40009ddc <close> <== NOT EXECUTED
40002860: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
40002864: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
40002868: 02 80 00 1a be 400028d0 <open+0x2a4> <== NOT EXECUTED
4000286c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40002870: a0 10 20 00 clr %l0 <== NOT EXECUTED
if ( iop )
40002874: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
40002878: 02 80 00 05 be 4000288c <open+0x260> <== NOT EXECUTED
4000287c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
rtems_libio_free( iop );
40002880: 40 00 1e 68 call 4000a220 <rtems_libio_free> <== NOT EXECUTED
40002884: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if ( loc_to_free )
40002888: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
4000288c: 02 80 00 0c be 400028bc <open+0x290> <== NOT EXECUTED
40002890: 01 00 00 00 nop <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
40002894: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
40002898: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000289c: 02 80 00 08 be 400028bc <open+0x290> <== NOT EXECUTED
400028a0: 01 00 00 00 nop <== NOT EXECUTED
400028a4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
400028a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400028ac: 02 80 00 04 be 400028bc <open+0x290> <== NOT EXECUTED
400028b0: 01 00 00 00 nop <== NOT EXECUTED
400028b4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400028b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( rc );
400028bc: 40 00 26 24 call 4000c14c <__errno>
400028c0: b0 10 3f ff mov -1, %i0
400028c4: fa 22 00 00 st %i5, [ %o0 ]
400028c8: 81 c7 e0 08 ret
400028cc: 81 e8 00 00 restore
}
return iop - rtems_libio_iops;
400028d0: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3
400028d4: 86 27 00 03 sub %i4, %g3, %g3
400028d8: 87 38 e0 02 sra %g3, 2, %g3
400028dc: 83 28 e0 02 sll %g3, 2, %g1
400028e0: 85 28 e0 06 sll %g3, 6, %g2
400028e4: 84 20 80 01 sub %g2, %g1, %g2
400028e8: 83 28 a0 06 sll %g2, 6, %g1
400028ec: 82 20 40 02 sub %g1, %g2, %g1
400028f0: 85 28 60 0c sll %g1, 0xc, %g2
400028f4: 82 00 40 02 add %g1, %g2, %g1
400028f8: 82 00 40 03 add %g1, %g3, %g1
400028fc: 83 28 60 04 sll %g1, 4, %g1
40002900: 82 20 40 03 sub %g1, %g3, %g1
40002904: 83 28 60 02 sll %g1, 2, %g1
40002908: b0 20 c0 01 sub %g3, %g1, %i0
}
4000290c: 81 c7 e0 08 ret
40002910: 81 e8 00 00 restore
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
40002914: 10 bf ff d8 b 40002874 <open+0x248> <== NOT EXECUTED
40002918: ba 10 20 86 mov 0x86, %i5 <== NOT EXECUTED
400025b8 <open_dev_console>:
/*
* This is a replaceable stub
*/
void open_dev_console(void)
{
400025b8: 9d e3 bf 98 save %sp, -104, %sp
int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
400025bc: 21 10 00 58 sethi %hi(0x40016000), %l0
400025c0: 92 10 20 00 clr %o1
400025c4: 90 14 20 e0 or %l0, 0xe0, %o0
400025c8: 40 00 00 19 call 4000262c <open>
400025cc: 94 10 20 00 clr %o2
400025d0: 80 a2 3f ff cmp %o0, -1
400025d4: 02 80 00 14 be 40002624 <open_dev_console+0x6c>
400025d8: 90 14 20 e0 or %l0, 0xe0, %o0
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
400025dc: 92 10 20 01 mov 1, %o1
400025e0: 40 00 00 13 call 4000262c <open>
400025e4: 94 10 20 00 clr %o2
400025e8: 80 a2 3f ff cmp %o0, -1
400025ec: 32 80 00 05 bne,a 40002600 <open_dev_console+0x48> <== ALWAYS TAKEN
400025f0: 90 14 20 e0 or %l0, 0xe0, %o0
rtems_fatal_error_occurred( error_code | '1' );
400025f4: 11 14 d5 11 sethi %hi(0x53544400), %o0 <== NOT EXECUTED
400025f8: 10 80 00 09 b 4000261c <open_dev_console+0x64> <== NOT EXECUTED
400025fc: 90 12 20 31 or %o0, 0x31, %o0 ! 53544431 <RAM_END+0x13144431><== NOT EXECUTED
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
40002600: 92 10 20 01 mov 1, %o1
40002604: 40 00 00 0a call 4000262c <open>
40002608: 94 10 20 00 clr %o2
4000260c: 80 a2 3f ff cmp %o0, -1
40002610: 12 80 00 05 bne 40002624 <open_dev_console+0x6c> <== ALWAYS TAKEN
40002614: 11 14 d5 11 sethi %hi(0x53544400), %o0
rtems_fatal_error_occurred( error_code | '2' );
40002618: 90 12 20 32 or %o0, 0x32, %o0 ! 53544432 <RAM_END+0x13144432><== NOT EXECUTED
4000261c: 40 00 0d 33 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002620: 01 00 00 00 nop <== NOT EXECUTED
40002624: 81 c7 e0 08 ret
40002628: 81 e8 00 00 restore
400033f8 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
400033f8: 9d e3 bf 98 save %sp, -104, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
400033fc: c8 06 60 34 ld [ %i1 + 0x34 ], %g4
40003400: 80 89 20 01 btst 1, %g4
40003404: 02 80 00 59 be 40003568 <oproc+0x170> <== NEVER TAKEN
40003408: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
4000340c: 82 0e 20 ff and %i0, 0xff, %g1
40003410: 80 a0 60 09 cmp %g1, 9
40003414: 22 80 00 2b be,a 400034c0 <oproc+0xc8>
40003418: c6 06 60 28 ld [ %i1 + 0x28 ], %g3
4000341c: 18 80 00 07 bgu 40003438 <oproc+0x40> <== ALWAYS TAKEN
40003420: 80 a0 60 0a cmp %g1, 0xa
40003424: 80 a0 60 08 cmp %g1, 8 <== NOT EXECUTED
40003428: 12 80 00 3c bne 40003518 <oproc+0x120> <== NOT EXECUTED
4000342c: 80 89 20 02 btst 2, %g4 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
40003430: 10 80 00 35 b 40003504 <oproc+0x10c> <== NOT EXECUTED
40003434: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
40003438: 02 80 00 06 be 40003450 <oproc+0x58>
4000343c: 80 a0 60 0d cmp %g1, 0xd
40003440: 32 80 00 36 bne,a 40003518 <oproc+0x120> <== ALWAYS TAKEN
40003444: 80 89 20 02 btst 2, %g4
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40003448: 10 80 00 10 b 40003488 <oproc+0x90> <== NOT EXECUTED
4000344c: 80 89 20 10 btst 0x10, %g4 <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
40003450: 80 89 20 20 btst 0x20, %g4
40003454: 32 80 00 02 bne,a 4000345c <oproc+0x64> <== NEVER TAKEN
40003458: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
4000345c: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
40003460: 80 88 60 04 btst 4, %g1
40003464: 02 80 00 42 be 4000356c <oproc+0x174> <== NEVER TAKEN
40003468: 94 10 00 19 mov %i1, %o2
rtems_termios_puts ("\r", 1, tty);
4000346c: 11 10 00 59 sethi %hi(0x40016400), %o0
40003470: 92 10 20 01 mov 1, %o1
40003474: 90 12 20 30 or %o0, 0x30, %o0
40003478: 7f ff ff 94 call 400032c8 <rtems_termios_puts>
4000347c: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
40003480: 10 80 00 3a b 40003568 <oproc+0x170>
40003484: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
40003488: 02 80 00 06 be 400034a0 <oproc+0xa8> <== NOT EXECUTED
4000348c: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED
40003490: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
40003494: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003498: 02 80 00 17 be 400034f4 <oproc+0xfc> <== NOT EXECUTED
4000349c: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
400034a0: 22 80 00 32 be,a 40003568 <oproc+0x170> <== NOT EXECUTED
400034a4: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
400034a8: 82 10 20 0a mov 0xa, %g1 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
400034ac: 80 89 20 20 btst 0x20, %g4 <== NOT EXECUTED
400034b0: 02 80 00 2e be 40003568 <oproc+0x170> <== NOT EXECUTED
400034b4: c2 2f a0 44 stb %g1, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
400034b8: 10 80 00 2c b 40003568 <oproc+0x170> <== NOT EXECUTED
400034bc: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
400034c0: 05 00 00 06 sethi %hi(0x1800), %g2
400034c4: 82 09 00 02 and %g4, %g2, %g1
400034c8: 80 a0 40 02 cmp %g1, %g2
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
400034cc: 84 08 e0 07 and %g3, 7, %g2
400034d0: 82 10 20 08 mov 8, %g1
400034d4: 92 20 40 02 sub %g1, %g2, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
400034d8: 12 80 00 09 bne 400034fc <oproc+0x104> <== NEVER TAKEN
400034dc: 84 02 40 03 add %o1, %g3, %g2
tty->column += i;
400034e0: c4 26 60 28 st %g2, [ %i1 + 0x28 ]
rtems_termios_puts ( " ", i, tty);
400034e4: 94 10 00 19 mov %i1, %o2
400034e8: 11 10 00 59 sethi %hi(0x40016400), %o0
400034ec: 7f ff ff 77 call 400032c8 <rtems_termios_puts>
400034f0: 90 12 20 38 or %o0, 0x38, %o0 ! 40016438 <__func__.4755+0x2b0>
400034f4: 81 c7 e0 08 ret
400034f8: 81 e8 00 00 restore
return;
}
tty->column += i;
400034fc: 10 80 00 1b b 40003568 <oproc+0x170> <== NOT EXECUTED
40003500: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED
break;
case '\b':
if (tty->column > 0)
40003504: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003508: 04 80 00 18 ble 40003568 <oproc+0x170> <== NOT EXECUTED
4000350c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
if (!iscntrl(c))
tty->column++;
40003510: 10 80 00 16 b 40003568 <oproc+0x170> <== NOT EXECUTED
40003514: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
40003518: 02 80 00 0b be 40003544 <oproc+0x14c> <== ALWAYS TAKEN
4000351c: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2
c = toupper(c);
40003520: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40003524: c2 00 62 c8 ld [ %g1 + 0x2c8 ], %g1 ! 400176c8 <__ctype_ptr><== NOT EXECUTED
40003528: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
4000352c: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED
40003530: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40003534: 32 80 00 02 bne,a 4000353c <oproc+0x144> <== NOT EXECUTED
40003538: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
4000353c: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
40003540: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2 <== NOT EXECUTED
40003544: 03 10 00 5d sethi %hi(0x40017400), %g1
40003548: c2 00 62 c8 ld [ %g1 + 0x2c8 ], %g1 ! 400176c8 <__ctype_ptr>
4000354c: c2 08 40 02 ldub [ %g1 + %g2 ], %g1
40003550: 80 88 60 20 btst 0x20, %g1
40003554: 12 80 00 06 bne 4000356c <oproc+0x174> <== NEVER TAKEN
40003558: 94 10 00 19 mov %i1, %o2
tty->column++;
4000355c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
40003560: 82 00 60 01 inc %g1
40003564: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
40003568: 94 10 00 19 mov %i1, %o2
4000356c: 90 07 a0 44 add %fp, 0x44, %o0
40003570: 7f ff ff 56 call 400032c8 <rtems_termios_puts>
40003574: 92 10 20 01 mov 1, %o1
40003578: 81 c7 e0 08 ret
4000357c: 81 e8 00 00 restore
40005244 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
40005244: 03 10 00 76 sethi %hi(0x4001d800), %g1
40005248: 82 10 62 60 or %g1, 0x260, %g1 ! 4001da60 <rtems_malloc_statistics>
4000524c: c4 00 60 08 ld [ %g1 + 8 ], %g2
40005250: 84 00 a0 01 inc %g2
40005254: c4 20 60 08 st %g2, [ %g1 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
40005258: 82 02 7f ff add %o1, -1, %g1
4000525c: 80 88 40 09 btst %g1, %o1
40005260: 12 80 00 04 bne 40005270 <posix_memalign+0x2c> <== NEVER TAKEN
40005264: 80 a2 60 03 cmp %o1, 3
40005268: 18 80 00 04 bgu 40005278 <posix_memalign+0x34>
4000526c: 01 00 00 00 nop
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
}
40005270: 81 c3 e0 08 retl
40005274: 90 10 20 16 mov 0x16, %o0 ! 16 <PROM_START+0x16>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
40005278: 82 13 c0 00 mov %o7, %g1
4000527c: 40 00 01 3f call 40005778 <rtems_memalign>
40005280: 9e 10 40 00 mov %g1, %o7
400155e4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
400155e4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
400155e8: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED
400155ec: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40017158 <rtems_libio_number_iops><== NOT EXECUTED
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
400155f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
400155f4: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
400155f8: 1a 80 00 0e bcc 40015630 <read+0x4c> <== NOT EXECUTED
400155fc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
iop = rtems_libio_iop( fd );
40015600: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
40015604: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops><== NOT EXECUTED
40015608: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
4001560c: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
40015610: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40015614: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
40015618: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
4001561c: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
40015620: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
40015624: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40015628: 12 80 00 06 bne 40015640 <read+0x5c> <== NOT EXECUTED
4001562c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40015630: 7f ff da c7 call 4000c14c <__errno> <== NOT EXECUTED
40015634: 01 00 00 00 nop <== NOT EXECUTED
40015638: 10 80 00 15 b 4001568c <read+0xa8> <== NOT EXECUTED
4001563c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
40015640: 02 80 00 08 be 40015660 <read+0x7c> <== NOT EXECUTED
40015644: 01 00 00 00 nop <== NOT EXECUTED
rtems_libio_check_count( count );
40015648: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4001564c: 02 80 00 1b be 400156b8 <read+0xd4> <== NOT EXECUTED
40015650: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ );
40015654: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40015658: 32 80 00 06 bne,a 40015670 <read+0x8c> <== NOT EXECUTED
4001565c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
40015660: 7f ff da bb call 4000c14c <__errno> <== NOT EXECUTED
40015664: 01 00 00 00 nop <== NOT EXECUTED
40015668: 10 80 00 09 b 4001568c <read+0xa8> <== NOT EXECUTED
4001566c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
40015670: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
40015674: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40015678: 12 80 00 08 bne 40015698 <read+0xb4> <== NOT EXECUTED
4001567c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
40015680: 7f ff da b3 call 4000c14c <__errno> <== NOT EXECUTED
40015684: 01 00 00 00 nop <== NOT EXECUTED
40015688: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
4001568c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40015690: 10 80 00 0a b 400156b8 <read+0xd4> <== NOT EXECUTED
40015694: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rc = (*iop->handlers->read_h)( iop, buffer, count );
40015698: 9f c0 40 00 call %g1 <== NOT EXECUTED
4001569c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( rc > 0 )
400156a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400156a4: 04 80 00 05 ble 400156b8 <read+0xd4> <== NOT EXECUTED
400156a8: 01 00 00 00 nop <== NOT EXECUTED
iop->offset += rc;
400156ac: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
400156b0: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED
400156b4: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
return rc;
}
400156b8: 81 c7 e0 08 ret <== NOT EXECUTED
400156bc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40015744 <realloc>:
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
40015744: 9d e3 bf 90 save %sp, -112, %sp
40015748: 07 10 00 5f sethi %hi(0x40017c00), %g3
4001574c: 86 10 e1 58 or %g3, 0x158, %g3 ! 40017d58 <rtems_malloc_statistics>
40015750: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
40015754: 05 10 00 60 sethi %hi(0x40018000), %g2
40015758: c4 00 a0 74 ld [ %g2 + 0x74 ], %g2 ! 40018074 <_System_state_Current>
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
4001575c: 82 00 60 01 inc %g1
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
40015760: 80 a0 a0 03 cmp %g2, 3
40015764: 12 80 00 0c bne 40015794 <realloc+0x50> <== NEVER TAKEN
40015768: c2 20 e0 10 st %g1, [ %g3 + 0x10 ]
if (_Thread_Dispatch_disable_level > 0)
4001576c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40015770: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 40017ed0 <_Thread_Dispatch_disable_level>
40015774: 80 a0 60 00 cmp %g1, 0
40015778: 32 80 00 13 bne,a 400157c4 <realloc+0x80> <== NEVER TAKEN
4001577c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return (void *) 0;
if (_ISR_Nest_level > 0)
40015780: 03 10 00 5f sethi %hi(0x40017c00), %g1
40015784: c2 00 63 6c ld [ %g1 + 0x36c ], %g1 ! 40017f6c <_ISR_Nest_level>
40015788: 80 a0 60 00 cmp %g1, 0
4001578c: 32 80 00 0e bne,a 400157c4 <realloc+0x80> <== NEVER TAKEN
40015790: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
40015794: 80 a6 20 00 cmp %i0, 0
40015798: 12 80 00 06 bne 400157b0 <realloc+0x6c> <== ALWAYS TAKEN
4001579c: 80 a6 60 00 cmp %i1, 0
return malloc( size );
400157a0: 7f ff d3 22 call 4000a428 <malloc> <== NOT EXECUTED
400157a4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
400157a8: 81 c7 e0 08 ret <== NOT EXECUTED
400157ac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if ( !size ) {
400157b0: 12 80 00 07 bne 400157cc <realloc+0x88> <== ALWAYS TAKEN
400157b4: 21 10 00 5f sethi %hi(0x40017c00), %l0
free( ptr );
400157b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400157bc: 7f ff d1 bb call 40009ea8 <free> <== NOT EXECUTED
400157c0: b0 10 20 00 clr %i0 <== NOT EXECUTED
400157c4: 81 c7 e0 08 ret <== NOT EXECUTED
400157c8: 81 e8 00 00 restore <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
400157cc: 92 10 00 18 mov %i0, %o1
400157d0: 90 14 21 00 or %l0, 0x100, %o0
400157d4: 40 00 00 63 call 40015960 <_Protected_heap_Get_block_size>
400157d8: 94 07 bf f4 add %fp, -12, %o2
400157dc: 80 8a 20 ff btst 0xff, %o0
400157e0: 12 80 00 08 bne 40015800 <realloc+0xbc>
400157e4: 90 14 21 00 or %l0, 0x100, %o0
errno = EINVAL;
400157e8: 7f ff da 59 call 4000c14c <__errno>
400157ec: b0 10 20 00 clr %i0
400157f0: 82 10 20 16 mov 0x16, %g1
400157f4: c2 22 00 00 st %g1, [ %o0 ]
400157f8: 81 c7 e0 08 ret
400157fc: 81 e8 00 00 restore
#if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)
if (rtems_malloc_boundary_helpers)
resize += (*rtems_malloc_boundary_helpers->overhead)();
#endif
if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) {
40015800: 92 10 00 18 mov %i0, %o1
40015804: 40 00 00 64 call 40015994 <_Protected_heap_Resize_block>
40015808: 94 10 00 19 mov %i1, %o2
4001580c: 80 8a 20 ff btst 0xff, %o0
40015810: 12 80 00 1b bne 4001587c <realloc+0x138>
40015814: 01 00 00 00 nop
* 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 );
40015818: 7f ff d3 04 call 4000a428 <malloc>
4001581c: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
40015820: 05 10 00 5f sethi %hi(0x40017c00), %g2
40015824: 84 10 a1 58 or %g2, 0x158, %g2 ! 40017d58 <rtems_malloc_statistics>
40015828: c2 00 a0 04 ld [ %g2 + 4 ], %g1
* 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 );
4001582c: a0 10 00 08 mov %o0, %l0
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
40015830: 82 00 7f ff add %g1, -1, %g1
if ( !new_area ) {
40015834: 80 a2 20 00 cmp %o0, 0
40015838: 02 80 00 10 be 40015878 <realloc+0x134> <== NEVER TAKEN
4001583c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
40015840: c2 07 bf f4 ld [ %fp + -12 ], %g1
40015844: 80 a6 40 01 cmp %i1, %g1
40015848: 08 80 00 03 bleu 40015854 <realloc+0x110> <== NEVER TAKEN
4001584c: 90 10 00 19 mov %i1, %o0
40015850: 90 10 00 01 mov %g1, %o0
40015854: 94 10 00 08 mov %o0, %o2
40015858: 92 10 00 18 mov %i0, %o1
4001585c: 7f ff dc 2e call 4000c914 <memcpy>
40015860: 90 10 00 10 mov %l0, %o0
free( ptr );
40015864: 90 10 00 18 mov %i0, %o0
40015868: 7f ff d1 90 call 40009ea8 <free>
4001586c: b0 10 00 10 mov %l0, %i0
40015870: 81 c7 e0 08 ret
40015874: 81 e8 00 00 restore
return new_area;
40015878: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
4001587c: 81 c7 e0 08 ret
40015880: 81 e8 00 00 restore
4000bb3c <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000bb3c: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
4000bb40: 90 10 00 18 mov %i0, %o0
4000bb44: 92 10 00 19 mov %i1, %o1
4000bb48: 40 00 00 07 call 4000bb64 <rtems_assoc_ptr_by_remote>
4000bb4c: b0 10 20 00 clr %i0
if (nap)
4000bb50: 80 a2 20 00 cmp %o0, 0
4000bb54: 32 80 00 02 bne,a 4000bb5c <rtems_assoc_local_by_remote+0x20><== ALWAYS TAKEN
4000bb58: f0 02 20 04 ld [ %o0 + 4 ], %i0
return nap->local_value;
return 0;
}
4000bb5c: 81 c7 e0 08 ret
4000bb60: 81 e8 00 00 restore
4000baf4 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000baf4: 9d e3 bf 98 save %sp, -104, %sp
4000baf8: a0 10 20 01 mov 1, %l0
4000bafc: a4 10 00 18 mov %i0, %l2
4000bb00: a2 10 20 00 clr %l1
4000bb04: b0 10 20 00 clr %i0
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
if (b & remote_value)
4000bb08: 80 8c 00 19 btst %l0, %i1
4000bb0c: 22 80 00 07 be,a 4000bb28 <rtems_assoc_local_by_remote_bitfield+0x34><== ALWAYS TAKEN
4000bb10: a2 04 60 01 inc %l1
local_value |= rtems_assoc_local_by_remote(ap, b);
4000bb14: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000bb18: 40 00 00 09 call 4000bb3c <rtems_assoc_local_by_remote> <== NOT EXECUTED
4000bb1c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4000bb20: b0 16 00 08 or %i0, %o0, %i0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
4000bb24: a2 04 60 01 inc %l1 <== NOT EXECUTED
4000bb28: 80 a4 60 20 cmp %l1, 0x20
4000bb2c: 12 bf ff f7 bne 4000bb08 <rtems_assoc_local_by_remote_bitfield+0x14>
4000bb30: a1 2c 20 01 sll %l0, 1, %l0
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
4000bb34: 81 c7 e0 08 ret
4000bb38: 81 e8 00 00 restore
4000dac4 <rtems_assoc_name_bad>:
const char *
rtems_assoc_name_bad(
uint32_t bad_value
)
{
4000dac4: 11 10 00 6f sethi %hi(0x4001bc00), %o0 <== NOT EXECUTED
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
}
4000dac8: 81 c3 e0 08 retl <== NOT EXECUTED
4000dacc: 90 12 22 28 or %o0, 0x228, %o0 ! 4001be28 <bad_buffer.5015><== NOT EXECUTED
4000bbf4 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000bbf4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
4000bbf8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000bbfc: 40 00 00 0b call 4000bc28 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
4000bc00: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (nap)
4000bc04: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000bc08: 02 80 00 05 be 4000bc1c <rtems_assoc_name_by_local+0x28> <== NOT EXECUTED
4000bc0c: 01 00 00 00 nop <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
4000bc10: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
4000bc14: 81 c7 e0 08 ret <== NOT EXECUTED
4000bc18: 81 e8 00 00 restore <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
4000bc1c: 40 00 07 aa call 4000dac4 <rtems_assoc_name_bad> <== NOT EXECUTED
4000bc20: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
4000c0cc <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000c0cc: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000c0d0: d0 06 00 00 ld [ %i0 ], %o0
4000c0d4: 80 a2 20 00 cmp %o0, 0
4000c0d8: 02 80 00 0e be 4000c110 <rtems_assoc_ptr_by_local+0x44> <== NEVER TAKEN
4000c0dc: 84 10 20 00 clr %g2
4000c0e0: 13 10 00 5a sethi %hi(0x40016800), %o1
4000c0e4: 40 00 04 ea call 4000d48c <strcmp>
4000c0e8: 92 12 62 48 or %o1, 0x248, %o1 ! 40016a48 <__func__.5594+0x18>
4000c0ec: 80 a2 20 00 cmp %o0, 0
4000c0f0: 02 80 00 07 be 4000c10c <rtems_assoc_ptr_by_local+0x40> <== NEVER TAKEN
4000c0f4: 84 10 00 18 mov %i0, %g2
default_ap = ap++;
4000c0f8: 10 80 00 06 b 4000c110 <rtems_assoc_ptr_by_local+0x44>
4000c0fc: 84 10 20 00 clr %g2
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
4000c100: 80 a0 40 19 cmp %g1, %i1
4000c104: 02 80 00 08 be 4000c124 <rtems_assoc_ptr_by_local+0x58>
4000c108: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
4000c10c: b0 06 20 0c add %i0, 0xc, %i0
4000c110: c2 06 00 00 ld [ %i0 ], %g1
4000c114: 80 a0 60 00 cmp %g1, 0
4000c118: 32 bf ff fa bne,a 4000c100 <rtems_assoc_ptr_by_local+0x34>
4000c11c: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000c120: b0 10 00 02 mov %g2, %i0
if (ap->local_value == local_value)
return ap;
return default_ap;
}
4000c124: 81 c7 e0 08 ret
4000c128: 81 e8 00 00 restore
4000bb64 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000bb64: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000bb68: d0 06 00 00 ld [ %i0 ], %o0
4000bb6c: 80 a2 20 00 cmp %o0, 0
4000bb70: 02 80 00 0e be 4000bba8 <rtems_assoc_ptr_by_remote+0x44> <== NEVER TAKEN
4000bb74: 84 10 20 00 clr %g2
4000bb78: 13 10 00 5a sethi %hi(0x40016800), %o1
4000bb7c: 40 00 06 44 call 4000d48c <strcmp>
4000bb80: 92 12 62 48 or %o1, 0x248, %o1 ! 40016a48 <__func__.5594+0x18>
4000bb84: 80 a2 20 00 cmp %o0, 0
4000bb88: 02 80 00 07 be 4000bba4 <rtems_assoc_ptr_by_remote+0x40> <== NEVER TAKEN
4000bb8c: 84 10 00 18 mov %i0, %g2
default_ap = ap++;
4000bb90: 10 80 00 06 b 4000bba8 <rtems_assoc_ptr_by_remote+0x44>
4000bb94: 84 10 20 00 clr %g2
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000bb98: 80 a0 40 19 cmp %g1, %i1
4000bb9c: 02 80 00 08 be 4000bbbc <rtems_assoc_ptr_by_remote+0x58>
4000bba0: 01 00 00 00 nop
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
4000bba4: b0 06 20 0c add %i0, 0xc, %i0
4000bba8: c2 06 00 00 ld [ %i0 ], %g1
4000bbac: 80 a0 60 00 cmp %g1, 0
4000bbb0: 32 bf ff fa bne,a 4000bb98 <rtems_assoc_ptr_by_remote+0x34><== ALWAYS TAKEN
4000bbb4: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000bbb8: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
4000bbbc: 81 c7 e0 08 ret
4000bbc0: 81 e8 00 00 restore
4000bbc4 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
4000bbc4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
4000bbc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000bbcc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000bbd0: 40 00 01 3f call 4000c0cc <rtems_assoc_ptr_by_local> <== NOT EXECUTED
4000bbd4: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (nap)
4000bbd8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000bbdc: 32 80 00 02 bne,a 4000bbe4 <rtems_assoc_remote_by_local+0x20><== NOT EXECUTED
4000bbe0: f0 02 20 08 ld [ %o0 + 8 ], %i0 <== NOT EXECUTED
return nap->remote_value;
return 0;
}
4000bbe4: 81 c7 e0 08 ret <== NOT EXECUTED
4000bbe8: 81 e8 00 00 restore <== NOT EXECUTED
40005a0c <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
40005a0c: 9d e3 bf 90 save %sp, -112, %sp
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
40005a10: a2 96 20 00 orcc %i0, 0, %l1
40005a14: 02 80 00 1b be 40005a80 <rtems_barrier_create+0x74> <== NEVER TAKEN
40005a18: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
40005a1c: 80 a6 e0 00 cmp %i3, 0
40005a20: 02 80 00 18 be 40005a80 <rtems_barrier_create+0x74> <== NEVER TAKEN
40005a24: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
40005a28: 80 8e 60 10 btst 0x10, %i1
40005a2c: 02 80 00 06 be 40005a44 <rtems_barrier_create+0x38>
40005a30: 80 a6 a0 00 cmp %i2, 0
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
40005a34: 02 80 00 13 be 40005a80 <rtems_barrier_create+0x74>
40005a38: b0 10 20 0a mov 0xa, %i0
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
40005a3c: 10 80 00 04 b 40005a4c <rtems_barrier_create+0x40>
40005a40: c0 27 bf f0 clr [ %fp + -16 ]
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
40005a44: 82 10 20 01 mov 1, %g1
40005a48: c2 27 bf f0 st %g1, [ %fp + -16 ]
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40005a4c: 05 10 00 6f sethi %hi(0x4001bc00), %g2
40005a50: c2 00 a0 c0 ld [ %g2 + 0xc0 ], %g1 ! 4001bcc0 <_Thread_Dispatch_disable_level>
the_attributes.maximum_count = maximum_waiters;
40005a54: f4 27 bf f4 st %i2, [ %fp + -12 ]
40005a58: 82 00 60 01 inc %g1
40005a5c: c2 20 a0 c0 st %g1, [ %g2 + 0xc0 ]
* 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 );
40005a60: 21 10 00 6e sethi %hi(0x4001b800), %l0
40005a64: 40 00 07 9d call 400078d8 <_Objects_Allocate>
40005a68: 90 14 23 44 or %l0, 0x344, %o0 ! 4001bb44 <_Barrier_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
40005a6c: b4 92 20 00 orcc %o0, 0, %i2
40005a70: 12 80 00 06 bne 40005a88 <rtems_barrier_create+0x7c>
40005a74: 90 06 a0 14 add %i2, 0x14, %o0
_Thread_Enable_dispatch();
40005a78: 40 00 0b 45 call 4000878c <_Thread_Enable_dispatch>
40005a7c: b0 10 20 05 mov 5, %i0
40005a80: 81 c7 e0 08 ret
40005a84: 81 e8 00 00 restore
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
40005a88: 92 07 bf f0 add %fp, -16, %o1
40005a8c: 40 00 05 55 call 40006fe0 <_CORE_barrier_Initialize>
40005a90: f2 26 a0 10 st %i1, [ %i2 + 0x10 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40005a94: c4 06 a0 08 ld [ %i2 + 8 ], %g2
40005a98: 82 14 23 44 or %l0, 0x344, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
40005a9c: e2 26 a0 0c st %l1, [ %i2 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40005aa0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
40005aa4: c4 26 c0 00 st %g2, [ %i3 ]
40005aa8: 03 00 00 3f sethi %hi(0xfc00), %g1
40005aac: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40005ab0: 84 08 80 01 and %g2, %g1, %g2
40005ab4: 85 28 a0 02 sll %g2, 2, %g2
_Thread_Enable_dispatch();
40005ab8: b0 10 20 00 clr %i0
40005abc: 40 00 0b 34 call 4000878c <_Thread_Enable_dispatch>
40005ac0: f4 20 c0 02 st %i2, [ %g3 + %g2 ]
return RTEMS_SUCCESSFUL;
}
40005ac4: 81 c7 e0 08 ret
40005ac8: 81 e8 00 00 restore
40005b6c <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
40005b6c: 9d e3 bf 90 save %sp, -112, %sp
40005b70: a0 10 00 18 mov %i0, %l0
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
40005b74: 80 a6 60 00 cmp %i1, 0
40005b78: 02 80 00 12 be 40005bc0 <rtems_barrier_release+0x54> <== NEVER TAKEN
40005b7c: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
40005b80: 11 10 00 6e sethi %hi(0x4001b800), %o0
40005b84: 92 10 00 10 mov %l0, %o1
40005b88: 90 12 23 44 or %o0, 0x344, %o0
40005b8c: 40 00 08 ad call 40007e40 <_Objects_Get>
40005b90: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
40005b94: c2 07 bf f4 ld [ %fp + -12 ], %g1
40005b98: 80 a0 60 00 cmp %g1, 0
40005b9c: 12 80 00 09 bne 40005bc0 <rtems_barrier_release+0x54>
40005ba0: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
40005ba4: 92 10 00 10 mov %l0, %o1
40005ba8: 94 10 20 00 clr %o2
40005bac: 40 00 05 19 call 40007010 <_CORE_barrier_Release>
40005bb0: 90 02 20 14 add %o0, 0x14, %o0
_Thread_Enable_dispatch();
40005bb4: b0 10 20 00 clr %i0
40005bb8: 40 00 0a f5 call 4000878c <_Thread_Enable_dispatch>
40005bbc: d0 26 40 00 st %o0, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40005bc0: 81 c7 e0 08 ret
40005bc4: 81 e8 00 00 restore
40005bc8 <rtems_barrier_wait>:
rtems_status_code rtems_barrier_wait(
rtems_id id,
rtems_interval timeout
)
{
40005bc8: 9d e3 bf 90 save %sp, -112, %sp
40005bcc: 11 10 00 6e sethi %hi(0x4001b800), %o0
40005bd0: 92 10 00 18 mov %i0, %o1
40005bd4: 90 12 23 44 or %o0, 0x344, %o0
40005bd8: 40 00 08 9a call 40007e40 <_Objects_Get>
40005bdc: 94 07 bf f4 add %fp, -12, %o2
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
40005be0: c2 07 bf f4 ld [ %fp + -12 ], %g1
40005be4: 84 10 00 08 mov %o0, %g2
rtems_status_code rtems_barrier_wait(
rtems_id id,
rtems_interval timeout
)
{
40005be8: 96 10 00 19 mov %i1, %o3
Barrier_Control *the_barrier;
Objects_Locations location;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
40005bec: 80 a0 60 00 cmp %g1, 0
40005bf0: 12 80 00 0d bne 40005c24 <rtems_barrier_wait+0x5c>
40005bf4: 90 10 20 04 mov 4, %o0
case OBJECTS_LOCAL:
_CORE_barrier_Wait(
40005bf8: 90 00 a0 14 add %g2, 0x14, %o0
40005bfc: 92 10 00 18 mov %i0, %o1
40005c00: 94 10 20 01 mov 1, %o2
40005c04: 40 00 05 0e call 4000703c <_CORE_barrier_Wait>
40005c08: 98 10 20 00 clr %o4
id,
TRUE,
timeout,
NULL
);
_Thread_Enable_dispatch();
40005c0c: 40 00 0a e0 call 4000878c <_Thread_Enable_dispatch>
40005c10: 01 00 00 00 nop
return _Barrier_Translate_core_barrier_return_code(
40005c14: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40005c18: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 4001bd80 <_Thread_Executing>
40005c1c: 40 00 17 ba call 4000bb04 <_Barrier_Translate_core_barrier_return_code>
40005c20: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40005c24: 81 c7 e0 08 ret
40005c28: 91 e8 00 08 restore %g0, %o0, %o0
40005c2c: 40 00 5c 78 call 4001ce0c <__end+0xca4>
40005c30: 40 00 5c 80 call 4001ce30 <__end+0xcc8>
40005c34: 40 00 5c 88 call 4001ce54 <__end+0xcec>
40005c38: 40 00 5c 98 call 4001ce98 <__end+0xd30>
40005c3c: 40 00 5c ac call 4001ceec <__end+0xd84> <== NOT EXECUTED
40004ab0 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
40004ab0: 9d e3 bf 98 save %sp, -104, %sp
40004ab4: 82 10 00 18 mov %i0, %g1
if ( !time_buffer )
40004ab8: 80 a6 60 00 cmp %i1, 0
40004abc: 02 80 00 1a be 40004b24 <rtems_clock_get+0x74> <== NEVER TAKEN
40004ac0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
40004ac4: 80 a0 60 04 cmp %g1, 4
40004ac8: 18 80 00 17 bgu 40004b24 <rtems_clock_get+0x74>
40004acc: b0 10 20 0a mov 0xa, %i0
40004ad0: 83 28 60 02 sll %g1, 2, %g1
40004ad4: 05 10 00 12 sethi %hi(0x40004800), %g2
40004ad8: 84 10 a2 9c or %g2, 0x29c, %g2 ! 40004a9c <rtems_termios_rxdaemon+0x70>
40004adc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40004ae0: 81 c0 40 00 jmp %g1
40004ae4: 01 00 00 00 nop
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
40004ae8: 40 00 00 2b call 40004b94 <rtems_clock_get_tod>
40004aec: 91 e8 00 19 restore %g0, %i1, %o0
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
40004af0: 40 00 00 0f call 40004b2c <rtems_clock_get_seconds_since_epoch>
40004af4: 91 e8 00 19 restore %g0, %i1, %o0
case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
40004af8: 40 00 00 23 call 40004b84 <rtems_clock_get_ticks_since_boot>
40004afc: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
40004b00: 10 80 00 05 b 40004b14 <rtems_clock_get+0x64>
40004b04: d0 26 40 00 st %o0, [ %i1 ]
40004b08: 40 00 00 17 call 40004b64 <rtems_clock_get_ticks_per_second>
40004b0c: 01 00 00 00 nop
40004b10: d0 26 40 00 st %o0, [ %i1 ]
40004b14: 81 c7 e0 08 ret
40004b18: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
40004b1c: 40 00 00 4d call 40004c50 <rtems_clock_get_tod_timeval>
40004b20: 91 e8 00 19 restore %g0, %i1, %o0
break;
}
return RTEMS_INVALID_NUMBER;
}
40004b24: 81 c7 e0 08 ret
40004b28: 81 e8 00 00 restore
40004b2c <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
40004b2c: 84 92 20 00 orcc %o0, 0, %g2
40004b30: 02 80 00 0b be 40004b5c <rtems_clock_get_seconds_since_epoch+0x30><== NEVER TAKEN
40004b34: 90 10 20 09 mov 9, %o0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
40004b38: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004b3c: c2 08 62 e4 ldub [ %g1 + 0x2e4 ], %g1 ! 40017ee4 <_TOD_Is_set>
40004b40: 80 a0 60 00 cmp %g1, 0
40004b44: 02 80 00 06 be 40004b5c <rtems_clock_get_seconds_since_epoch+0x30>
40004b48: 90 10 20 0b mov 0xb, %o0
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
40004b4c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004b50: c2 00 63 60 ld [ %g1 + 0x360 ], %g1 ! 40017f60 <_TOD_Now>
40004b54: 90 10 20 00 clr %o0
40004b58: c2 20 80 00 st %g1, [ %g2 ]
return RTEMS_SUCCESSFUL;
}
40004b5c: 81 c3 e0 08 retl
40004b94 <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
40004b94: 9d e3 bf 60 save %sp, -160, %sp
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
40004b98: a2 96 20 00 orcc %i0, 0, %l1
40004b9c: 02 80 00 2b be 40004c48 <rtems_clock_get_tod+0xb4> <== NEVER TAKEN
40004ba0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
40004ba4: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004ba8: c2 08 62 e4 ldub [ %g1 + 0x2e4 ], %g1 ! 40017ee4 <_TOD_Is_set>
40004bac: 80 a0 60 00 cmp %g1, 0
40004bb0: 02 80 00 26 be 40004c48 <rtems_clock_get_tod+0xb4>
40004bb4: b0 10 20 0b mov 0xb, %i0
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
40004bb8: 7f ff f4 49 call 40001cdc <sparc_disable_interrupts>
40004bbc: 01 00 00 00 nop
40004bc0: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
40004bc4: 40 00 05 ae call 4000627c <_TOD_Get>
40004bc8: 90 07 bf e8 add %fp, -24, %o0
_ISR_Enable(level);
40004bcc: 7f ff f4 48 call 40001cec <sparc_enable_interrupts>
40004bd0: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
40004bd4: c2 07 bf e8 ld [ %fp + -24 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
40004bd8: d0 07 bf ec ld [ %fp + -20 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
40004bdc: c2 27 bf f0 st %g1, [ %fp + -16 ]
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
40004be0: 40 00 39 2b call 4001308c <.udiv>
40004be4: 92 10 23 e8 mov 0x3e8, %o1
/* Obtain the current time */
_TOD_Get_timeval( &now );
/* Split it into a closer format */
gmtime_r( &now.tv_sec, &time );
40004be8: 92 07 bf c4 add %fp, -60, %o1
40004bec: d0 27 bf f4 st %o0, [ %fp + -12 ]
40004bf0: 40 00 1f 44 call 4000c900 <gmtime_r>
40004bf4: 90 07 bf f0 add %fp, -16, %o0
tmbuf->month = time.tm_mon + 1;
tmbuf->day = time.tm_mday;
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
40004bf8: 03 10 00 60 sethi %hi(0x40018000), %g1
40004bfc: d2 00 60 70 ld [ %g1 + 0x70 ], %o1 ! 40018070 <_TOD_Microseconds_per_tick>
gmtime_r( &now.tv_sec, &time );
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
tmbuf->month = time.tm_mon + 1;
tmbuf->day = time.tm_mday;
40004c00: c2 07 bf d0 ld [ %fp + -48 ], %g1
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
40004c04: d0 07 bf f4 ld [ %fp + -12 ], %o0
gmtime_r( &now.tv_sec, &time );
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
tmbuf->month = time.tm_mon + 1;
tmbuf->day = time.tm_mday;
40004c08: c2 24 60 08 st %g1, [ %l1 + 8 ]
tmbuf->hour = time.tm_hour;
40004c0c: c2 07 bf cc ld [ %fp + -52 ], %g1
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
40004c10: b0 10 20 00 clr %i0
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
tmbuf->month = time.tm_mon + 1;
tmbuf->day = time.tm_mday;
tmbuf->hour = time.tm_hour;
40004c14: c2 24 60 0c st %g1, [ %l1 + 0xc ]
tmbuf->minute = time.tm_min;
40004c18: c2 07 bf c8 ld [ %fp + -56 ], %g1
40004c1c: c2 24 60 10 st %g1, [ %l1 + 0x10 ]
tmbuf->second = time.tm_sec;
40004c20: c2 07 bf c4 ld [ %fp + -60 ], %g1
40004c24: c2 24 60 14 st %g1, [ %l1 + 0x14 ]
/* Split it into a closer format */
gmtime_r( &now.tv_sec, &time );
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
40004c28: c2 07 bf d8 ld [ %fp + -40 ], %g1
40004c2c: 82 00 67 6c add %g1, 0x76c, %g1
40004c30: c2 24 40 00 st %g1, [ %l1 ]
tmbuf->month = time.tm_mon + 1;
40004c34: c2 07 bf d4 ld [ %fp + -44 ], %g1
40004c38: 82 00 60 01 inc %g1
tmbuf->day = time.tm_mday;
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
40004c3c: 40 00 39 14 call 4001308c <.udiv>
40004c40: c2 24 60 04 st %g1, [ %l1 + 4 ]
40004c44: d0 24 60 18 st %o0, [ %l1 + 0x18 ]
return RTEMS_SUCCESSFUL;
}
40004c48: 81 c7 e0 08 ret
40004c4c: 81 e8 00 00 restore
40004c50 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
40004c50: 9d e3 bf 90 save %sp, -112, %sp
if ( !time )
40004c54: a2 96 20 00 orcc %i0, 0, %l1
40004c58: 02 80 00 15 be 40004cac <rtems_clock_get_tod_timeval+0x5c><== NEVER TAKEN
40004c5c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
40004c60: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004c64: c2 08 62 e4 ldub [ %g1 + 0x2e4 ], %g1 ! 40017ee4 <_TOD_Is_set>
40004c68: 80 a0 60 00 cmp %g1, 0
40004c6c: 02 80 00 10 be 40004cac <rtems_clock_get_tod_timeval+0x5c>
40004c70: b0 10 20 0b mov 0xb, %i0
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
40004c74: 7f ff f4 1a call 40001cdc <sparc_disable_interrupts>
40004c78: 01 00 00 00 nop
40004c7c: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
40004c80: 40 00 05 7f call 4000627c <_TOD_Get>
40004c84: 90 07 bf f0 add %fp, -16, %o0
_ISR_Enable(level);
40004c88: 7f ff f4 19 call 40001cec <sparc_enable_interrupts>
40004c8c: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
40004c90: d0 07 bf f4 ld [ %fp + -12 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
40004c94: c2 07 bf f0 ld [ %fp + -16 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
40004c98: 92 10 23 e8 mov 0x3e8, %o1
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
40004c9c: c2 24 40 00 st %g1, [ %l1 ]
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
40004ca0: 40 00 38 fb call 4001308c <.udiv>
40004ca4: b0 10 20 00 clr %i0
40004ca8: d0 24 60 04 st %o0, [ %l1 + 4 ]
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
40004cac: 81 c7 e0 08 ret
40004cb0: 81 e8 00 00 restore
40004ee4 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
40004ee4: 9d e3 bf 98 save %sp, -104, %sp
if ( !uptime )
40004ee8: 90 96 20 00 orcc %i0, 0, %o0
40004eec: 02 80 00 04 be 40004efc <rtems_clock_get_uptime+0x18> <== NEVER TAKEN
40004ef0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
40004ef4: 40 00 06 00 call 400066f4 <_TOD_Get_uptime>
40004ef8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
40004efc: 81 c7 e0 08 ret
40004f00: 81 e8 00 00 restore
40005fa8 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
40005fa8: 9d e3 bf 90 save %sp, -112, %sp
struct timespec newtime;
if ( !time_buffer )
40005fac: a0 96 20 00 orcc %i0, 0, %l0
40005fb0: 02 80 00 1e be 40006028 <rtems_clock_set+0x80> <== NEVER TAKEN
40005fb4: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
40005fb8: 90 10 00 10 mov %l0, %o0
40005fbc: 40 00 00 65 call 40006150 <_TOD_Validate>
40005fc0: b0 10 20 14 mov 0x14, %i0
40005fc4: 80 8a 20 ff btst 0xff, %o0
40005fc8: 02 80 00 18 be 40006028 <rtems_clock_set+0x80>
40005fcc: 01 00 00 00 nop
newtime.tv_sec = _TOD_To_seconds( time_buffer );
40005fd0: 40 00 00 2d call 40006084 <_TOD_To_seconds>
40005fd4: 90 10 00 10 mov %l0, %o0
newtime.tv_nsec = time_buffer->ticks *
40005fd8: 03 10 00 91 sethi %hi(0x40024400), %g1
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
40005fdc: d0 27 bf f0 st %o0, [ %fp + -16 ]
newtime.tv_nsec = time_buffer->ticks *
40005fe0: d2 00 61 50 ld [ %g1 + 0x150 ], %o1
40005fe4: 40 00 41 f2 call 400167ac <.umul>
40005fe8: d0 04 20 18 ld [ %l0 + 0x18 ], %o0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40005fec: 05 10 00 90 sethi %hi(0x40024000), %g2
40005ff0: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 400243b0 <_Thread_Dispatch_disable_level>
40005ff4: 87 2a 20 02 sll %o0, 2, %g3
40005ff8: 82 00 60 01 inc %g1
40005ffc: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ]
40006000: 83 2a 20 07 sll %o0, 7, %g1
40006004: 82 20 40 03 sub %g1, %g3, %g1
40006008: 82 00 40 08 add %g1, %o0, %g1
4000600c: 83 28 60 03 sll %g1, 3, %g1
40006010: c2 27 bf f4 st %g1, [ %fp + -12 ]
(_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
40006014: 90 07 bf f0 add %fp, -16, %o0
40006018: 40 00 06 bd call 40007b0c <_TOD_Set>
4000601c: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
40006020: 40 00 0b 9d call 40008e94 <_Thread_Enable_dispatch>
40006024: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
40006028: 81 c7 e0 08 ret
4000602c: 81 e8 00 00 restore
40004cb4 <rtems_clock_set_nanoseconds_extension>:
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
40004cb4: 84 92 20 00 orcc %o0, 0, %g2
40004cb8: 02 80 00 05 be 40004ccc <rtems_clock_set_nanoseconds_extension+0x18><== NEVER TAKEN
40004cbc: 90 10 20 09 mov 9, %o0
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
40004cc0: 03 10 00 60 sethi %hi(0x40018000), %g1
40004cc4: 90 10 20 00 clr %o0
40004cc8: c4 20 60 78 st %g2, [ %g1 + 0x78 ]
return RTEMS_SUCCESSFUL;
}
40004ccc: 81 c3 e0 08 retl
40002ac8 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40002ac8: 9d e3 bf 60 save %sp, -160, %sp
struct timespec uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
40002acc: 80 a6 60 00 cmp %i1, 0
40002ad0: 02 80 00 66 be 40002c68 <rtems_cpu_usage_report_with_plugin+0x1a0><== NEVER TAKEN
40002ad4: a0 07 bf e8 add %fp, -24, %l0
* 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.
*/
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
_TOD_Get_uptime( &uptime );
40002ad8: 40 00 13 e5 call 40007a6c <_TOD_Get_uptime>
40002adc: 90 10 00 10 mov %l0, %o0
_Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
40002ae0: 92 10 00 10 mov %l0, %o1
40002ae4: 11 10 00 91 sethi %hi(0x40024400), %o0
40002ae8: a0 07 bf e0 add %fp, -32, %l0
40002aec: 90 12 22 6c or %o0, 0x26c, %o0
40002af0: 40 00 1d d3 call 4000a23c <_Timespec_Subtract>
40002af4: 94 10 00 10 mov %l0, %o2
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
40002af8: 90 10 00 18 mov %i0, %o0
40002afc: 13 10 00 67 sethi %hi(0x40019c00), %o1
40002b00: 9f c6 40 00 call %i1
40002b04: 92 12 60 88 or %o1, 0x88, %o1 ! 40019c88 <__func__.4755+0x240>
40002b08: 03 10 00 90 sethi %hi(0x40024000), %g1
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40002b0c: ac 07 bf c0 add %fp, -64, %l6
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
40002b10: a4 10 63 14 or %g1, 0x314, %l2
_Timespec_Subtract(
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
40002b14: aa 07 bf d8 add %fp, -40, %l5
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
struct timespec used;
_Timespec_Subtract(
40002b18: 03 10 00 91 sethi %hi(0x40024400), %g1
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
40002b1c: b6 07 bf f4 add %fp, -12, %i3
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
struct timespec used;
_Timespec_Subtract(
40002b20: b4 10 60 78 or %g1, 0x78, %i2
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
40002b24: b8 07 bf f0 add %fp, -16, %i4
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
40002b28: ba 04 a0 10 add %l2, 0x10, %i5
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
40002b2c: c2 04 80 00 ld [ %l2 ], %g1
40002b30: 80 a0 60 00 cmp %g1, 0
40002b34: 22 80 00 41 be,a 40002c38 <rtems_cpu_usage_report_with_plugin+0x170>
40002b38: a4 04 a0 04 add %l2, 4, %l2
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
40002b3c: e6 00 60 04 ld [ %g1 + 4 ], %l3
if ( information ) {
40002b40: 80 a4 e0 00 cmp %l3, 0
40002b44: 22 80 00 3d be,a 40002c38 <rtems_cpu_usage_report_with_plugin+0x170><== NEVER TAKEN
40002b48: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED
40002b4c: a2 10 20 01 mov 1, %l1
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
struct timespec used;
_Timespec_Subtract(
40002b50: ae 07 bf e8 add %fp, -24, %l7
40002b54: 10 80 00 32 b 40002c1c <rtems_cpu_usage_report_with_plugin+0x154>
40002b58: a8 07 bf d0 add %fp, -48, %l4
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
40002b5c: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1
40002b60: e0 00 40 02 ld [ %g1 + %g2 ], %l0
if ( !the_thread )
40002b64: 80 a4 20 00 cmp %l0, 0
40002b68: 02 80 00 2d be 40002c1c <rtems_cpu_usage_report_with_plugin+0x154><== NEVER TAKEN
40002b6c: a2 04 60 01 inc %l1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40002b70: 40 00 0e b6 call 40006648 <rtems_object_get_name>
40002b74: d0 04 20 08 ld [ %l0 + 8 ], %o0
(*print)(
40002b78: d4 04 20 08 ld [ %l0 + 8 ], %o2
40002b7c: 90 10 00 18 mov %i0, %o0
40002b80: 13 10 00 67 sethi %hi(0x40019c00), %o1
40002b84: 96 10 00 16 mov %l6, %o3
40002b88: 9f c6 40 00 call %i1
40002b8c: 92 12 60 d0 or %o1, 0xd0, %o1
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
40002b90: c2 04 20 84 ld [ %l0 + 0x84 ], %g1
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
40002b94: 07 10 00 91 sethi %hi(0x40024400), %g3
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
40002b98: c2 27 bf d8 st %g1, [ %fp + -40 ]
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
40002b9c: 86 10 e0 70 or %g3, 0x70, %g3
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
40002ba0: c2 04 20 88 ld [ %l0 + 0x88 ], %g1
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
40002ba4: c4 00 c0 00 ld [ %g3 ], %g2
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
40002ba8: c2 27 bf dc st %g1, [ %fp + -36 ]
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
40002bac: c4 00 a0 08 ld [ %g2 + 8 ], %g2
40002bb0: c2 04 20 08 ld [ %l0 + 8 ], %g1
40002bb4: 80 a0 80 01 cmp %g2, %g1
40002bb8: 12 80 00 0a bne 40002be0 <rtems_cpu_usage_report_with_plugin+0x118>
40002bbc: 94 10 00 1b mov %i3, %o2
struct timespec used;
_Timespec_Subtract(
40002bc0: 90 10 00 1a mov %i2, %o0
40002bc4: 92 10 00 17 mov %l7, %o1
40002bc8: 40 00 1d 9d call 4000a23c <_Timespec_Subtract>
40002bcc: 94 10 00 14 mov %l4, %o2
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
40002bd0: 90 10 00 15 mov %l5, %o0
40002bd4: 40 00 1c ef call 40009f90 <_Timespec_Add_to>
40002bd8: 92 10 00 14 mov %l4, %o1
};
_Timespec_Divide( &ran, &total, &ival, &fval );
40002bdc: 94 10 00 1b mov %i3, %o2
40002be0: 96 10 00 1c mov %i4, %o3
40002be4: 90 10 00 15 mov %l5, %o0
40002be8: 40 00 1d 02 call 40009ff0 <_Timespec_Divide>
40002bec: 92 07 bf e0 add %fp, -32, %o1
/*
* Print the information
*/
(*print)( context,
40002bf0: d0 07 bf dc ld [ %fp + -36 ], %o0
40002bf4: 40 00 4f 28 call 40016894 <.udiv>
40002bf8: 92 10 23 e8 mov 0x3e8, %o1
40002bfc: d4 07 bf d8 ld [ %fp + -40 ], %o2
40002c00: d8 07 bf f4 ld [ %fp + -12 ], %o4
40002c04: da 07 bf f0 ld [ %fp + -16 ], %o5
40002c08: 96 10 00 08 mov %o0, %o3
40002c0c: 13 10 00 67 sethi %hi(0x40019c00), %o1
40002c10: 90 10 00 18 mov %i0, %o0
40002c14: 9f c6 40 00 call %i1
40002c18: 92 12 60 e8 or %o1, 0xe8, %o1
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
40002c1c: c2 14 e0 10 lduh [ %l3 + 0x10 ], %g1
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
40002c20: 94 10 00 16 mov %l6, %o2
40002c24: 92 10 20 0d mov 0xd, %o1
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
40002c28: 80 a4 40 01 cmp %l1, %g1
40002c2c: 08 bf ff cc bleu 40002b5c <rtems_cpu_usage_report_with_plugin+0x94>
40002c30: 85 2c 60 02 sll %l1, 2, %g2
40002c34: a4 04 a0 04 add %l2, 4, %l2
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
40002c38: 80 a4 80 1d cmp %l2, %i5
40002c3c: 32 bf ff bd bne,a 40002b30 <rtems_cpu_usage_report_with_plugin+0x68>
40002c40: c2 04 80 00 ld [ %l2 ], %g1
}
}
}
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
(*print)( context, "Time since last CPU Usage reset %" PRId32
40002c44: d0 07 bf e4 ld [ %fp + -28 ], %o0
40002c48: 40 00 4f 13 call 40016894 <.udiv>
40002c4c: 92 10 23 e8 mov 0x3e8, %o1
40002c50: d4 07 bf e0 ld [ %fp + -32 ], %o2
40002c54: 96 10 00 08 mov %o0, %o3
40002c58: 13 10 00 67 sethi %hi(0x40019c00), %o1
40002c5c: 90 10 00 18 mov %i0, %o0
40002c60: 9f c6 40 00 call %i1
40002c64: 92 12 61 00 or %o1, 0x100, %o1
40002c68: 81 c7 e0 08 ret
40002c6c: 81 e8 00 00 restore
4000b75c <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
static int
rtems_deviceio_errno(rtems_status_code code)
{
4000b75c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
4000b760: 11 10 00 5a sethi %hi(0x40016800), %o0 <== NOT EXECUTED
4000b764: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000b768: 40 00 01 17 call 4000bbc4 <rtems_assoc_remote_by_local> <== NOT EXECUTED
4000b76c: 90 12 21 2c or %o0, 0x12c, %o0 <== NOT EXECUTED
4000b770: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000b774: 02 80 00 05 be 4000b788 <rtems_deviceio_errno+0x2c> <== NOT EXECUTED
4000b778: 01 00 00 00 nop <== NOT EXECUTED
{
errno = rc;
4000b77c: 40 00 02 74 call 4000c14c <__errno> <== NOT EXECUTED
4000b780: 01 00 00 00 nop <== NOT EXECUTED
4000b784: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
return -1;
}
return -1;
}
4000b788: 81 c7 e0 08 ret <== NOT EXECUTED
4000b78c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
4000307c <rtems_error>:
int rtems_error(
int error_flag,
const char *printf_format,
...
)
{
4000307c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
40003080: 94 07 a0 4c add %fp, 0x4c, %o2 <== NOT EXECUTED
40003084: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
40003088: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
4000308c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40003090: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
40003094: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40003098: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000309c: 7f ff ff 7c call 40002e8c <rtems_verror> <== NOT EXECUTED
400030a0: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
400030a4: 81 c7 e0 08 ret <== NOT EXECUTED
400030a8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
40004d28 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
40004d28: 9d e3 bf 98 save %sp, -104, %sp
40004d2c: 90 10 00 18 mov %i0, %o0
40004d30: 96 10 00 1b mov %i3, %o3
40004d34: 92 10 00 19 mov %i1, %o1
40004d38: 94 10 00 1a mov %i2, %o2
RTEMS_API_Control *api;
if ( !event_out )
40004d3c: 80 a6 e0 00 cmp %i3, 0
40004d40: 02 80 00 15 be 40004d94 <rtems_event_receive+0x6c> <== NEVER TAKEN
40004d44: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
40004d48: 37 10 00 5f sethi %hi(0x40017c00), %i3
40004d4c: c2 06 e3 90 ld [ %i3 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
if ( _Event_sets_Is_empty( event_in ) ) {
40004d50: 80 a2 20 00 cmp %o0, 0
40004d54: 12 80 00 06 bne 40004d6c <rtems_event_receive+0x44>
40004d58: c2 00 61 5c ld [ %g1 + 0x15c ], %g1
*event_out = api->pending_events;
40004d5c: c2 00 40 00 ld [ %g1 ], %g1
40004d60: c2 22 c0 00 st %g1, [ %o3 ]
40004d64: 81 c7 e0 08 ret
40004d68: 91 e8 20 00 restore %g0, 0, %o0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40004d6c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004d70: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 40017ed0 <_Thread_Dispatch_disable_level>
40004d74: 84 00 a0 01 inc %g2
40004d78: c4 20 62 d0 st %g2, [ %g1 + 0x2d0 ]
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
40004d7c: 40 00 00 08 call 40004d9c <_Event_Seize>
40004d80: 01 00 00 00 nop
_Thread_Enable_dispatch();
40004d84: 40 00 09 ee call 4000753c <_Thread_Enable_dispatch>
40004d88: 01 00 00 00 nop
return( _Thread_Executing->Wait.return_code );
40004d8c: c2 06 e3 90 ld [ %i3 + 0x390 ], %g1
40004d90: f0 00 60 34 ld [ %g1 + 0x34 ], %i0
}
40004d94: 81 c7 e0 08 ret
40004d98: 81 e8 00 00 restore
40001e98 <rtems_filesystem_evaluate_parent>:
int rtems_filesystem_evaluate_parent(
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
40001e98: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
40001e9c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40001ea0: 32 80 00 06 bne,a 40001eb8 <rtems_filesystem_evaluate_parent+0x20><== NOT EXECUTED
40001ea4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
40001ea8: 40 00 28 a9 call 4000c14c <__errno> <== NOT EXECUTED
40001eac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40001eb0: 10 80 00 09 b 40001ed4 <rtems_filesystem_evaluate_parent+0x3c><== NOT EXECUTED
40001eb4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
40001eb8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40001ebc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001ec0: 12 80 00 08 bne 40001ee0 <rtems_filesystem_evaluate_parent+0x48><== NOT EXECUTED
40001ec4: a0 07 bf e8 add %fp, -24, %l0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
40001ec8: 40 00 28 a1 call 4000c14c <__errno> <== NOT EXECUTED
40001ecc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40001ed0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
40001ed4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40001ed8: 81 c7 e0 08 ret <== NOT EXECUTED
40001edc: 81 e8 00 00 restore <== NOT EXECUTED
parent = *pathloc;
40001ee0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40001ee4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
40001ee8: 40 00 2a 8b call 4000c914 <memcpy> <== NOT EXECUTED
40001eec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
40001ef0: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
40001ef4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
40001ef8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
40001efc: 11 10 00 59 sethi %hi(0x40016400), %o0 <== NOT EXECUTED
40001f00: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
40001f04: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001f08: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
if (result != 0){
40001f0c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40001f10: 02 80 00 04 be 40001f20 <rtems_filesystem_evaluate_parent+0x88><== NOT EXECUTED
40001f14: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
40001f18: 81 c7 e0 08 ret <== NOT EXECUTED
40001f1c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
40001f20: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001f24: 02 80 00 08 be 40001f44 <rtems_filesystem_evaluate_parent+0xac><== NOT EXECUTED
40001f28: 01 00 00 00 nop <== NOT EXECUTED
40001f2c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
40001f30: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001f34: 02 80 00 04 be 40001f44 <rtems_filesystem_evaluate_parent+0xac><== NOT EXECUTED
40001f38: 01 00 00 00 nop <== NOT EXECUTED
40001f3c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001f40: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return result;
}
40001f44: 81 c7 e0 08 ret <== NOT EXECUTED
40001f48: 81 e8 00 00 restore <== NOT EXECUTED
40001f4c <rtems_filesystem_evaluate_path>:
const char *pathname,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
40001f4c: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify Input parameters.
*/
if ( !pathname )
40001f50: 80 a6 20 00 cmp %i0, 0
40001f54: 12 80 00 06 bne 40001f6c <rtems_filesystem_evaluate_path+0x20><== ALWAYS TAKEN
40001f58: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EFAULT );
40001f5c: 40 00 28 7c call 4000c14c <__errno> <== NOT EXECUTED
40001f60: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40001f64: 10 80 00 44 b 40002074 <rtems_filesystem_evaluate_path+0x128><== NOT EXECUTED
40001f68: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
if ( !pathloc )
40001f6c: 32 80 00 06 bne,a 40001f84 <rtems_filesystem_evaluate_path+0x38><== ALWAYS TAKEN
40001f70: c2 4e 00 00 ldsb [ %i0 ], %g1
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
40001f74: 40 00 28 76 call 4000c14c <__errno> <== NOT EXECUTED
40001f78: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40001f7c: 10 80 00 3e b 40002074 <rtems_filesystem_evaluate_path+0x128><== NOT EXECUTED
40001f80: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
40001f84: 80 a0 60 2f cmp %g1, 0x2f
40001f88: 02 80 00 06 be 40001fa0 <rtems_filesystem_evaluate_path+0x54><== ALWAYS TAKEN
40001f8c: 80 a0 60 5c cmp %g1, 0x5c
40001f90: 02 80 00 04 be 40001fa0 <rtems_filesystem_evaluate_path+0x54><== NOT EXECUTED
40001f94: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001f98: 12 80 00 0a bne 40001fc0 <rtems_filesystem_evaluate_path+0x74><== NOT EXECUTED
40001f9c: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40001fa0: 03 10 00 5d sethi %hi(0x40017400), %g1
40001fa4: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 ! 4001767c <rtems_current_user_env>
40001fa8: 90 10 00 1a mov %i2, %o0
40001fac: 92 02 60 14 add %o1, 0x14, %o1
40001fb0: 40 00 2a 59 call 4000c914 <memcpy>
40001fb4: 94 10 20 10 mov 0x10, %o2
40001fb8: 10 80 00 08 b 40001fd8 <rtems_filesystem_evaluate_path+0x8c>
40001fbc: 84 10 20 01 mov 1, %g2
40001fc0: d2 00 62 7c ld [ %g1 + 0x27c ], %o1 <== NOT EXECUTED
40001fc4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40001fc8: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
40001fcc: 40 00 2a 52 call 4000c914 <memcpy> <== NOT EXECUTED
40001fd0: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
40001fd4: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
40001fd8: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40001fdc: c2 00 40 00 ld [ %g1 ], %g1
40001fe0: 80 a0 60 00 cmp %g1, 0
40001fe4: 02 80 00 21 be 40002068 <rtems_filesystem_evaluate_path+0x11c><== NEVER TAKEN
40001fe8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
40001fec: 90 06 00 02 add %i0, %g2, %o0
40001ff0: 92 10 00 19 mov %i1, %o1
40001ff4: 9f c0 40 00 call %g1
40001ff8: 94 10 00 1a mov %i2, %o2
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
40001ffc: b0 92 20 00 orcc %o0, 0, %i0
40002000: 12 80 00 1e bne 40002078 <rtems_filesystem_evaluate_path+0x12c><== NEVER TAKEN
40002004: 80 a6 e0 00 cmp %i3, 0
40002008: 02 80 00 21 be 4000208c <rtems_filesystem_evaluate_path+0x140>
4000200c: 01 00 00 00 nop
if ( !pathloc->ops->node_type_h ){
40002010: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40002014: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40002018: 80 a0 a0 00 cmp %g2, 0
4000201c: 22 80 00 0e be,a 40002054 <rtems_filesystem_evaluate_path+0x108><== NEVER TAKEN
40002020: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
rtems_filesystem_freenode( pathloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
40002024: 9f c0 80 00 call %g2
40002028: 90 10 00 1a mov %i2, %o0
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
4000202c: 90 02 3f fd add %o0, -3, %o0
40002030: 80 a2 20 01 cmp %o0, 1
40002034: 18 80 00 16 bgu 4000208c <rtems_filesystem_evaluate_path+0x140><== ALWAYS TAKEN
40002038: 01 00 00 00 nop
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
4000203c: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED
40002040: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED
40002044: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40002048: 12 80 00 0e bne 40002080 <rtems_filesystem_evaluate_path+0x134><== NOT EXECUTED
4000204c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_filesystem_freenode( pathloc );
40002050: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
40002054: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002058: 02 80 00 04 be 40002068 <rtems_filesystem_evaluate_path+0x11c><== NOT EXECUTED
4000205c: 01 00 00 00 nop <== NOT EXECUTED
40002060: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002064: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
40002068: 40 00 28 39 call 4000c14c <__errno> <== NOT EXECUTED
4000206c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40002070: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
40002074: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40002078: 81 c7 e0 08 ret <== NOT EXECUTED
4000207c: 81 e8 00 00 restore <== NOT EXECUTED
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
40002080: 9f c0 80 00 call %g2 <== NOT EXECUTED
40002084: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40002088: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return result;
}
4000208c: 81 c7 e0 08 ret
40002090: 81 e8 00 00 restore
40009c78 <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 )
{
40009c78: 9d e3 bf 80 save %sp, -128, %sp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
40009c7c: 25 10 00 5d sethi %hi(0x40017400), %l2
40009c80: c4 04 a2 7c ld [ %l2 + 0x27c ], %g2 ! 4001767c <rtems_current_user_env>
40009c84: 82 10 20 12 mov 0x12, %g1
init_fs_mount_table();
40009c88: 40 00 02 31 call 4000a54c <init_fs_mount_table>
40009c8c: c2 30 a0 24 sth %g1, [ %g2 + 0x24 ]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
40009c90: 03 10 00 57 sethi %hi(0x40015c00), %g1
40009c94: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 40015f9c <rtems_filesystem_mount_table_size>
rtems_fatal_error_occurred( 0xABCD0001 );
40009c98: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
40009c9c: 80 a0 60 00 cmp %g1, 0
40009ca0: 02 80 00 0f be 40009cdc <rtems_filesystem_initialize+0x64><== NEVER TAKEN
40009ca4: 90 12 20 01 or %o0, 1, %o0
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
40009ca8: 03 10 00 5c sethi %hi(0x40017000), %g1
40009cac: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 40017160 <rtems_filesystem_mount_table>
status = mount(
40009cb0: 90 07 bf f4 add %fp, -12, %o0
40009cb4: d8 00 60 0c ld [ %g1 + 0xc ], %o4
40009cb8: d2 00 40 00 ld [ %g1 ], %o1
40009cbc: d4 00 60 04 ld [ %g1 + 4 ], %o2
40009cc0: 40 00 02 2b call 4000a56c <mount>
40009cc4: d6 00 60 08 ld [ %g1 + 8 ], %o3
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
40009cc8: 80 a2 3f ff cmp %o0, -1
40009ccc: 32 80 00 06 bne,a 40009ce4 <rtems_filesystem_initialize+0x6c><== ALWAYS TAKEN
40009cd0: d0 04 a2 7c ld [ %l2 + 0x27c ], %o0
rtems_fatal_error_occurred( 0xABCD0002 );
40009cd4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
40009cd8: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <LEON_REG+0x2bcd0002><== NOT EXECUTED
40009cdc: 7f ff ef 83 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40009ce0: 01 00 00 00 nop <== NOT EXECUTED
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
40009ce4: d2 07 bf f4 ld [ %fp + -12 ], %o1
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
40009ce8: c0 32 20 26 clrh [ %o0 + 0x26 ]
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
40009cec: 92 02 60 18 add %o1, 0x18, %o1
40009cf0: 94 10 20 10 mov 0x10, %o2
40009cf4: 40 00 0b 08 call 4000c914 <memcpy>
40009cf8: 90 02 20 14 add %o0, 0x14, %o0
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
40009cfc: a0 07 bf e4 add %fp, -28, %l0
40009d00: 96 10 20 00 clr %o3
40009d04: 23 10 00 59 sethi %hi(0x40016400), %l1
40009d08: 92 10 20 00 clr %o1
40009d0c: 94 10 00 10 mov %l0, %o2
40009d10: 7f ff e0 8f call 40001f4c <rtems_filesystem_evaluate_path>
40009d14: 90 14 63 b8 or %l1, 0x3b8, %o0
rtems_filesystem_root = loc;
40009d18: d0 04 a2 7c ld [ %l2 + 0x27c ], %o0
40009d1c: 92 10 00 10 mov %l0, %o1
40009d20: 94 10 20 10 mov 0x10, %o2
40009d24: 40 00 0a fc call 4000c914 <memcpy>
40009d28: 90 02 20 14 add %o0, 0x14, %o0
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
40009d2c: 96 10 20 00 clr %o3
40009d30: 92 10 20 00 clr %o1
40009d34: 94 10 00 10 mov %l0, %o2
40009d38: 7f ff e0 85 call 40001f4c <rtems_filesystem_evaluate_path>
40009d3c: 90 14 63 b8 or %l1, 0x3b8, %o0
rtems_filesystem_current = loc;
40009d40: d0 04 a2 7c ld [ %l2 + 0x27c ], %o0
40009d44: 92 10 00 10 mov %l0, %o1
40009d48: 94 10 20 10 mov 0x10, %o2
40009d4c: 40 00 0a f2 call 4000c914 <memcpy>
40009d50: 90 02 20 04 add %o0, 4, %o0
*
* 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);
40009d54: 92 10 21 ff mov 0x1ff, %o1
40009d58: 11 10 00 59 sethi %hi(0x40016400), %o0
40009d5c: 40 00 01 f2 call 4000a524 <mkdir>
40009d60: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 400167c0 <IMFS_link_handlers+0x44>
if ( status != 0 )
40009d64: 80 a2 20 00 cmp %o0, 0
40009d68: 02 80 00 04 be 40009d78 <rtems_filesystem_initialize+0x100><== ALWAYS TAKEN
40009d6c: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
40009d70: 10 bf ff db b 40009cdc <rtems_filesystem_initialize+0x64> <== NOT EXECUTED
40009d74: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <LEON_REG+0x2bcd0003><== NOT EXECUTED
40009d78: 81 c7 e0 08 ret
40009d7c: 81 e8 00 00 restore
40001cfc <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
40001cfc: 9d e3 bf 88 save %sp, -120, %sp <== 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( name, 0x00, &loc, true );
40001d00: 92 10 20 00 clr %o1 <== NOT EXECUTED
40001d04: a4 07 bf e8 add %fp, -24, %l2 <== NOT EXECUTED
40001d08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40001d0c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40001d10: 40 00 00 8f call 40001f4c <rtems_filesystem_evaluate_path><== NOT EXECUTED
40001d14: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
40001d18: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== 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( name, 0x00, &loc, true );
40001d1c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
40001d20: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
40001d24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001d28: 12 80 00 0e bne 40001d60 <rtems_io_lookup_name+0x64> <== NOT EXECUTED
40001d2c: e2 07 bf e8 ld [ %fp + -24 ], %l1 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
40001d30: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
40001d34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001d38: 02 80 00 04 be 40001d48 <rtems_io_lookup_name+0x4c> <== NOT EXECUTED
40001d3c: 01 00 00 00 nop <== NOT EXECUTED
40001d40: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001d44: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
40001d48: 40 00 29 01 call 4000c14c <__errno> <== NOT EXECUTED
40001d4c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40001d50: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
40001d54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40001d58: 81 c7 e0 08 ret <== NOT EXECUTED
40001d5c: 81 e8 00 00 restore <== NOT EXECUTED
}
node_type = (*loc.ops->node_type_h)( &loc );
40001d60: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001d64: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
40001d68: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
40001d6c: 12 80 00 05 bne 40001d80 <rtems_io_lookup_name+0x84> <== NOT EXECUTED
40001d70: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
40001d74: 80 a2 20 02 cmp %o0, 2 <== NOT EXECUTED
40001d78: 22 80 00 0d be,a 40001dac <rtems_io_lookup_name+0xb0> <== NOT EXECUTED
40001d7c: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
40001d80: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001d84: 02 80 00 1c be 40001df4 <rtems_io_lookup_name+0xf8> <== NOT EXECUTED
40001d88: 01 00 00 00 nop <== NOT EXECUTED
40001d8c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
40001d90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001d94: 02 80 00 18 be 40001df4 <rtems_io_lookup_name+0xf8> <== NOT EXECUTED
40001d98: 01 00 00 00 nop <== NOT EXECUTED
40001d9c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001da0: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
40001da4: 81 c7 e0 08 ret <== NOT EXECUTED
40001da8: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
40001dac: 40 00 2e 0a call 4000d5d4 <strlen> <== NOT EXECUTED
40001db0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40001db4: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
40001db8: c2 04 60 4c ld [ %l1 + 0x4c ], %g1 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
40001dbc: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== 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;
40001dc0: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
40001dc4: c2 04 60 50 ld [ %l1 + 0x50 ], %g1 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
40001dc8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40001dcc: 02 80 00 0c be 40001dfc <rtems_io_lookup_name+0x100> <== NOT EXECUTED
40001dd0: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
40001dd4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
40001dd8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40001ddc: 02 80 00 08 be 40001dfc <rtems_io_lookup_name+0x100> <== NOT EXECUTED
40001de0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40001de4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40001de8: b0 10 20 00 clr %i0 <== NOT EXECUTED
40001dec: 81 c7 e0 08 ret <== NOT EXECUTED
40001df0: 81 e8 00 00 restore <== NOT EXECUTED
40001df4: 81 c7 e0 08 ret <== NOT EXECUTED
40001df8: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED
40001dfc: b0 10 20 00 clr %i0 <== NOT EXECUTED
#endif
return RTEMS_SUCCESSFUL;
}
40001e00: 81 c7 e0 08 ret <== NOT EXECUTED
40001e04: 81 e8 00 00 restore <== NOT EXECUTED
40006b48 <rtems_io_register_driver>:
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
)
{
40006b48: 9d e3 bf 98 save %sp, -104, %sp
40006b4c: 92 10 00 19 mov %i1, %o1
/*
* Validate the pointer data and contents passed in
*/
if ( !driver_table )
40006b50: 80 a6 60 00 cmp %i1, 0
40006b54: 02 80 00 3f be 40006c50 <rtems_io_register_driver+0x108>
40006b58: a0 10 00 18 mov %i0, %l0
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
40006b5c: 80 a6 a0 00 cmp %i2, 0
40006b60: 02 80 00 3c be 40006c50 <rtems_io_register_driver+0x108>
40006b64: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
40006b68: c2 06 40 00 ld [ %i1 ], %g1
40006b6c: 80 a0 60 00 cmp %g1, 0
40006b70: 32 80 00 07 bne,a 40006b8c <rtems_io_register_driver+0x44>
40006b74: c0 26 80 00 clr [ %i2 ]
40006b78: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006b7c: 80 a0 60 00 cmp %g1, 0
40006b80: 02 80 00 34 be 40006c50 <rtems_io_register_driver+0x108> <== ALWAYS TAKEN
40006b84: 01 00 00 00 nop
return RTEMS_INVALID_ADDRESS;
*registered_major = 0;
40006b88: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
40006b8c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40006b90: c8 00 61 80 ld [ %g1 + 0x180 ], %g4 ! 4001bd80 <_IO_Number_of_drivers>
40006b94: 80 a4 00 04 cmp %l0, %g4
40006b98: 1a 80 00 31 bcc 40006c5c <rtems_io_register_driver+0x114>
40006b9c: b0 10 20 0a mov 0xa, %i0
/*
* Test for initialise/open being present to indicate the driver slot is
* in use.
*/
if ( major == 0 ) {
40006ba0: 80 a4 20 00 cmp %l0, 0
40006ba4: 12 80 00 18 bne 40006c04 <rtems_io_register_driver+0xbc>
40006ba8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
40006bac: c6 00 61 84 ld [ %g1 + 0x184 ], %g3 ! 4001bd84 <_IO_Driver_address_table>
40006bb0: 85 29 20 03 sll %g4, 3, %g2
40006bb4: 83 29 20 05 sll %g4, 5, %g1
40006bb8: a0 01 3f ff add %g4, -1, %l0
40006bbc: 82 20 40 02 sub %g1, %g2, %g1
40006bc0: 82 00 7f e8 add %g1, -24, %g1
40006bc4: 10 80 00 0b b 40006bf0 <rtems_io_register_driver+0xa8>
40006bc8: 86 00 c0 01 add %g3, %g1, %g3
if ( !_IO_Driver_address_table[major].initialization_entry &&
40006bcc: 80 a0 60 00 cmp %g1, 0
40006bd0: 32 80 00 07 bne,a 40006bec <rtems_io_register_driver+0xa4>
40006bd4: a0 04 3f ff add %l0, -1, %l0
40006bd8: c2 00 e0 04 ld [ %g3 + 4 ], %g1
40006bdc: 80 a0 60 00 cmp %g1, 0
40006be0: 02 80 00 09 be 40006c04 <rtems_io_register_driver+0xbc> <== ALWAYS TAKEN
40006be4: 03 10 00 6f sethi %hi(0x4001bc00), %g1
* in use.
*/
if ( major == 0 ) {
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
40006be8: a0 04 3f ff add %l0, -1, %l0 <== NOT EXECUTED
40006bec: 86 00 ff e8 add %g3, -24, %g3
40006bf0: 80 a4 20 00 cmp %l0, 0
40006bf4: 32 bf ff f6 bne,a 40006bcc <rtems_io_register_driver+0x84>
40006bf8: c2 00 c0 00 ld [ %g3 ], %g1
40006bfc: 81 c7 e0 08 ret
40006c00: 91 e8 20 05 restore %g0, 5, %o0
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
40006c04: c6 00 61 84 ld [ %g1 + 0x184 ], %g3
40006c08: 85 2c 20 03 sll %l0, 3, %g2
40006c0c: 83 2c 20 05 sll %l0, 5, %g1
40006c10: 82 20 40 02 sub %g1, %g2, %g1
40006c14: c4 00 c0 01 ld [ %g3 + %g1 ], %g2
40006c18: 80 a0 a0 00 cmp %g2, 0
40006c1c: 12 80 00 0f bne 40006c58 <rtems_io_register_driver+0x110>
40006c20: 90 00 c0 01 add %g3, %g1, %o0
40006c24: c2 02 20 04 ld [ %o0 + 4 ], %g1
40006c28: 80 a0 60 00 cmp %g1, 0
40006c2c: 32 80 00 0c bne,a 40006c5c <rtems_io_register_driver+0x114><== NEVER TAKEN
40006c30: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
40006c34: 40 00 1b 21 call 4000d8b8 <memcpy>
40006c38: 94 10 20 18 mov 0x18, %o2
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
40006c3c: b0 10 00 10 mov %l0, %i0
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
40006c40: e0 26 80 00 st %l0, [ %i2 ]
return rtems_io_initialize( major, 0, NULL );
40006c44: b2 10 20 00 clr %i1
40006c48: 7f ff ff 4f call 40006984 <rtems_io_initialize>
40006c4c: 95 e8 20 00 restore %g0, 0, %o2
40006c50: 81 c7 e0 08 ret
40006c54: 91 e8 20 09 restore %g0, 9, %o0
40006c58: b0 10 20 0c mov 0xc, %i0
}
40006c5c: 81 c7 e0 08 ret
40006c60: 81 e8 00 00 restore
40006c64 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
40006c64: 9d e3 bf 98 save %sp, -104, %sp
if ( major < _IO_Number_of_drivers ) {
40006c68: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40006c6c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 4001bd80 <_IO_Number_of_drivers>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
40006c70: 86 10 00 18 mov %i0, %g3
if ( major < _IO_Number_of_drivers ) {
40006c74: 80 a6 00 01 cmp %i0, %g1
40006c78: 1a 80 00 0c bcc 40006ca8 <rtems_io_unregister_driver+0x44><== NEVER TAKEN
40006c7c: b0 10 20 0d mov 0xd, %i0
memset(
40006c80: 03 10 00 6f sethi %hi(0x4001bc00), %g1
40006c84: c4 00 61 84 ld [ %g1 + 0x184 ], %g2 ! 4001bd84 <_IO_Driver_address_table>
40006c88: 83 28 e0 03 sll %g3, 3, %g1
40006c8c: 91 28 e0 05 sll %g3, 5, %o0
40006c90: 92 10 20 00 clr %o1
40006c94: 90 22 00 01 sub %o0, %g1, %o0
40006c98: 94 10 20 18 mov 0x18, %o2
40006c9c: 90 00 80 08 add %g2, %o0, %o0
40006ca0: 40 00 1b 3f call 4000d99c <memset>
40006ca4: b0 10 20 00 clr %i0
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
40006ca8: 81 c7 e0 08 ret
40006cac: 81 e8 00 00 restore
40007ef8 <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)
{
40007ef8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
40007efc: 80 a6 20 00 cmp %i0, 0
40007f00: 02 80 00 1d be 40007f74 <rtems_iterate_over_all_threads+0x7c><== NEVER TAKEN
40007f04: 03 10 00 90 sethi %hi(0x40024000), %g1
return;
40007f08: a4 10 63 14 or %g1, 0x314, %l2 ! 40024314 <_Objects_Information_table+0x4>
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
40007f0c: a6 04 a0 10 add %l2, 0x10, %l3
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
40007f10: c2 04 80 00 ld [ %l2 ], %g1
40007f14: 80 a0 60 00 cmp %g1, 0
40007f18: 22 80 00 14 be,a 40007f68 <rtems_iterate_over_all_threads+0x70>
40007f1c: a4 04 a0 04 add %l2, 4, %l2
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
40007f20: e2 00 60 04 ld [ %g1 + 4 ], %l1
if ( information ) {
40007f24: 80 a4 60 00 cmp %l1, 0
40007f28: 12 80 00 0b bne 40007f54 <rtems_iterate_over_all_threads+0x5c><== ALWAYS TAKEN
40007f2c: a0 10 20 01 mov 1, %l0
for ( i=1 ; i <= information->maximum ; i++ ) {
40007f30: 10 80 00 0e b 40007f68 <rtems_iterate_over_all_threads+0x70><== NOT EXECUTED
40007f34: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED
the_thread = (Thread_Control *)information->local_table[ i ];
40007f38: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
40007f3c: d0 00 40 08 ld [ %g1 + %o0 ], %o0
if ( !the_thread )
40007f40: 80 a2 20 00 cmp %o0, 0
40007f44: 02 80 00 04 be 40007f54 <rtems_iterate_over_all_threads+0x5c><== NEVER TAKEN
40007f48: a0 04 20 01 inc %l0
continue;
(*routine)(the_thread);
40007f4c: 9f c6 00 00 call %i0
40007f50: 01 00 00 00 nop
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
40007f54: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1
40007f58: 80 a4 00 01 cmp %l0, %g1
40007f5c: 08 bf ff f7 bleu 40007f38 <rtems_iterate_over_all_threads+0x40>
40007f60: 91 2c 20 02 sll %l0, 2, %o0
40007f64: a4 04 a0 04 add %l2, 4, %l2
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
40007f68: 80 a4 80 13 cmp %l2, %l3
40007f6c: 32 bf ff ea bne,a 40007f14 <rtems_iterate_over_all_threads+0x1c>
40007f70: c2 04 80 00 ld [ %l2 ], %g1
40007f74: 81 c7 e0 08 ret
40007f78: 81 e8 00 00 restore
4000a280 <rtems_libio_allocate>:
* This routine searches the IOP Table for an unused entry. If it
* finds one, it returns it. Otherwise, it returns NULL.
*/
rtems_libio_t *rtems_libio_allocate( void )
{
4000a280: 9d e3 bf 90 save %sp, -112, %sp
rtems_libio_t *iop, *next;
rtems_status_code rc;
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000a284: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a288: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore>
4000a28c: 92 10 20 00 clr %o1
4000a290: 7f ff ec 56 call 400053e8 <rtems_semaphore_obtain>
4000a294: 94 10 20 00 clr %o2
if (rtems_libio_iop_freelist) {
4000a298: 23 10 00 5f sethi %hi(0x40017c00), %l1
4000a29c: c4 04 60 f4 ld [ %l1 + 0xf4 ], %g2 ! 40017cf4 <rtems_libio_iop_freelist>
4000a2a0: 80 a0 a0 00 cmp %g2, 0
4000a2a4: 02 80 00 28 be 4000a344 <rtems_libio_allocate+0xc4>
4000a2a8: b0 10 20 00 clr %i0
rc = rtems_semaphore_create(
4000a2ac: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a2b0: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops>
4000a2b4: 92 10 20 01 mov 1, %o1
4000a2b8: 86 20 80 03 sub %g2, %g3, %g3
4000a2bc: 87 38 e0 02 sra %g3, 2, %g3
4000a2c0: 83 28 e0 02 sll %g3, 2, %g1
4000a2c4: 85 28 e0 06 sll %g3, 6, %g2
4000a2c8: 84 20 80 01 sub %g2, %g1, %g2
4000a2cc: 83 28 a0 06 sll %g2, 6, %g1
4000a2d0: 82 20 40 02 sub %g1, %g2, %g1
4000a2d4: 85 28 60 0c sll %g1, 0xc, %g2
4000a2d8: 82 00 40 02 add %g1, %g2, %g1
4000a2dc: 82 00 40 03 add %g1, %g3, %g1
4000a2e0: 83 28 60 04 sll %g1, 4, %g1
4000a2e4: 82 20 40 03 sub %g1, %g3, %g1
4000a2e8: 83 28 60 02 sll %g1, 2, %g1
4000a2ec: 86 20 c0 01 sub %g3, %g1, %g3
4000a2f0: 94 10 20 54 mov 0x54, %o2
4000a2f4: 96 10 20 00 clr %o3
4000a2f8: 11 13 10 92 sethi %hi(0x4c424800), %o0
4000a2fc: 98 07 bf f4 add %fp, -12, %o4
4000a300: 90 12 21 00 or %o0, 0x100, %o0
4000a304: 7f ff eb 93 call 40005150 <rtems_semaphore_create>
4000a308: 90 10 c0 08 or %g3, %o0, %o0
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&sema
);
if (rc != RTEMS_SUCCESSFUL)
4000a30c: 80 a2 20 00 cmp %o0, 0
4000a310: 32 80 00 0d bne,a 4000a344 <rtems_libio_allocate+0xc4> <== NEVER TAKEN
4000a314: b0 10 20 00 clr %i0 <== NOT EXECUTED
goto failed;
iop = rtems_libio_iop_freelist;
4000a318: f0 04 60 f4 ld [ %l1 + 0xf4 ], %i0
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
4000a31c: 92 10 20 00 clr %o1
&sema
);
if (rc != RTEMS_SUCCESSFUL)
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
4000a320: e0 06 20 28 ld [ %i0 + 0x28 ], %l0
(void) memset( iop, 0, sizeof(rtems_libio_t) );
4000a324: 90 10 00 18 mov %i0, %o0
4000a328: 40 00 09 b4 call 4000c9f8 <memset>
4000a32c: 94 10 20 34 mov 0x34, %o2
iop->flags = LIBIO_FLAGS_OPEN;
iop->sem = sema;
4000a330: c2 07 bf f4 ld [ %fp + -12 ], %g1
rtems_libio_iop_freelist = next;
4000a334: e0 24 60 f4 st %l0, [ %l1 + 0xf4 ]
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
iop->flags = LIBIO_FLAGS_OPEN;
iop->sem = sema;
4000a338: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
if (rc != RTEMS_SUCCESSFUL)
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
iop->flags = LIBIO_FLAGS_OPEN;
4000a33c: 82 10 21 00 mov 0x100, %g1
4000a340: c2 26 20 0c st %g1, [ %i0 + 0xc ]
failed:
iop = 0;
done:
rtems_semaphore_release( rtems_libio_semaphore );
4000a344: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a348: 7f ff ec 6f call 40005504 <rtems_semaphore_release>
4000a34c: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore>
return iop;
}
4000a350: 81 c7 e0 08 ret
4000a354: 81 e8 00 00 restore
4000a220 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
4000a220: 9d e3 bf 98 save %sp, -104, %sp
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000a224: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000a228: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore>
4000a22c: 92 10 20 00 clr %o1
4000a230: 7f ff ec 6e call 400053e8 <rtems_semaphore_obtain>
4000a234: 94 10 20 00 clr %o2
if (iop->sem)
4000a238: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
4000a23c: 80 a2 20 00 cmp %o0, 0
4000a240: 02 80 00 04 be 4000a250 <rtems_libio_free+0x30> <== NEVER TAKEN
4000a244: a0 10 00 18 mov %i0, %l0
rtems_semaphore_delete(iop->sem);
4000a248: 7f ff ec 3a call 40005330 <rtems_semaphore_delete>
4000a24c: 01 00 00 00 nop
iop->flags &= ~LIBIO_FLAGS_OPEN;
4000a250: c4 04 20 0c ld [ %l0 + 0xc ], %g2
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
4000a254: 03 10 00 5f sethi %hi(0x40017c00), %g1
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
4000a258: 07 10 00 5f sethi %hi(0x40017c00), %g3
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
4000a25c: f0 00 60 f8 ld [ %g1 + 0xf8 ], %i0
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
4000a260: c2 00 e0 f4 ld [ %g3 + 0xf4 ], %g1
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
4000a264: 84 08 be ff and %g2, -257, %g2
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
4000a268: e0 20 e0 f4 st %l0, [ %g3 + 0xf4 ]
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
4000a26c: c2 24 20 28 st %g1, [ %l0 + 0x28 ]
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
4000a270: c4 24 20 0c st %g2, [ %l0 + 0xc ]
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
4000a274: 7f ff ec a4 call 40005504 <rtems_semaphore_release>
4000a278: 81 e8 00 00 restore
40002094 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
40002094: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code rc;
int i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
40002098: 21 10 00 5c sethi %hi(0x40017000), %l0
4000209c: d0 04 21 58 ld [ %l0 + 0x158 ], %o0 ! 40017158 <rtems_libio_number_iops>
400020a0: 80 a2 20 00 cmp %o0, 0
400020a4: 22 80 00 1d be,a 40002118 <rtems_libio_init+0x84>
400020a8: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
400020ac: 40 00 1f 35 call 40009d80 <calloc>
400020b0: 92 10 20 34 mov 0x34, %o1
400020b4: 03 10 00 5f sethi %hi(0x40017c00), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
400020b8: 80 a2 20 00 cmp %o0, 0
400020bc: 12 80 00 04 bne 400020cc <rtems_libio_init+0x38> <== ALWAYS TAKEN
400020c0: d0 20 60 f0 st %o0, [ %g1 + 0xf0 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
400020c4: 10 80 00 1f b 40002140 <rtems_libio_init+0xac> <== NOT EXECUTED
400020c8: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED
iop = rtems_libio_iop_freelist = rtems_libio_iops;
400020cc: 03 10 00 5f sethi %hi(0x40017c00), %g1
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
400020d0: c4 04 21 58 ld [ %l0 + 0x158 ], %g2
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;
400020d4: d0 20 60 f4 st %o0, [ %g1 + 0xf4 ]
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
400020d8: 86 10 20 00 clr %g3
400020dc: 10 80 00 03 b 400020e8 <rtems_libio_init+0x54>
400020e0: 82 10 00 08 mov %o0, %g1
iop->data1 = iop + 1;
400020e4: c2 20 7f f4 st %g1, [ %g1 + -12 ]
400020e8: 86 00 e0 01 inc %g3
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 < (rtems_libio_number_iops - 1) ; i++, iop++)
400020ec: 80 a0 c0 02 cmp %g3, %g2
400020f0: 12 bf ff fd bne 400020e4 <rtems_libio_init+0x50>
400020f4: 82 00 60 34 add %g1, 0x34, %g1
iop->data1 = iop + 1;
iop->data1 = NULL;
400020f8: 85 28 e0 02 sll %g3, 2, %g2
400020fc: 83 28 e0 04 sll %g3, 4, %g1
40002100: 82 20 40 02 sub %g1, %g2, %g1
40002104: 82 00 40 03 add %g1, %g3, %g1
40002108: 83 28 60 02 sll %g1, 2, %g1
4000210c: 82 02 00 01 add %o0, %g1, %g1
40002110: c0 20 7f f4 clr [ %g1 + -12 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
40002114: 11 13 10 92 sethi %hi(0x4c424800), %o0
40002118: 92 10 20 01 mov 1, %o1
4000211c: 90 12 21 4f or %o0, 0x14f, %o0
40002120: 94 10 20 54 mov 0x54, %o2
40002124: 96 10 20 00 clr %o3
40002128: 19 10 00 5f sethi %hi(0x40017c00), %o4
4000212c: 40 00 0c 09 call 40005150 <rtems_semaphore_create>
40002130: 98 13 20 f8 or %o4, 0xf8, %o4 ! 40017cf8 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
40002134: 80 a2 20 00 cmp %o0, 0
40002138: 02 80 00 04 be 40002148 <rtems_libio_init+0xb4> <== ALWAYS TAKEN
4000213c: 01 00 00 00 nop
rtems_fatal_error_occurred( rc );
40002140: 40 00 0e 6a call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002144: 01 00 00 00 nop <== NOT EXECUTED
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
40002148: 40 00 1e cc call 40009c78 <rtems_filesystem_initialize>
4000214c: 81 e8 00 00 restore
4000a128 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
4000a128: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_libio_t *iop;
int result=0;
int i;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000a12c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a130: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore><== NOT EXECUTED
4000a134: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000a138: 7f ff ec ac call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
4000a13c: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
4000a140: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a144: 86 10 20 00 clr %g3 <== NOT EXECUTED
4000a148: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 <== NOT EXECUTED
4000a14c: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED
4000a150: 10 80 00 0c b 4000a180 <rtems_libio_is_file_open+0x58> <== NOT EXECUTED
4000a154: c8 00 61 58 ld [ %g1 + 0x158 ], %g4 ! 40017158 <rtems_libio_number_iops><== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
4000a158: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
4000a15c: 02 80 00 08 be 4000a17c <rtems_libio_is_file_open+0x54> <== NOT EXECUTED
4000a160: 86 00 e0 01 inc %g3 <== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
4000a164: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
4000a168: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
4000a16c: 12 80 00 05 bne 4000a180 <rtems_libio_is_file_open+0x58> <== NOT EXECUTED
4000a170: 84 00 a0 34 add %g2, 0x34, %g2 <== NOT EXECUTED
4000a174: 10 80 00 07 b 4000a190 <rtems_libio_is_file_open+0x68> <== NOT EXECUTED
4000a178: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
4000a17c: 84 00 a0 34 add %g2, 0x34, %g2 <== NOT EXECUTED
4000a180: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED
4000a184: 2a bf ff f5 bcs,a 4000a158 <rtems_libio_is_file_open+0x30><== NOT EXECUTED
4000a188: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 <== NOT EXECUTED
4000a18c: b0 10 20 00 clr %i0 <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
4000a190: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a194: 7f ff ec dc call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
4000a198: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore><== NOT EXECUTED
return result;
}
4000a19c: 81 c7 e0 08 ret <== NOT EXECUTED
4000a1a0: 81 e8 00 00 restore <== NOT EXECUTED
4000a1a4 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
4000a1a4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_libio_t *iop;
int result = 0;
int i;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
4000a1a8: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a1ac: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore><== NOT EXECUTED
4000a1b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000a1b4: 7f ff ec 8d call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
4000a1b8: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
4000a1bc: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a1c0: 86 10 20 00 clr %g3 <== NOT EXECUTED
4000a1c4: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 <== NOT EXECUTED
4000a1c8: 03 10 00 5c sethi %hi(0x40017000), %g1 <== NOT EXECUTED
4000a1cc: 10 80 00 0c b 4000a1fc <rtems_libio_is_open_files_in_fs+0x58><== NOT EXECUTED
4000a1d0: c8 00 61 58 ld [ %g1 + 0x158 ], %g4 ! 40017158 <rtems_libio_number_iops><== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
4000a1d4: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
4000a1d8: 02 80 00 08 be 4000a1f8 <rtems_libio_is_open_files_in_fs+0x54><== NOT EXECUTED
4000a1dc: 86 00 e0 01 inc %g3 <== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.mt_entry == fs_mt_entry ) {
4000a1e0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
4000a1e4: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
4000a1e8: 12 80 00 05 bne 4000a1fc <rtems_libio_is_open_files_in_fs+0x58><== NOT EXECUTED
4000a1ec: 84 00 a0 34 add %g2, 0x34, %g2 <== NOT EXECUTED
4000a1f0: 10 80 00 07 b 4000a20c <rtems_libio_is_open_files_in_fs+0x68><== NOT EXECUTED
4000a1f4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
4000a1f8: 84 00 a0 34 add %g2, 0x34, %g2 <== NOT EXECUTED
4000a1fc: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED
4000a200: 2a bf ff f5 bcs,a 4000a1d4 <rtems_libio_is_open_files_in_fs+0x30><== NOT EXECUTED
4000a204: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 <== NOT EXECUTED
4000a208: b0 10 20 00 clr %i0 <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
4000a20c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
4000a210: 7f ff ec bd call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
4000a214: d0 00 60 f8 ld [ %g1 + 0xf8 ], %o0 ! 40017cf8 <rtems_libio_semaphore><== NOT EXECUTED
return result;
}
4000a218: 81 c7 e0 08 ret <== NOT EXECUTED
4000a21c: 81 e8 00 00 restore <== NOT EXECUTED
4000a0d0 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
4000a0d0: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
4000a0d4: 82 08 a0 06 and %g2, 6, %g1 <== NOT EXECUTED
4000a0d8: 80 a0 60 06 cmp %g1, 6 <== NOT EXECUTED
4000a0dc: 02 80 00 07 be 4000a0f8 <rtems_libio_to_fcntl_flags+0x28> <== NOT EXECUTED
4000a0e0: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
4000a0e4: 83 30 a0 02 srl %g2, 2, %g1 <== NOT EXECUTED
4000a0e8: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED
4000a0ec: 02 80 00 03 be 4000a0f8 <rtems_libio_to_fcntl_flags+0x28> <== NOT EXECUTED
4000a0f0: 90 08 60 01 and %g1, 1, %o0 <== NOT EXECUTED
4000a0f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
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 ) {
4000a0f8: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
4000a0fc: 02 80 00 04 be 4000a10c <rtems_libio_to_fcntl_flags+0x3c> <== NOT EXECUTED
4000a100: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED
fcntl_flags |= O_NONBLOCK;
4000a104: 03 00 00 10 sethi %hi(0x4000), %g1 <== NOT EXECUTED
4000a108: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
4000a10c: 32 80 00 02 bne,a 4000a114 <rtems_libio_to_fcntl_flags+0x44><== NOT EXECUTED
4000a110: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
4000a114: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED
4000a118: 32 80 00 02 bne,a 4000a120 <rtems_libio_to_fcntl_flags+0x50><== NOT EXECUTED
4000a11c: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
4000a120: 81 c3 e0 08 retl <== NOT EXECUTED
40005778 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
40005778: 9d e3 bf 98 save %sp, -104, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
4000577c: a0 96 20 00 orcc %i0, 0, %l0
40005780: 02 80 00 1f be 400057fc <rtems_memalign+0x84>
40005784: 03 10 00 77 sethi %hi(0x4001dc00), %g1
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
40005788: c2 00 61 74 ld [ %g1 + 0x174 ], %g1 ! 4001dd74 <_System_state_Current>
4000578c: 80 a0 60 03 cmp %g1, 3
40005790: 12 80 00 07 bne 400057ac <rtems_memalign+0x34> <== NEVER TAKEN
40005794: c0 24 00 00 clr [ %l0 ]
40005798: 7f ff fb cf call 400046d4 <malloc_is_system_state_OK>
4000579c: 01 00 00 00 nop
400057a0: 80 8a 20 ff btst 0xff, %o0
400057a4: 02 80 00 17 be 40005800 <rtems_memalign+0x88> <== NEVER TAKEN
400057a8: b0 10 20 16 mov 0x16, %i0
/*
*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
400057ac: 7f ff fb e4 call 4000473c <malloc_deferred_frees_process>
400057b0: b0 10 20 0c mov 0xc, %i0
/*
* Perform the aligned allocation requested
*/
return_this = _Protected_heap_Allocate_aligned(
400057b4: 92 10 00 1a mov %i2, %o1
400057b8: 94 10 00 19 mov %i1, %o2
400057bc: 11 10 00 76 sethi %hi(0x4001d800), %o0
400057c0: 40 00 13 10 call 4000a400 <_Protected_heap_Allocate_aligned>
400057c4: 90 12 22 08 or %o0, 0x208, %o0 ! 4001da08 <RTEMS_Malloc_Heap>
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
400057c8: b4 92 20 00 orcc %o0, 0, %i2
400057cc: 02 80 00 0d be 40005800 <rtems_memalign+0x88>
400057d0: 03 10 00 74 sethi %hi(0x4001d000), %g1
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
400057d4: c2 00 63 e4 ld [ %g1 + 0x3e4 ], %g1 ! 4001d3e4 <rtems_malloc_statistics_helpers>
400057d8: 80 a0 60 00 cmp %g1, 0
400057dc: 22 80 00 06 be,a 400057f4 <rtems_memalign+0x7c> <== ALWAYS TAKEN
400057e0: f4 24 00 00 st %i2, [ %l0 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
400057e4: c2 00 60 04 ld [ %g1 + 4 ], %g1
400057e8: 9f c0 40 00 call %g1
400057ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
*/
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
*pointer = return_this;
400057f0: f4 24 00 00 st %i2, [ %l0 ] <== NOT EXECUTED
400057f4: 81 c7 e0 08 ret
400057f8: 91 e8 20 00 restore %g0, 0, %o0
return 0;
400057fc: b0 10 20 16 mov 0x16, %i0
}
40005800: 81 c7 e0 08 ret
40005804: 81 e8 00 00 restore
4000f08c <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
4000f08c: 9d e3 bf 90 save %sp, -112, %sp
CORE_message_queue_Attributes the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
bool is_global;
#endif
if ( !rtems_is_name_valid( name ) )
4000f090: a2 96 20 00 orcc %i0, 0, %l1
4000f094: 02 80 00 16 be 4000f0ec <rtems_message_queue_create+0x60>
4000f098: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
4000f09c: 80 a7 20 00 cmp %i4, 0
4000f0a0: 02 80 00 13 be 4000f0ec <rtems_message_queue_create+0x60> <== NEVER TAKEN
4000f0a4: b0 10 20 09 mov 9, %i0
if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
!_System_state_Is_multiprocessing )
return RTEMS_MP_NOT_CONFIGURED;
#endif
if ( count == 0 )
4000f0a8: 80 a6 60 00 cmp %i1, 0
4000f0ac: 02 80 00 10 be 4000f0ec <rtems_message_queue_create+0x60> <== NEVER TAKEN
4000f0b0: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
4000f0b4: 80 a6 a0 00 cmp %i2, 0
4000f0b8: 02 80 00 0d be 4000f0ec <rtems_message_queue_create+0x60> <== NEVER TAKEN
4000f0bc: b0 10 20 08 mov 8, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
4000f0c0: 05 10 00 c6 sethi %hi(0x40031800), %g2
4000f0c4: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
4000f0c8: 82 00 60 01 inc %g1
4000f0cc: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
4000f0d0: 40 00 24 17 call 4001812c <_Message_queue_Allocate>
4000f0d4: 01 00 00 00 nop
if ( !the_message_queue ) {
4000f0d8: a0 92 20 00 orcc %o0, 0, %l0
4000f0dc: 12 80 00 06 bne 4000f0f4 <rtems_message_queue_create+0x68>
4000f0e0: 80 8e e0 04 btst 4, %i3
_Thread_Enable_dispatch();
4000f0e4: 40 00 15 c2 call 400147ec <_Thread_Enable_dispatch>
4000f0e8: b0 10 20 05 mov 5, %i0
4000f0ec: 81 c7 e0 08 ret
4000f0f0: 81 e8 00 00 restore
}
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
4000f0f4: 02 80 00 05 be 4000f108 <rtems_message_queue_create+0x7c>
4000f0f8: f6 24 20 10 st %i3, [ %l0 + 0x10 ]
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
4000f0fc: 82 10 20 01 mov 1, %g1
4000f100: 10 80 00 03 b 4000f10c <rtems_message_queue_create+0x80>
4000f104: c2 27 bf f4 st %g1, [ %fp + -12 ]
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
4000f108: c0 27 bf f4 clr [ %fp + -12 ]
if ( ! _CORE_message_queue_Initialize(
4000f10c: 94 10 00 19 mov %i1, %o2
4000f110: 96 10 00 1a mov %i2, %o3
4000f114: 90 04 20 14 add %l0, 0x14, %o0
4000f118: 40 00 0d 2a call 400125c0 <_CORE_message_queue_Initialize>
4000f11c: 92 07 bf f4 add %fp, -12, %o1
4000f120: 80 8a 20 ff btst 0xff, %o0
4000f124: 12 80 00 0a bne 4000f14c <rtems_message_queue_create+0xc0>
4000f128: 03 10 00 c7 sethi %hi(0x40031c00), %g1
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
4000f12c: 90 10 61 10 or %g1, 0x110, %o0 ! 40031d10 <_Message_queue_Information>
4000f130: 92 10 00 10 mov %l0, %o1
4000f134: 40 00 12 dc call 40013ca4 <_Objects_Free>
4000f138: b0 10 20 0d mov 0xd, %i0
_Objects_MP_Close(
&_Message_queue_Information, the_message_queue->Object.id);
#endif
_Message_queue_Free( the_message_queue );
_Thread_Enable_dispatch();
4000f13c: 40 00 15 ac call 400147ec <_Thread_Enable_dispatch>
4000f140: 01 00 00 00 nop
4000f144: 81 c7 e0 08 ret
4000f148: 81 e8 00 00 restore
4000f14c: c4 04 20 08 ld [ %l0 + 8 ], %g2
4000f150: 82 10 61 10 or %g1, 0x110, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000f154: e2 24 20 0c st %l1, [ %l0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000f158: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
4000f15c: c4 27 00 00 st %g2, [ %i4 ]
4000f160: 03 00 00 3f sethi %hi(0xfc00), %g1
4000f164: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4000f168: 84 08 80 01 and %g2, %g1, %g2
4000f16c: 85 28 a0 02 sll %g2, 2, %g2
name,
0
);
#endif
_Thread_Enable_dispatch();
4000f170: b0 10 20 00 clr %i0
4000f174: 40 00 15 9e call 400147ec <_Thread_Enable_dispatch>
4000f178: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
return RTEMS_SUCCESSFUL;
}
4000f17c: 81 c7 e0 08 ret
4000f180: 81 e8 00 00 restore
4000f1ec <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
Objects_Id id,
uint32_t *count
)
{
4000f1ec: 9d e3 bf 90 save %sp, -112, %sp
4000f1f0: 92 10 00 18 mov %i0, %o1
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
4000f1f4: 80 a6 60 00 cmp %i1, 0
4000f1f8: 02 80 00 0f be 4000f234 <rtems_message_queue_flush+0x48> <== NEVER TAKEN
4000f1fc: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Message_queue_Control *)
4000f200: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4000f204: 94 07 bf f4 add %fp, -12, %o2
4000f208: 40 00 13 26 call 40013ea0 <_Objects_Get>
4000f20c: 90 12 21 10 or %o0, 0x110, %o0
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4000f210: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000f214: 80 a0 60 00 cmp %g1, 0
4000f218: 12 80 00 07 bne 4000f234 <rtems_message_queue_flush+0x48>
4000f21c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
4000f220: 40 00 0c c8 call 40012540 <_CORE_message_queue_Flush>
4000f224: 90 02 20 14 add %o0, 0x14, %o0
_Thread_Enable_dispatch();
4000f228: b0 10 20 00 clr %i0
4000f22c: 40 00 15 70 call 400147ec <_Thread_Enable_dispatch>
4000f230: d0 26 40 00 st %o0, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000f234: 81 c7 e0 08 ret
4000f238: 81 e8 00 00 restore
4000f23c <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
Objects_Id id,
uint32_t *count
)
{
4000f23c: 9d e3 bf 90 save %sp, -112, %sp
4000f240: 92 10 00 18 mov %i0, %o1
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
4000f244: 80 a6 60 00 cmp %i1, 0
4000f248: 02 80 00 0e be 4000f280 <rtems_message_queue_get_number_pending+0x44><== NEVER TAKEN
4000f24c: b0 10 20 09 mov 9, %i0
4000f250: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4000f254: 94 07 bf f4 add %fp, -12, %o2
4000f258: 40 00 13 12 call 40013ea0 <_Objects_Get>
4000f25c: 90 12 21 10 or %o0, 0x110, %o0
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4000f260: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000f264: 80 a0 60 00 cmp %g1, 0
4000f268: 12 80 00 06 bne 4000f280 <rtems_message_queue_get_number_pending+0x44>
4000f26c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
4000f270: c2 02 20 5c ld [ %o0 + 0x5c ], %g1
_Thread_Enable_dispatch();
4000f274: b0 10 20 00 clr %i0
4000f278: 40 00 15 5d call 400147ec <_Thread_Enable_dispatch>
4000f27c: c2 26 40 00 st %g1, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000f280: 81 c7 e0 08 ret
4000f284: 81 e8 00 00 restore
4000f348 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
Objects_Id id,
const void *buffer,
size_t size
)
{
4000f348: 9d e3 bf 88 save %sp, -120, %sp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
4000f34c: 80 a6 60 00 cmp %i1, 0
4000f350: 02 80 00 1a be 4000f3b8 <rtems_message_queue_send+0x70> <== NEVER TAKEN
4000f354: 90 10 20 09 mov 9, %o0
4000f358: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4000f35c: 92 10 00 18 mov %i0, %o1
4000f360: 90 12 21 10 or %o0, 0x110, %o0
4000f364: 40 00 12 cf call 40013ea0 <_Objects_Get>
4000f368: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4000f36c: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000f370: 84 10 00 08 mov %o0, %g2
4000f374: 80 a0 60 00 cmp %g1, 0
4000f378: 12 80 00 10 bne 4000f3b8 <rtems_message_queue_send+0x70>
4000f37c: 90 10 20 04 mov 4, %o0
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
4000f380: 92 10 00 19 mov %i1, %o1
4000f384: 94 10 00 1a mov %i2, %o2
4000f388: 96 10 00 18 mov %i0, %o3
4000f38c: 90 00 a0 14 add %g2, 0x14, %o0
4000f390: 98 10 20 00 clr %o4
4000f394: c0 23 a0 5c clr [ %sp + 0x5c ]
4000f398: c0 23 a0 60 clr [ %sp + 0x60 ]
4000f39c: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5
4000f3a0: 40 00 0c fe call 40012798 <_CORE_message_queue_Submit>
4000f3a4: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff <RAM_END+0x3fbfffff>
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
4000f3a8: 40 00 15 11 call 400147ec <_Thread_Enable_dispatch>
4000f3ac: a0 10 00 08 mov %o0, %l0
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
4000f3b0: 40 00 00 04 call 4000f3c0 <_Message_queue_Translate_core_message_queue_return_code>
4000f3b4: 90 10 00 10 mov %l0, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000f3b8: 81 c7 e0 08 ret
4000f3bc: 91 e8 00 08 restore %g0, %o0, %o0
4000f3d4 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
Objects_Id id,
const void *buffer,
size_t size
)
{
4000f3d4: 9d e3 bf 88 save %sp, -120, %sp
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
4000f3d8: 80 a6 60 00 cmp %i1, 0
4000f3dc: 02 80 00 19 be 4000f440 <rtems_message_queue_urgent+0x6c> <== NEVER TAKEN
4000f3e0: 90 10 20 09 mov 9, %o0
4000f3e4: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4000f3e8: 92 10 00 18 mov %i0, %o1
4000f3ec: 90 12 21 10 or %o0, 0x110, %o0
4000f3f0: 40 00 12 ac call 40013ea0 <_Objects_Get>
4000f3f4: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
4000f3f8: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000f3fc: 84 10 00 08 mov %o0, %g2
4000f400: 80 a0 60 00 cmp %g1, 0
4000f404: 12 80 00 0f bne 4000f440 <rtems_message_queue_urgent+0x6c>
4000f408: 90 10 20 04 mov 4, %o0
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
4000f40c: 92 10 00 19 mov %i1, %o1
4000f410: 94 10 00 1a mov %i2, %o2
4000f414: 96 10 00 18 mov %i0, %o3
4000f418: 90 00 a0 14 add %g2, 0x14, %o0
4000f41c: 98 10 20 00 clr %o4
4000f420: 1b 20 00 00 sethi %hi(0x80000000), %o5
4000f424: c0 23 a0 5c clr [ %sp + 0x5c ]
4000f428: 40 00 0c dc call 40012798 <_CORE_message_queue_Submit>
4000f42c: c0 23 a0 60 clr [ %sp + 0x60 ]
id,
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
4000f430: 40 00 14 ef call 400147ec <_Thread_Enable_dispatch>
4000f434: a0 10 00 08 mov %o0, %l0
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
4000f438: 7f ff ff e2 call 4000f3c0 <_Message_queue_Translate_core_message_queue_return_code>
4000f43c: 90 10 00 10 mov %l0, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000f440: 81 c7 e0 08 ret
4000f444: 91 e8 00 08 restore %g0, %o0, %o0
40006c18 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
40006c18: 9d e3 bf 90 save %sp, -112, %sp
40006c1c: 90 10 00 18 mov %i0, %o0
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
40006c20: 80 a6 60 00 cmp %i1, 0
40006c24: 02 80 00 18 be 40006c84 <rtems_object_set_name+0x6c> <== NEVER TAKEN
40006c28: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
40006c2c: b0 92 20 00 orcc %o0, 0, %i0
40006c30: 12 80 00 04 bne 40006c40 <rtems_object_set_name+0x28>
40006c34: 03 10 00 74 sethi %hi(0x4001d000), %g1
40006c38: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 4001d230 <_Thread_Executing>
40006c3c: f0 00 60 08 ld [ %g1 + 8 ], %i0
information = _Objects_Get_information_id( tmpId );
40006c40: 40 00 06 82 call 40008648 <_Objects_Get_information_id>
40006c44: 90 10 00 18 mov %i0, %o0
if ( !information )
40006c48: a0 92 20 00 orcc %o0, 0, %l0
40006c4c: 02 80 00 10 be 40006c8c <rtems_object_set_name+0x74>
40006c50: 92 10 00 18 mov %i0, %o1
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
40006c54: 40 00 07 0c call 40008884 <_Objects_Get>
40006c58: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
40006c5c: c2 07 bf f4 ld [ %fp + -12 ], %g1
40006c60: 80 a0 60 00 cmp %g1, 0
40006c64: 32 80 00 08 bne,a 40006c84 <rtems_object_set_name+0x6c>
40006c68: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
40006c6c: 92 10 00 08 mov %o0, %o1
40006c70: 94 10 00 19 mov %i1, %o2
40006c74: 40 00 07 96 call 40008acc <_Objects_Set_name>
40006c78: 90 10 00 10 mov %l0, %o0
_Thread_Enable_dispatch();
40006c7c: 40 00 09 93 call 400092c8 <_Thread_Enable_dispatch>
40006c80: b0 10 20 00 clr %i0
40006c84: 81 c7 e0 08 ret
40006c88: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
40006c8c: b0 10 20 04 mov 4, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40006c90: 81 c7 e0 08 ret
40006c94: 81 e8 00 00 restore
40003048 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
40003048: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
4000304c: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
40003050: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
40003054: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
40003058: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
4000305c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
40003060: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
40003064: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
40003068: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
4000306c: 7f ff ff 88 call 40002e8c <rtems_verror> <== NOT EXECUTED
40003070: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED
va_end(arglist);
}
40003074: 81 c7 e0 08 ret <== NOT EXECUTED
40003078: 81 e8 00 00 restore <== NOT EXECUTED
4000f448 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
4000f448: 9d e3 bf 98 save %sp, -104, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
4000f44c: a6 96 20 00 orcc %i0, 0, %l3
4000f450: 02 80 00 1e be 4000f4c8 <rtems_partition_create+0x80>
4000f454: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !starting_address )
4000f458: 80 a6 60 00 cmp %i1, 0
4000f45c: 02 80 00 38 be 4000f53c <rtems_partition_create+0xf4> <== NEVER TAKEN
4000f460: 80 a7 60 00 cmp %i5, 0
return RTEMS_INVALID_ADDRESS;
if ( !id )
4000f464: 02 80 00 36 be 4000f53c <rtems_partition_create+0xf4> <== NEVER TAKEN
4000f468: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
4000f46c: 22 80 00 17 be,a 4000f4c8 <rtems_partition_create+0x80>
4000f470: b0 10 20 08 mov 8, %i0
4000f474: 80 a6 e0 00 cmp %i3, 0
4000f478: 22 80 00 14 be,a 4000f4c8 <rtems_partition_create+0x80>
4000f47c: b0 10 20 08 mov 8, %i0
4000f480: 80 a6 80 1b cmp %i2, %i3
4000f484: 0a 80 00 30 bcs 4000f544 <rtems_partition_create+0xfc>
4000f488: 80 8e e0 07 btst 7, %i3
4000f48c: 12 80 00 2e bne 4000f544 <rtems_partition_create+0xfc>
4000f490: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
4000f494: 12 80 00 2a bne 4000f53c <rtems_partition_create+0xf4>
4000f498: 05 10 00 c6 sethi %hi(0x40031800), %g2
4000f49c: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
4000f4a0: 82 00 60 01 inc %g1
4000f4a4: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
* 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 );
4000f4a8: 25 10 00 c5 sethi %hi(0x40031400), %l2
4000f4ac: 40 00 11 11 call 400138f0 <_Objects_Allocate>
4000f4b0: 90 14 a3 ec or %l2, 0x3ec, %o0 ! 400317ec <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
4000f4b4: a2 92 20 00 orcc %o0, 0, %l1
4000f4b8: 12 80 00 06 bne 4000f4d0 <rtems_partition_create+0x88>
4000f4bc: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
4000f4c0: 40 00 14 cb call 400147ec <_Thread_Enable_dispatch>
4000f4c4: b0 10 20 05 mov 5, %i0
4000f4c8: 81 c7 e0 08 ret
4000f4cc: 81 e8 00 00 restore
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
4000f4d0: f8 24 60 1c st %i4, [ %l1 + 0x1c ]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
4000f4d4: f2 24 60 10 st %i1, [ %l1 + 0x10 ]
the_partition->length = length;
4000f4d8: f4 24 60 14 st %i2, [ %l1 + 0x14 ]
the_partition->buffer_size = buffer_size;
4000f4dc: f6 24 60 18 st %i3, [ %l1 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
4000f4e0: c0 24 60 20 clr [ %l1 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
4000f4e4: 40 00 4b 59 call 40022248 <.udiv>
4000f4e8: 90 10 00 1a mov %i2, %o0
4000f4ec: 92 10 00 19 mov %i1, %o1
4000f4f0: 94 10 00 08 mov %o0, %o2
4000f4f4: 96 10 00 1b mov %i3, %o3
4000f4f8: a0 04 60 24 add %l1, 0x24, %l0
4000f4fc: 40 00 0b d7 call 40012458 <_Chain_Initialize>
4000f500: 90 10 00 10 mov %l0, %o0
4000f504: c4 04 60 08 ld [ %l1 + 8 ], %g2
4000f508: 82 14 a3 ec or %l2, 0x3ec, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000f50c: e6 24 60 0c st %l3, [ %l1 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000f510: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
4000f514: c4 27 40 00 st %g2, [ %i5 ]
4000f518: 03 00 00 3f sethi %hi(0xfc00), %g1
4000f51c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4000f520: 84 08 80 01 and %g2, %g1, %g2
4000f524: 85 28 a0 02 sll %g2, 2, %g2
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
4000f528: b0 10 20 00 clr %i0
4000f52c: 40 00 14 b0 call 400147ec <_Thread_Enable_dispatch>
4000f530: e2 20 c0 02 st %l1, [ %g3 + %g2 ]
4000f534: 81 c7 e0 08 ret
4000f538: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
4000f53c: 81 c7 e0 08 ret
4000f540: 91 e8 20 09 restore %g0, 9, %o0
4000f544: b0 10 20 08 mov 8, %i0
}
4000f548: 81 c7 e0 08 ret
4000f54c: 81 e8 00 00 restore
4000f5c4 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
Objects_Id id,
void **buffer
)
{
4000f5c4: 9d e3 bf 90 save %sp, -112, %sp
4000f5c8: 92 10 00 18 mov %i0, %o1
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
4000f5cc: 80 a6 60 00 cmp %i1, 0
4000f5d0: 02 80 00 19 be 4000f634 <rtems_partition_get_buffer+0x70> <== NEVER TAKEN
4000f5d4: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
4000f5d8: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000f5dc: 94 07 bf f4 add %fp, -12, %o2
4000f5e0: 40 00 12 30 call 40013ea0 <_Objects_Get>
4000f5e4: 90 12 23 ec or %o0, 0x3ec, %o0
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
4000f5e8: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000f5ec: a0 10 00 08 mov %o0, %l0
4000f5f0: 80 a0 60 00 cmp %g1, 0
4000f5f4: 12 80 00 10 bne 4000f634 <rtems_partition_get_buffer+0x70>
4000f5f8: b0 10 20 04 mov 4, %i0
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
4000f5fc: 40 00 0b 87 call 40012418 <_Chain_Get>
4000f600: 90 02 20 24 add %o0, 0x24, %o0
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
4000f604: b0 92 20 00 orcc %o0, 0, %i0
4000f608: 02 80 00 09 be 4000f62c <rtems_partition_get_buffer+0x68>
4000f60c: 01 00 00 00 nop
the_partition->number_of_used_blocks += 1;
4000f610: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
4000f614: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
4000f618: 40 00 14 75 call 400147ec <_Thread_Enable_dispatch>
4000f61c: c2 24 20 20 st %g1, [ %l0 + 0x20 ]
*buffer = the_buffer;
4000f620: f0 26 40 00 st %i0, [ %i1 ]
4000f624: 81 c7 e0 08 ret
4000f628: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
4000f62c: 40 00 14 70 call 400147ec <_Thread_Enable_dispatch>
4000f630: b0 10 20 0d mov 0xd, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000f634: 81 c7 e0 08 ret
4000f638: 81 e8 00 00 restore
4000e9d0 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
Objects_Id *id
)
{
4000e9d0: 9d e3 bf 98 save %sp, -104, %sp
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
4000e9d4: a2 96 20 00 orcc %i0, 0, %l1
4000e9d8: 02 80 00 14 be 4000ea28 <rtems_port_create+0x58>
4000e9dc: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
4000e9e0: 80 a7 20 00 cmp %i4, 0
4000e9e4: 02 80 00 24 be 4000ea74 <rtems_port_create+0xa4> <== NEVER TAKEN
4000e9e8: 82 16 80 19 or %i2, %i1, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
4000e9ec: 80 88 60 07 btst 7, %g1
4000e9f0: 12 80 00 0e bne 4000ea28 <rtems_port_create+0x58>
4000e9f4: b0 10 20 09 mov 9, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
4000e9f8: 05 10 00 c6 sethi %hi(0x40031800), %g2
4000e9fc: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
4000ea00: 82 00 60 01 inc %g1
4000ea04: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
* of free port control blocks.
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
4000ea08: 21 10 00 c5 sethi %hi(0x40031400), %l0
4000ea0c: 40 00 13 b9 call 400138f0 <_Objects_Allocate>
4000ea10: 90 14 23 ac or %l0, 0x3ac, %o0 ! 400317ac <_Dual_ported_memory_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
4000ea14: 80 a2 20 00 cmp %o0, 0
4000ea18: 32 80 00 06 bne,a 4000ea30 <rtems_port_create+0x60>
4000ea1c: c4 02 20 08 ld [ %o0 + 8 ], %g2
_Thread_Enable_dispatch();
4000ea20: 40 00 17 73 call 400147ec <_Thread_Enable_dispatch>
4000ea24: b0 10 20 05 mov 5, %i0
4000ea28: 81 c7 e0 08 ret
4000ea2c: 81 e8 00 00 restore
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000ea30: 82 14 23 ac or %l0, 0x3ac, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000ea34: e2 22 20 0c st %l1, [ %o0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
4000ea38: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
4000ea3c: 82 06 ff ff add %i3, -1, %g1
4000ea40: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
4000ea44: c4 27 00 00 st %g2, [ %i4 ]
4000ea48: 03 00 00 3f sethi %hi(0xfc00), %g1
4000ea4c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
4000ea50: 84 08 80 01 and %g2, %g1, %g2
4000ea54: 85 28 a0 02 sll %g2, 2, %g2
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
4000ea58: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
the_port->external_base = external_start;
4000ea5c: f4 22 20 14 st %i2, [ %o0 + 0x14 ]
4000ea60: d0 20 c0 02 st %o0, [ %g3 + %g2 ]
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
4000ea64: 40 00 17 62 call 400147ec <_Thread_Enable_dispatch>
4000ea68: b0 10 20 00 clr %i0
4000ea6c: 81 c7 e0 08 ret
4000ea70: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
4000ea74: b0 10 20 09 mov 9, %i0
}
4000ea78: 81 c7 e0 08 ret
4000ea7c: 81 e8 00 00 restore
4000ead8 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
Objects_Id id,
void *external,
void **internal
)
{
4000ead8: 9d e3 bf 90 save %sp, -112, %sp
4000eadc: 92 10 00 18 mov %i0, %o1
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
4000eae0: 80 a6 a0 00 cmp %i2, 0
4000eae4: 02 80 00 16 be 4000eb3c <rtems_port_external_to_internal+0x64><== NEVER TAKEN
4000eae8: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Dual_ported_memory_Control *)
4000eaec: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000eaf0: 94 07 bf f4 add %fp, -12, %o2
4000eaf4: 40 00 14 eb call 40013ea0 <_Objects_Get>
4000eaf8: 90 12 23 ac or %o0, 0x3ac, %o0
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
4000eafc: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000eb00: 80 a0 60 00 cmp %g1, 0
4000eb04: 12 80 00 0e bne 4000eb3c <rtems_port_external_to_internal+0x64>
4000eb08: b0 10 20 04 mov 4, %i0
RTEMS_INLINE_ROUTINE uint32_t _Addresses_Subtract (
void *left,
void *right
)
{
return ((char *) left - (char *) right);
4000eb0c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
4000eb10: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
4000eb14: 86 26 40 01 sub %i1, %g1, %g3
4000eb18: 80 a0 c0 02 cmp %g3, %g2
4000eb1c: 28 80 00 04 bleu,a 4000eb2c <rtems_port_external_to_internal+0x54>
4000eb20: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
*internal = external;
4000eb24: 10 80 00 04 b 4000eb34 <rtems_port_external_to_internal+0x5c>
4000eb28: f2 26 80 00 st %i1, [ %i2 ]
else
*internal = _Addresses_Add_offset( the_port->internal_base,
4000eb2c: 82 00 40 03 add %g1, %g3, %g1
4000eb30: c2 26 80 00 st %g1, [ %i2 ]
ending );
_Thread_Enable_dispatch();
4000eb34: 40 00 17 2e call 400147ec <_Thread_Enable_dispatch>
4000eb38: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000eb3c: 81 c7 e0 08 ret
4000eb40: 81 e8 00 00 restore
4000eb78 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
Objects_Id id,
void *internal,
void **external
)
{
4000eb78: 9d e3 bf 90 save %sp, -112, %sp
4000eb7c: 92 10 00 18 mov %i0, %o1
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
4000eb80: 80 a6 a0 00 cmp %i2, 0
4000eb84: 02 80 00 16 be 4000ebdc <rtems_port_internal_to_external+0x64><== NEVER TAKEN
4000eb88: b0 10 20 09 mov 9, %i0
4000eb8c: 11 10 00 c5 sethi %hi(0x40031400), %o0
4000eb90: 94 07 bf f4 add %fp, -12, %o2
4000eb94: 40 00 14 c3 call 40013ea0 <_Objects_Get>
4000eb98: 90 12 23 ac or %o0, 0x3ac, %o0
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
4000eb9c: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000eba0: 80 a0 60 00 cmp %g1, 0
4000eba4: 12 80 00 0e bne 4000ebdc <rtems_port_internal_to_external+0x64>
4000eba8: b0 10 20 04 mov 4, %i0
4000ebac: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
4000ebb0: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
4000ebb4: 86 26 40 01 sub %i1, %g1, %g3
4000ebb8: 80 a0 c0 02 cmp %g3, %g2
4000ebbc: 28 80 00 04 bleu,a 4000ebcc <rtems_port_internal_to_external+0x54>
4000ebc0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
*external = internal;
4000ebc4: 10 80 00 04 b 4000ebd4 <rtems_port_internal_to_external+0x5c>
4000ebc8: f2 26 80 00 st %i1, [ %i2 ]
else
*external = _Addresses_Add_offset( the_port->external_base,
4000ebcc: 82 00 40 03 add %g1, %g3, %g1
4000ebd0: c2 26 80 00 st %g1, [ %i2 ]
ending );
_Thread_Enable_dispatch();
4000ebd4: 40 00 17 06 call 400147ec <_Thread_Enable_dispatch>
4000ebd8: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000ebdc: 81 c7 e0 08 ret
4000ebe0: 81 e8 00 00 restore
40006304 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
Objects_Id *id
)
{
40006304: 9d e3 bf 98 save %sp, -104, %sp
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
40006308: a4 96 20 00 orcc %i0, 0, %l2
4000630c: 02 80 00 11 be 40006350 <rtems_rate_monotonic_create+0x4c>
40006310: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
40006314: 80 a6 60 00 cmp %i1, 0
40006318: 02 80 00 0e be 40006350 <rtems_rate_monotonic_create+0x4c><== NEVER TAKEN
4000631c: b0 10 20 09 mov 9, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40006320: 05 10 00 72 sethi %hi(0x4001c800), %g2
40006324: c2 00 a1 a0 ld [ %g2 + 0x1a0 ], %g1 ! 4001c9a0 <_Thread_Dispatch_disable_level>
40006328: 82 00 60 01 inc %g1
4000632c: c2 20 a1 a0 st %g1, [ %g2 + 0x1a0 ]
* This function allocates a period control block from
* the inactive chain of free period control blocks.
*/
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void )
{
return (Rate_monotonic_Control *)
40006330: 23 10 00 72 sethi %hi(0x4001c800), %l1
40006334: 40 00 07 cc call 40008264 <_Objects_Allocate>
40006338: 90 14 60 24 or %l1, 0x24, %o0 ! 4001c824 <_Rate_monotonic_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
4000633c: a0 92 20 00 orcc %o0, 0, %l0
40006340: 12 80 00 06 bne 40006358 <rtems_rate_monotonic_create+0x54>
40006344: 03 10 00 72 sethi %hi(0x4001c800), %g1
_Thread_Enable_dispatch();
40006348: 40 00 0b ba call 40009230 <_Thread_Enable_dispatch>
4000634c: b0 10 20 05 mov 5, %i0
40006350: 81 c7 e0 08 ret
40006354: 81 e8 00 00 restore
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
40006358: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
4000635c: 92 10 20 00 clr %o1
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
40006360: c2 24 20 50 st %g1, [ %l0 + 0x50 ]
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
40006364: 94 10 20 38 mov 0x38, %o2
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
the_period->state = RATE_MONOTONIC_INACTIVE;
40006368: c0 24 20 38 clr [ %l0 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4000636c: c0 24 20 18 clr [ %l0 + 0x18 ]
the_watchdog->routine = routine;
40006370: c0 24 20 2c clr [ %l0 + 0x2c ]
the_watchdog->id = id;
40006374: c0 24 20 30 clr [ %l0 + 0x30 ]
the_watchdog->user_data = user_data;
40006378: c0 24 20 34 clr [ %l0 + 0x34 ]
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
4000637c: 40 00 21 ce call 4000eab4 <memset>
40006380: 90 04 20 54 add %l0, 0x54, %o0
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40006384: c4 04 20 08 ld [ %l0 + 8 ], %g2
40006388: 82 14 60 24 or %l1, 0x24, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
4000638c: e4 24 20 0c st %l2, [ %l0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
40006390: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
40006394: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
40006398: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
4000639c: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
400063a0: c2 24 20 5c st %g1, [ %l0 + 0x5c ]
400063a4: c2 24 20 60 st %g1, [ %l0 + 0x60 ]
400063a8: c2 24 20 74 st %g1, [ %l0 + 0x74 ]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
400063ac: c4 26 40 00 st %g2, [ %i1 ]
400063b0: 03 00 00 3f sethi %hi(0xfc00), %g1
400063b4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400063b8: 84 08 80 01 and %g2, %g1, %g2
400063bc: 85 28 a0 02 sll %g2, 2, %g2
_Thread_Enable_dispatch();
400063c0: b0 10 20 00 clr %i0
400063c4: 40 00 0b 9b call 40009230 <_Thread_Enable_dispatch>
400063c8: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
return RTEMS_SUCCESSFUL;
}
400063cc: 81 c7 e0 08 ret
400063d0: 81 e8 00 00 restore
4000ca18 <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
Objects_Id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
4000ca18: 9d e3 bf 90 save %sp, -112, %sp
4000ca1c: 92 10 00 18 mov %i0, %o1
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
4000ca20: 80 a6 60 00 cmp %i1, 0
4000ca24: 02 80 00 10 be 4000ca64 <rtems_rate_monotonic_get_statistics+0x4c><== NEVER TAKEN
4000ca28: b0 10 20 09 mov 9, %i0
4000ca2c: 11 10 00 72 sethi %hi(0x4001c800), %o0
4000ca30: 94 07 bf f4 add %fp, -12, %o2
4000ca34: 7f ff ef ac call 400088e4 <_Objects_Get>
4000ca38: 90 12 20 24 or %o0, 0x24, %o0
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
4000ca3c: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000ca40: 80 a0 60 00 cmp %g1, 0
4000ca44: 12 80 00 08 bne 4000ca64 <rtems_rate_monotonic_get_statistics+0x4c>
4000ca48: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*statistics = the_period->Statistics;
4000ca4c: 92 02 20 54 add %o0, 0x54, %o1
4000ca50: 94 10 20 38 mov 0x38, %o2
4000ca54: 40 00 07 df call 4000e9d0 <memcpy>
4000ca58: 90 10 00 19 mov %i1, %o0
_Thread_Enable_dispatch();
4000ca5c: 7f ff f1 f5 call 40009230 <_Thread_Enable_dispatch>
4000ca60: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000ca64: 81 c7 e0 08 ret
4000ca68: 81 e8 00 00 restore
4000ca6c <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
Objects_Id id,
rtems_rate_monotonic_period_status *status
)
{
4000ca6c: 9d e3 bf 88 save %sp, -120, %sp
4000ca70: 92 10 00 18 mov %i0, %o1
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
4000ca74: 80 a6 60 00 cmp %i1, 0
4000ca78: 02 80 00 28 be 4000cb18 <rtems_rate_monotonic_get_status+0xac><== NEVER TAKEN
4000ca7c: b0 10 20 09 mov 9, %i0
4000ca80: 11 10 00 72 sethi %hi(0x4001c800), %o0
4000ca84: 94 07 bf f4 add %fp, -12, %o2
4000ca88: 7f ff ef 97 call 400088e4 <_Objects_Get>
4000ca8c: 90 12 20 24 or %o0, 0x24, %o0
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
4000ca90: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000ca94: a2 10 00 08 mov %o0, %l1
4000ca98: 80 a0 60 00 cmp %g1, 0
4000ca9c: 12 80 00 1f bne 4000cb18 <rtems_rate_monotonic_get_status+0xac>
4000caa0: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
4000caa4: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
4000caa8: 80 a0 60 00 cmp %g1, 0
4000caac: 02 80 00 03 be 4000cab8 <rtems_rate_monotonic_get_status+0x4c><== NEVER TAKEN
4000cab0: 84 10 20 00 clr %g2
4000cab4: c4 00 60 08 ld [ %g1 + 8 ], %g2
status->state = the_period->state;
4000cab8: c2 04 60 38 ld [ %l1 + 0x38 ], %g1
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
4000cabc: c4 26 40 00 st %g2, [ %i1 ]
status->state = the_period->state;
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
4000cac0: 80 a0 60 00 cmp %g1, 0
4000cac4: 12 80 00 07 bne 4000cae0 <rtems_rate_monotonic_get_status+0x74>
4000cac8: c2 26 60 04 st %g1, [ %i1 + 4 ]
#else
status->since_last_period = 0;
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
status->executed_since_last_period.tv_sec = 0;
status->executed_since_last_period.tv_nsec = 0;
4000cacc: c0 26 60 14 clr [ %i1 + 0x14 ]
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
status->state = the_period->state;
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
status->since_last_period.tv_sec = 0;
4000cad0: c0 26 60 08 clr [ %i1 + 8 ]
status->since_last_period.tv_nsec = 0;
4000cad4: c0 26 60 0c clr [ %i1 + 0xc ]
#else
status->since_last_period = 0;
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
status->executed_since_last_period.tv_sec = 0;
4000cad8: 10 80 00 0e b 4000cb10 <rtems_rate_monotonic_get_status+0xa4>
4000cadc: c0 26 60 10 clr [ %i1 + 0x10 ]
* This lets them share one single invocation of _TOD_Get_uptime().
*/
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \
defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
struct timespec uptime;
_TOD_Get_uptime( &uptime );
4000cae0: a0 07 bf ec add %fp, -20, %l0
4000cae4: 7f ff ec dd call 40007e58 <_TOD_Get_uptime>
4000cae8: 90 10 00 10 mov %l0, %o0
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
_Timespec_Subtract(
4000caec: 90 04 60 44 add %l1, 0x44, %o0
4000caf0: 92 10 00 10 mov %l0, %o1
4000caf4: 7f ff f6 4d call 4000a428 <_Timespec_Subtract>
4000caf8: 94 06 60 08 add %i1, 8, %o2
status->since_last_period =
_Watchdog_Ticks_since_boot - the_period->time_at_period;
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
_Timespec_Subtract(
4000cafc: 11 10 00 72 sethi %hi(0x4001c800), %o0
4000cb00: 92 10 00 10 mov %l0, %o1
4000cb04: 94 06 60 10 add %i1, 0x10, %o2
4000cb08: 7f ff f6 48 call 4000a428 <_Timespec_Subtract>
4000cb0c: 90 12 22 68 or %o0, 0x268, %o0
the_period->owner->cpu_time_used -
the_period->owner_executed_at_period;
#endif
}
_Thread_Enable_dispatch();
4000cb10: 7f ff f1 c8 call 40009230 <_Thread_Enable_dispatch>
4000cb14: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000cb18: 81 c7 e0 08 ret
4000cb1c: 81 e8 00 00 restore
400065e0 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
Objects_Id id,
rtems_interval length
)
{
400065e0: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
400065e4: 11 10 00 72 sethi %hi(0x4001c800), %o0
400065e8: 92 10 00 18 mov %i0, %o1
400065ec: 90 12 20 24 or %o0, 0x24, %o0
400065f0: 40 00 08 bd call 400088e4 <_Objects_Get>
400065f4: 94 07 bf f4 add %fp, -12, %o2
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
400065f8: c2 07 bf f4 ld [ %fp + -12 ], %g1
400065fc: 80 a0 60 00 cmp %g1, 0
40006600: 12 80 00 64 bne 40006790 <rtems_rate_monotonic_period+0x1b0>
40006604: a2 10 00 08 mov %o0, %l1
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
40006608: 27 10 00 72 sethi %hi(0x4001c800), %l3
4000660c: c4 02 20 50 ld [ %o0 + 0x50 ], %g2
40006610: c2 04 e2 60 ld [ %l3 + 0x260 ], %g1
40006614: 80 a0 80 01 cmp %g2, %g1
40006618: 02 80 00 06 be 40006630 <rtems_rate_monotonic_period+0x50>
4000661c: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
40006620: 40 00 0b 04 call 40009230 <_Thread_Enable_dispatch>
40006624: b0 10 20 17 mov 0x17, %i0
40006628: 81 c7 e0 08 ret
4000662c: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
40006630: 12 80 00 0c bne 40006660 <rtems_rate_monotonic_period+0x80>
40006634: 01 00 00 00 nop
switch ( the_period->state ) {
40006638: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000663c: 80 a0 60 00 cmp %g1, 0
40006640: 02 80 00 50 be 40006780 <rtems_rate_monotonic_period+0x1a0>
40006644: b0 10 20 0b mov 0xb, %i0
40006648: 82 00 7f fd add %g1, -3, %g1
4000664c: 80 a0 60 01 cmp %g1, 1
40006650: 18 80 00 4c bgu 40006780 <rtems_rate_monotonic_period+0x1a0>
40006654: b0 10 20 00 clr %i0
the_period->state = RATE_MONOTONIC_ACTIVE;
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
40006658: 10 80 00 4a b 40006780 <rtems_rate_monotonic_period+0x1a0>
4000665c: b0 10 20 06 mov 6, %i0
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
40006660: 7f ff f1 59 call 40002bc4 <sparc_disable_interrupts>
40006664: 01 00 00 00 nop
40006668: a0 10 00 08 mov %o0, %l0
switch ( the_period->state ) {
4000666c: e4 04 60 38 ld [ %l1 + 0x38 ], %l2
40006670: 80 a4 a0 02 cmp %l2, 2
40006674: 02 80 00 1a be 400066dc <rtems_rate_monotonic_period+0xfc>
40006678: 80 a4 a0 04 cmp %l2, 4
4000667c: 02 80 00 34 be 4000674c <rtems_rate_monotonic_period+0x16c>
40006680: 80 a4 a0 00 cmp %l2, 0
40006684: 12 80 00 43 bne 40006790 <rtems_rate_monotonic_period+0x1b0><== NEVER TAKEN
40006688: 01 00 00 00 nop
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
4000668c: 7f ff f1 52 call 40002bd4 <sparc_enable_interrupts>
40006690: 01 00 00 00 nop
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
40006694: 7f ff ff 5e call 4000640c <_Rate_monotonic_Initiate_statistics>
40006698: 90 10 00 11 mov %l1, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
4000669c: 82 10 20 02 mov 2, %g1
400066a0: c2 24 60 38 st %g1, [ %l1 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400066a4: 03 10 00 1a sethi %hi(0x40006800), %g1
400066a8: 82 10 62 64 or %g1, 0x264, %g1 ! 40006a64 <_Rate_monotonic_Timeout>
the_watchdog->id = id;
400066ac: f0 24 60 30 st %i0, [ %l1 + 0x30 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400066b0: 92 04 60 10 add %l1, 0x10, %o1
400066b4: 11 10 00 72 sethi %hi(0x4001c800), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400066b8: f2 24 60 1c st %i1, [ %l1 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400066bc: 90 12 22 80 or %o0, 0x280, %o0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400066c0: c0 24 60 18 clr [ %l1 + 0x18 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
400066c4: c0 24 60 34 clr [ %l1 + 0x34 ]
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
400066c8: f2 24 60 4c st %i1, [ %l1 + 0x4c ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400066cc: c2 24 60 2c st %g1, [ %l1 + 0x2c ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400066d0: 40 00 10 14 call 4000a720 <_Watchdog_Insert>
400066d4: b0 10 20 00 clr %i0
400066d8: 30 80 00 2a b,a 40006780 <rtems_rate_monotonic_period+0x1a0>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
400066dc: 7f ff ff 68 call 4000647c <_Rate_monotonic_Update_statistics>
400066e0: 90 10 00 11 mov %l1, %o0
/*
* 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;
400066e4: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
400066e8: f2 24 60 4c st %i1, [ %l1 + 0x4c ]
/*
* 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;
400066ec: c2 24 60 38 st %g1, [ %l1 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
400066f0: 7f ff f1 39 call 40002bd4 <sparc_enable_interrupts>
400066f4: 90 10 00 10 mov %l0, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
400066f8: c2 04 e2 60 ld [ %l3 + 0x260 ], %g1
400066fc: c4 04 60 08 ld [ %l1 + 8 ], %g2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40006700: 90 10 00 01 mov %g1, %o0
the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
the_period->next_length = length;
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
40006704: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40006708: 40 00 0d 3d call 40009bfc <_Thread_Set_state>
4000670c: 13 00 00 10 sethi %hi(0x4000), %o1
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
40006710: 7f ff f1 2d call 40002bc4 <sparc_disable_interrupts>
40006714: 01 00 00 00 nop
local_state = the_period->state;
40006718: e0 04 60 38 ld [ %l1 + 0x38 ], %l0
the_period->state = RATE_MONOTONIC_ACTIVE;
4000671c: e4 24 60 38 st %l2, [ %l1 + 0x38 ]
_ISR_Enable( level );
40006720: 7f ff f1 2d call 40002bd4 <sparc_enable_interrupts>
40006724: 01 00 00 00 nop
/*
* 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 )
40006728: 80 a4 20 03 cmp %l0, 3
4000672c: 12 80 00 04 bne 4000673c <rtems_rate_monotonic_period+0x15c><== ALWAYS TAKEN
40006730: d0 04 e2 60 ld [ %l3 + 0x260 ], %o0
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
40006734: 40 00 09 c4 call 40008e44 <_Thread_Clear_state> <== NOT EXECUTED
40006738: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED
_Thread_Enable_dispatch();
4000673c: 40 00 0a bd call 40009230 <_Thread_Enable_dispatch>
40006740: b0 10 20 00 clr %i0
40006744: 81 c7 e0 08 ret
40006748: 81 e8 00 00 restore
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
4000674c: 7f ff ff 4c call 4000647c <_Rate_monotonic_Update_statistics>
40006750: 90 10 00 11 mov %l1, %o0
_ISR_Enable( level );
40006754: 7f ff f1 20 call 40002bd4 <sparc_enable_interrupts>
40006758: 90 10 00 10 mov %l0, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
4000675c: 82 10 20 02 mov 2, %g1
40006760: 11 10 00 72 sethi %hi(0x4001c800), %o0
40006764: 92 04 60 10 add %l1, 0x10, %o1
40006768: 90 12 22 80 or %o0, 0x280, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
4000676c: f2 24 60 1c st %i1, [ %l1 + 0x1c ]
the_period->next_length = length;
40006770: f2 24 60 4c st %i1, [ %l1 + 0x4c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
40006774: 40 00 0f eb call 4000a720 <_Watchdog_Insert>
40006778: c2 24 60 38 st %g1, [ %l1 + 0x38 ]
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
4000677c: b0 10 20 06 mov 6, %i0
40006780: 40 00 0a ac call 40009230 <_Thread_Enable_dispatch>
40006784: 01 00 00 00 nop
40006788: 81 c7 e0 08 ret
4000678c: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40006790: 81 c7 e0 08 ret
40006794: 91 e8 20 04 restore %g0, 4, %o0
40006798 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
40006798: 9d e3 bf 30 save %sp, -208, %sp
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
4000679c: 80 a6 60 00 cmp %i1, 0
400067a0: 02 80 00 7c be 40006990 <rtems_rate_monotonic_report_statistics_with_plugin+0x1f8><== NEVER TAKEN
400067a4: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
400067a8: 13 10 00 69 sethi %hi(0x4001a400), %o1
400067ac: 9f c6 40 00 call %i1
400067b0: 92 12 60 68 or %o1, 0x68, %o1 ! 4001a468 <rtems_status_assoc+0x1b8>
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
(*print)( context, "--- CPU times are in seconds ---\n" );
400067b4: 90 10 00 18 mov %i0, %o0
400067b8: 13 10 00 69 sethi %hi(0x4001a400), %o1
400067bc: 9f c6 40 00 call %i1
400067c0: 92 12 60 88 or %o1, 0x88, %o1 ! 4001a488 <rtems_status_assoc+0x1d8>
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
(*print)( context, "--- Wall times are in seconds ---\n" );
400067c4: 90 10 00 18 mov %i0, %o0
400067c8: 13 10 00 69 sethi %hi(0x4001a400), %o1
400067cc: 9f c6 40 00 call %i1
400067d0: 92 12 60 b0 or %o1, 0xb0, %o1 ! 4001a4b0 <rtems_status_assoc+0x200>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
400067d4: 90 10 00 18 mov %i0, %o0
400067d8: 13 10 00 69 sethi %hi(0x4001a400), %o1
400067dc: 9f c6 40 00 call %i1
400067e0: 92 12 60 d8 or %o1, 0xd8, %o1 ! 4001a4d8 <rtems_status_assoc+0x228>
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
400067e4: 90 10 00 18 mov %i0, %o0
400067e8: 13 10 00 69 sethi %hi(0x4001a400), %o1
400067ec: 9f c6 40 00 call %i1
400067f0: 92 12 61 28 or %o1, 0x128, %o1 ! 4001a528 <rtems_status_assoc+0x278>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
400067f4: 03 10 00 69 sethi %hi(0x4001a400), %g1
400067f8: b4 10 61 78 or %g1, 0x178, %i2 ! 4001a578 <rtems_status_assoc+0x2c8>
_Timespec_Divide_by_integer(
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
400067fc: 03 10 00 69 sethi %hi(0x4001a400), %g1
40006800: b6 10 61 90 or %g1, 0x190, %i3 ! 4001a590 <rtems_status_assoc+0x2e0>
_Timespec_Divide_by_integer(
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
40006804: 03 10 00 69 sethi %hi(0x4001a400), %g1
/*
* 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 ;
40006808: 05 10 00 72 sethi %hi(0x4001c800), %g2
_Timespec_Divide_by_integer(
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
4000680c: b8 10 61 b0 or %g1, 0x1b0, %i4
/*
* 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 ;
40006810: 84 10 a0 24 or %g2, 0x24, %g2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
40006814: 03 10 00 69 sethi %hi(0x4001a400), %g1
/*
* 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 ;
40006818: e4 00 a0 08 ld [ %g2 + 8 ], %l2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
4000681c: ba 10 60 a8 or %g1, 0xa8, %i5
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
if ( status != RTEMS_SUCCESSFUL )
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
40006820: ae 07 bf d0 add %fp, -48, %l7
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40006824: a8 07 bf f0 add %fp, -16, %l4
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
40006828: ac 07 bf b0 add %fp, -80, %l6
4000682c: a6 07 bf e8 add %fp, -24, %l3
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
40006830: 10 80 00 52 b 40006978 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e0>
40006834: aa 07 bf c8 add %fp, -56, %l5
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
40006838: 40 00 18 78 call 4000ca18 <rtems_rate_monotonic_get_statistics>
4000683c: 92 07 bf 98 add %fp, -104, %o1
if ( status != RTEMS_SUCCESSFUL )
40006840: 80 a2 20 00 cmp %o0, 0
40006844: 32 80 00 4d bne,a 40006978 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e0>
40006848: a4 04 a0 01 inc %l2
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
4000684c: 92 10 00 17 mov %l7, %o1
40006850: 40 00 18 87 call 4000ca6c <rtems_rate_monotonic_get_status>
40006854: 90 10 00 12 mov %l2, %o0
continue;
#endif
name[ 0 ] = '\0';
if ( the_status.owner ) {
40006858: d0 07 bf d0 ld [ %fp + -48 ], %o0
4000685c: 80 a2 20 00 cmp %o0, 0
40006860: 02 80 00 05 be 40006874 <rtems_rate_monotonic_report_statistics_with_plugin+0xdc><== NEVER TAKEN
40006864: c0 2f bf f0 clrb [ %fp + -16 ]
rtems_object_get_name( the_status.owner, sizeof(name), name );
40006868: 94 10 00 14 mov %l4, %o2
4000686c: 40 00 00 ae call 40006b24 <rtems_object_get_name>
40006870: 92 10 20 05 mov 5, %o1
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
40006874: d8 1f bf 98 ldd [ %fp + -104 ], %o4
40006878: 94 10 00 12 mov %l2, %o2
4000687c: 92 10 00 1a mov %i2, %o1
40006880: 96 10 00 14 mov %l4, %o3
40006884: 9f c6 40 00 call %i1
40006888: 90 10 00 18 mov %i0, %o0
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
4000688c: c2 07 bf 98 ld [ %fp + -104 ], %g1
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
40006890: 94 10 00 13 mov %l3, %o2
40006894: 90 10 00 16 mov %l6, %o0
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
40006898: 80 a0 60 00 cmp %g1, 0
4000689c: 12 80 00 06 bne 400068b4 <rtems_rate_monotonic_report_statistics_with_plugin+0x11c>
400068a0: 92 10 00 1d mov %i5, %o1
(*print)( context, "\n" );
400068a4: 9f c6 40 00 call %i1
400068a8: 90 10 00 18 mov %i0, %o0
* 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 ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
400068ac: 10 80 00 33 b 40006978 <rtems_rate_monotonic_report_statistics_with_plugin+0x1e0>
400068b0: a4 04 a0 01 inc %l2
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
400068b4: 40 00 0e 76 call 4000a28c <_Timespec_Divide_by_integer>
400068b8: 92 10 00 01 mov %g1, %o1
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
400068bc: d0 07 bf a4 ld [ %fp + -92 ], %o0
400068c0: 40 00 40 99 call 40016b24 <.div>
400068c4: 92 10 23 e8 mov 0x3e8, %o1
400068c8: a2 10 00 08 mov %o0, %l1
400068cc: d0 07 bf ac ld [ %fp + -84 ], %o0
400068d0: 40 00 40 95 call 40016b24 <.div>
400068d4: 92 10 23 e8 mov 0x3e8, %o1
400068d8: c2 07 bf e8 ld [ %fp + -24 ], %g1
400068dc: a0 10 00 08 mov %o0, %l0
400068e0: d0 07 bf ec ld [ %fp + -20 ], %o0
400068e4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400068e8: 40 00 40 8f call 40016b24 <.div>
400068ec: 92 10 23 e8 mov 0x3e8, %o1
400068f0: d8 07 bf a8 ld [ %fp + -88 ], %o4
400068f4: d4 07 bf a0 ld [ %fp + -96 ], %o2
400068f8: 96 10 00 11 mov %l1, %o3
400068fc: 9a 10 00 10 mov %l0, %o5
40006900: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40006904: 92 10 00 1b mov %i3, %o1
40006908: 9f c6 40 00 call %i1
4000690c: 90 10 00 18 mov %i0, %o0
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
40006910: d2 07 bf 98 ld [ %fp + -104 ], %o1
40006914: 94 10 00 13 mov %l3, %o2
40006918: 40 00 0e 5d call 4000a28c <_Timespec_Divide_by_integer>
4000691c: 90 10 00 15 mov %l5, %o0
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
40006920: d0 07 bf bc ld [ %fp + -68 ], %o0
40006924: 40 00 40 80 call 40016b24 <.div>
40006928: 92 10 23 e8 mov 0x3e8, %o1
4000692c: a2 10 00 08 mov %o0, %l1
40006930: d0 07 bf c4 ld [ %fp + -60 ], %o0
40006934: 40 00 40 7c call 40016b24 <.div>
40006938: 92 10 23 e8 mov 0x3e8, %o1
4000693c: c2 07 bf e8 ld [ %fp + -24 ], %g1
40006940: a0 10 00 08 mov %o0, %l0
40006944: d0 07 bf ec ld [ %fp + -20 ], %o0
40006948: 92 10 23 e8 mov 0x3e8, %o1
4000694c: 40 00 40 76 call 40016b24 <.div>
40006950: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40006954: d4 07 bf b8 ld [ %fp + -72 ], %o2
40006958: d8 07 bf c0 ld [ %fp + -64 ], %o4
4000695c: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
40006960: 96 10 00 11 mov %l1, %o3
40006964: 9a 10 00 10 mov %l0, %o5
40006968: 90 10 00 18 mov %i0, %o0
4000696c: 9f c6 40 00 call %i1
40006970: 92 10 00 1c mov %i4, %o1
* 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 ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
40006974: a4 04 a0 01 inc %l2
/*
* 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 ;
id <= _Rate_monotonic_Information.maximum_id ;
40006978: 05 10 00 72 sethi %hi(0x4001c800), %g2
4000697c: 84 10 a0 24 or %g2, 0x24, %g2 ! 4001c824 <_Rate_monotonic_Information>
40006980: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
40006984: 80 a4 80 01 cmp %l2, %g1
40006988: 08 bf ff ac bleu 40006838 <rtems_rate_monotonic_report_statistics_with_plugin+0xa0>
4000698c: 90 10 00 12 mov %l2, %o0
40006990: 81 c7 e0 08 ret
40006994: 81 e8 00 00 restore
4000ff78 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
Objects_Id id,
void *starting_address,
uint32_t length
)
{
4000ff78: 9d e3 bf 90 save %sp, -112, %sp
4000ff7c: a0 10 00 18 mov %i0, %l0
Heap_Extend_status heap_status;
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Region_Control *the_region;
if ( !starting_address )
4000ff80: 80 a6 60 00 cmp %i1, 0
4000ff84: 02 80 00 2c be 40010034 <rtems_region_extend+0xbc> <== NEVER TAKEN
4000ff88: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
4000ff8c: 03 10 00 c6 sethi %hi(0x40031800), %g1
4000ff90: 40 00 08 f4 call 40012360 <_API_Mutex_Lock>
4000ff94: d0 00 62 e8 ld [ %g1 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
4000ff98: 92 10 00 10 mov %l0, %o1
4000ff9c: 11 10 00 c6 sethi %hi(0x40031800), %o0
4000ffa0: 94 07 bf f0 add %fp, -16, %o2
4000ffa4: 40 00 0f ad call 40013e58 <_Objects_Get_no_protection>
4000ffa8: 90 12 20 6c or %o0, 0x6c, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
4000ffac: c2 07 bf f0 ld [ %fp + -16 ], %g1
4000ffb0: 80 a0 60 00 cmp %g1, 0
4000ffb4: 02 80 00 05 be 4000ffc8 <rtems_region_extend+0x50>
4000ffb8: a0 10 00 08 mov %o0, %l0
4000ffbc: 80 a0 60 01 cmp %g1, 1
4000ffc0: 10 80 00 0f b 4000fffc <rtems_region_extend+0x84>
4000ffc4: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
heap_status = _Heap_Extend(
4000ffc8: 92 10 00 19 mov %i1, %o1
4000ffcc: 94 10 00 1a mov %i2, %o2
4000ffd0: 90 02 20 68 add %o0, 0x68, %o0
4000ffd4: 96 07 bf f4 add %fp, -12, %o3
4000ffd8: 40 00 0b e3 call 40012f64 <_Heap_Extend>
4000ffdc: b0 10 20 09 mov 9, %i0
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
4000ffe0: 80 a2 20 01 cmp %o0, 1
4000ffe4: 02 80 00 12 be 4001002c <rtems_region_extend+0xb4>
4000ffe8: 03 10 00 c6 sethi %hi(0x40031800), %g1
4000ffec: 0a 80 00 08 bcs 4001000c <rtems_region_extend+0x94>
4000fff0: c6 07 bf f4 ld [ %fp + -12 ], %g3
4000fff4: 80 a2 20 02 cmp %o0, 2
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
4000fff8: b0 10 20 18 mov 0x18, %i0
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
4000fffc: 32 80 00 0b bne,a 40010028 <rtems_region_extend+0xb0> <== NEVER TAKEN
40010000: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
40010004: 10 80 00 0a b 4001002c <rtems_region_extend+0xb4>
40010008: 03 10 00 c6 sethi %hi(0x40031800), %g1
&amount_extended
);
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
4001000c: c4 04 20 54 ld [ %l0 + 0x54 ], %g2
the_region->maximum_segment_size += amount_extended;
40010010: c2 04 20 5c ld [ %l0 + 0x5c ], %g1
&amount_extended
);
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
40010014: 84 00 80 03 add %g2, %g3, %g2
the_region->maximum_segment_size += amount_extended;
40010018: 82 00 40 03 add %g1, %g3, %g1
&amount_extended
);
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
4001001c: c4 24 20 54 st %g2, [ %l0 + 0x54 ]
the_region->maximum_segment_size += amount_extended;
40010020: c2 24 20 5c st %g1, [ %l0 + 0x5c ]
40010024: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
40010028: 03 10 00 c6 sethi %hi(0x40031800), %g1
4001002c: 40 00 08 e3 call 400123b8 <_API_Mutex_Unlock>
40010030: d0 00 62 e8 ld [ %g1 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
return return_status;
}
40010034: 81 c7 e0 08 ret
40010038: 81 e8 00 00 restore
40010148 <rtems_region_get_segment>:
uint32_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
40010148: 9d e3 bf 90 save %sp, -112, %sp
4001014c: a6 10 00 18 mov %i0, %l3
Objects_Locations location;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
register Region_Control *the_region;
void *the_segment;
if ( !segment )
40010150: 80 a7 20 00 cmp %i4, 0
40010154: 02 80 00 41 be 40010258 <rtems_region_get_segment+0x110> <== NEVER TAKEN
40010158: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
4001015c: c0 27 00 00 clr [ %i4 ]
if ( size == 0 )
40010160: 80 a6 60 00 cmp %i1, 0
40010164: 02 80 00 3d be 40010258 <rtems_region_get_segment+0x110> <== NEVER TAKEN
40010168: b0 10 20 08 mov 8, %i0
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
4001016c: 25 10 00 c6 sethi %hi(0x40031800), %l2
40010170: 40 00 08 7c call 40012360 <_API_Mutex_Lock>
40010174: d0 04 a2 e8 ld [ %l2 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
executing = _Thread_Executing;
40010178: 03 10 00 c6 sethi %hi(0x40031800), %g1
4001017c: 92 10 00 13 mov %l3, %o1
40010180: e2 00 62 f0 ld [ %g1 + 0x2f0 ], %l1
40010184: 11 10 00 c6 sethi %hi(0x40031800), %o0
40010188: 94 07 bf f4 add %fp, -12, %o2
4001018c: 40 00 0f 33 call 40013e58 <_Objects_Get_no_protection>
40010190: 90 12 20 6c or %o0, 0x6c, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
40010194: c2 07 bf f4 ld [ %fp + -12 ], %g1
40010198: 80 a0 60 00 cmp %g1, 0
4001019c: 02 80 00 08 be 400101bc <rtems_region_get_segment+0x74>
400101a0: a0 10 00 08 mov %o0, %l0
400101a4: 82 18 60 01 xor %g1, 1, %g1
400101a8: 80 a0 00 01 cmp %g0, %g1
400101ac: 82 40 3f ff addx %g0, -1, %g1
400101b0: b0 08 7f eb and %g1, -21, %i0
400101b4: 10 80 00 2b b 40010260 <rtems_region_get_segment+0x118>
400101b8: b0 06 20 19 add %i0, 0x19, %i0
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
400101bc: c2 02 20 5c ld [ %o0 + 0x5c ], %g1
400101c0: 80 a6 40 01 cmp %i1, %g1
400101c4: 18 80 00 27 bgu 40010260 <rtems_region_get_segment+0x118>
400101c8: b0 10 20 08 mov 8, %i0
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
Region_Control *the_region,
uint32_t size
)
{
return _Heap_Allocate( &the_region->Memory, size );
400101cc: 90 02 20 68 add %o0, 0x68, %o0
400101d0: 40 00 0b 3e call 40012ec8 <_Heap_Allocate>
400101d4: 92 10 00 19 mov %i1, %o1
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
400101d8: 80 a2 20 00 cmp %o0, 0
400101dc: 02 80 00 07 be 400101f8 <rtems_region_get_segment+0xb0>
400101e0: b0 10 20 00 clr %i0
the_region->number_of_used_blocks += 1;
400101e4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1
*segment = the_segment;
400101e8: d0 27 00 00 st %o0, [ %i4 ]
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
the_region->number_of_used_blocks += 1;
400101ec: 82 00 60 01 inc %g1
400101f0: 10 80 00 1c b 40010260 <rtems_region_get_segment+0x118>
400101f4: c2 24 20 64 st %g1, [ %l0 + 0x64 ]
*segment = the_segment;
return_status = RTEMS_SUCCESSFUL;
}
else if ( _Options_Is_no_wait( option_set ) ) {
400101f8: 80 8e a0 01 btst 1, %i2
400101fc: 12 80 00 19 bne 40010260 <rtems_region_get_segment+0x118>
40010200: b0 10 20 0d mov 0xd, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40010204: 05 10 00 c6 sethi %hi(0x40031800), %g2
40010208: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
4001020c: 82 00 60 01 inc %g1
40010210: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
* Switch from using the memory allocation mutex to using a
* dispatching disabled critical section. We have to do this
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
40010214: 40 00 08 69 call 400123b8 <_API_Mutex_Unlock>
40010218: d0 04 a2 e8 ld [ %l2 + 0x2e8 ], %o0
executing->Wait.queue = &the_region->Wait_queue;
4001021c: 82 04 20 10 add %l0, 0x10, %g1
executing->Wait.count = size;
executing->Wait.return_argument = segment;
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
40010220: 92 10 00 1b mov %i3, %o1
40010224: 90 10 00 01 mov %g1, %o0
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
executing->Wait.queue = &the_region->Wait_queue;
40010228: c2 24 60 44 st %g1, [ %l1 + 0x44 ]
executing->Wait.count = size;
executing->Wait.return_argument = segment;
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
4001022c: 15 10 00 54 sethi %hi(0x40015000), %o2
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;
40010230: 82 10 20 01 mov 1, %g1
40010234: 94 12 a0 b8 or %o2, 0xb8, %o2
40010238: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
executing->Wait.queue = &the_region->Wait_queue;
executing->Wait.id = id;
4001023c: e6 24 60 20 st %l3, [ %l1 + 0x20 ]
executing->Wait.count = size;
40010240: f2 24 60 24 st %i1, [ %l1 + 0x24 ]
executing->Wait.return_argument = segment;
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
40010244: 40 00 12 aa call 40014cec <_Thread_queue_Enqueue_with_handler>
40010248: f8 24 60 28 st %i4, [ %l1 + 0x28 ]
_Thread_Enable_dispatch();
4001024c: 40 00 11 68 call 400147ec <_Thread_Enable_dispatch>
40010250: 01 00 00 00 nop
return (rtems_status_code) executing->Wait.return_code;
40010254: f0 04 60 34 ld [ %l1 + 0x34 ], %i0
40010258: 81 c7 e0 08 ret
4001025c: 81 e8 00 00 restore
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
40010260: 03 10 00 c6 sethi %hi(0x40031800), %g1
40010264: 40 00 08 55 call 400123b8 <_API_Mutex_Unlock>
40010268: d0 00 62 e8 ld [ %g1 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
return return_status;
}
4001026c: 81 c7 e0 08 ret
40010270: 81 e8 00 00 restore
40010340 <rtems_region_resize_segment>:
Objects_Id id,
void *segment,
size_t size,
size_t *old_size
)
{
40010340: 9d e3 bf 88 save %sp, -120, %sp
uint32_t osize;
rtems_status_code return_status = RTEMS_INTERNAL_ERROR;
Heap_Resize_status status;
register Region_Control *the_region;
if ( !old_size )
40010344: 80 a6 e0 00 cmp %i3, 0
40010348: 02 80 00 32 be 40010410 <rtems_region_resize_segment+0xd0>
4001034c: 21 10 00 c6 sethi %hi(0x40031800), %l0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
40010350: 40 00 08 04 call 40012360 <_API_Mutex_Lock>
40010354: d0 04 22 e8 ld [ %l0 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
40010358: 92 10 00 18 mov %i0, %o1
4001035c: 11 10 00 c6 sethi %hi(0x40031800), %o0
40010360: 94 07 bf f0 add %fp, -16, %o2
40010364: 40 00 0e bd call 40013e58 <_Objects_Get_no_protection>
40010368: 90 12 20 6c or %o0, 0x6c, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
4001036c: c2 07 bf f0 ld [ %fp + -16 ], %g1
40010370: 80 a0 60 00 cmp %g1, 0
40010374: 02 80 00 0b be 400103a0 <rtems_region_resize_segment+0x60>
40010378: b0 10 00 08 mov %o0, %i0
4001037c: 82 18 60 01 xor %g1, 1, %g1
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
40010380: d0 04 22 e8 ld [ %l0 + 0x2e8 ], %o0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
40010384: 80 a0 00 01 cmp %g0, %g1
40010388: 82 40 3f ff addx %g0, -1, %g1
4001038c: b0 08 7f eb and %g1, -21, %i0
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
40010390: 40 00 08 0a call 400123b8 <_API_Mutex_Unlock>
40010394: b0 06 20 19 add %i0, 0x19, %i0
40010398: 81 c7 e0 08 ret
4001039c: 81 e8 00 00 restore
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
400103a0: 94 10 00 1a mov %i2, %o2
400103a4: 92 10 00 19 mov %i1, %o1
400103a8: 90 02 20 68 add %o0, 0x68, %o0
400103ac: 96 07 bf ec add %fp, -20, %o3
400103b0: 40 00 0c 6d call 40013564 <_Heap_Resize_block>
400103b4: 98 07 bf f4 add %fp, -12, %o4
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
400103b8: c2 07 bf ec ld [ %fp + -20 ], %g1
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
400103bc: b4 92 20 00 orcc %o0, 0, %i2
400103c0: 12 80 00 0b bne 400103ec <rtems_region_resize_segment+0xac><== ALWAYS TAKEN
400103c4: c2 26 c0 00 st %g1, [ %i3 ]
400103c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
400103cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400103d0: 02 80 00 08 be 400103f0 <rtems_region_resize_segment+0xb0><== NOT EXECUTED
400103d4: 03 10 00 c6 sethi %hi(0x40031800), %g1 <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
400103d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400103dc: 40 00 1f 81 call 400181e0 <_Region_Process_queue> <== NOT EXECUTED
400103e0: b0 10 20 00 clr %i0 <== NOT EXECUTED
400103e4: 81 c7 e0 08 ret <== NOT EXECUTED
400103e8: 81 e8 00 00 restore <== NOT EXECUTED
else
_RTEMS_Unlock_allocator();
400103ec: 03 10 00 c6 sethi %hi(0x40031800), %g1
400103f0: d0 00 62 e8 ld [ %g1 + 0x2e8 ], %o0 ! 40031ae8 <_RTEMS_Allocator_Mutex>
400103f4: 40 00 07 f1 call 400123b8 <_API_Mutex_Unlock>
400103f8: b0 10 20 00 clr %i0
return
400103fc: 80 a6 a0 00 cmp %i2, 0
40010400: 02 bf ff e6 be 40010398 <rtems_region_resize_segment+0x58><== NEVER TAKEN
40010404: 80 a6 a0 01 cmp %i2, 1
40010408: 02 bf ff e4 be 40010398 <rtems_region_resize_segment+0x58><== NEVER TAKEN
4001040c: b0 10 20 0d mov 0xd, %i0
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
return return_status;
40010410: b0 10 20 09 mov 9, %i0
}
40010414: 81 c7 e0 08 ret
40010418: 81 e8 00 00 restore
40005150 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
40005150: 9d e3 bf 80 save %sp, -128, %sp
register Semaphore_Control *the_semaphore;
CORE_mutex_Attributes the_mutex_attributes;
CORE_semaphore_Attributes the_semaphore_attributes;
if ( !rtems_is_name_valid( name ) )
40005154: a4 96 20 00 orcc %i0, 0, %l2
40005158: 02 80 00 23 be 400051e4 <rtems_semaphore_create+0x94>
4000515c: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
40005160: 80 a7 20 00 cmp %i4, 0
40005164: 02 80 00 20 be 400051e4 <rtems_semaphore_create+0x94> <== NEVER TAKEN
40005168: b0 10 20 09 mov 9, %i0
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
4000516c: 84 8e a0 c0 andcc %i2, 0xc0, %g2
40005170: 02 80 00 0d be 400051a4 <rtems_semaphore_create+0x54>
40005174: a2 8e a0 30 andcc %i2, 0x30, %l1
*/
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
rtems_attribute attribute_set
)
{
return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
40005178: 82 0e a0 30 and %i2, 0x30, %g1
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
4000517c: 80 a0 60 10 cmp %g1, 0x10
40005180: 02 80 00 04 be 40005190 <rtems_semaphore_create+0x40>
40005184: 80 a0 60 20 cmp %g1, 0x20
40005188: 32 80 00 17 bne,a 400051e4 <rtems_semaphore_create+0x94>
4000518c: b0 10 20 0b mov 0xb, %i0
40005190: 80 8e a0 04 btst 4, %i2
40005194: 02 80 00 64 be 40005324 <rtems_semaphore_create+0x1d4>
40005198: 80 a0 a0 c0 cmp %g2, 0xc0
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
4000519c: 02 80 00 62 be 40005324 <rtems_semaphore_create+0x1d4>
400051a0: a2 8e a0 30 andcc %i2, 0x30, %l1
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
400051a4: 02 80 00 04 be 400051b4 <rtems_semaphore_create+0x64>
400051a8: 80 a6 60 01 cmp %i1, 1
400051ac: 18 80 00 0e bgu 400051e4 <rtems_semaphore_create+0x94>
400051b0: b0 10 20 0a mov 0xa, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
400051b4: 03 10 00 5f sethi %hi(0x40017c00), %g1
400051b8: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 40017ed0 <_Thread_Dispatch_disable_level>
400051bc: 84 00 a0 01 inc %g2
400051c0: c4 20 62 d0 st %g2, [ %g1 + 0x2d0 ]
* 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 );
400051c4: 11 10 00 5f sethi %hi(0x40017c00), %o0
400051c8: 40 00 05 30 call 40006688 <_Objects_Allocate>
400051cc: 90 12 21 94 or %o0, 0x194, %o0 ! 40017d94 <_Semaphore_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
400051d0: a0 92 20 00 orcc %o0, 0, %l0
400051d4: 12 80 00 06 bne 400051ec <rtems_semaphore_create+0x9c>
400051d8: 80 a4 60 00 cmp %l1, 0
_Thread_Enable_dispatch();
400051dc: 40 00 08 d8 call 4000753c <_Thread_Enable_dispatch>
400051e0: b0 10 20 05 mov 5, %i0
400051e4: 81 c7 e0 08 ret
400051e8: 81 e8 00 00 restore
* If it is not a counting semaphore, then it is either a
* simple binary semaphore or a more powerful mutex style binary
* semaphore.
*/
if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
400051ec: 02 80 00 33 be 400052b8 <rtems_semaphore_create+0x168>
400051f0: f4 24 20 10 st %i2, [ %l0 + 0x10 ]
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
400051f4: 80 8e a0 40 btst 0x40, %i2
400051f8: 12 80 00 06 bne 40005210 <rtems_semaphore_create+0xc0>
400051fc: 82 10 20 02 mov 2, %g1
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
40005200: 80 8e a0 80 btst 0x80, %i2
40005204: 02 80 00 05 be 40005218 <rtems_semaphore_create+0xc8>
40005208: 80 8e a0 04 btst 4, %i2
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
4000520c: 82 10 20 03 mov 3, %g1
40005210: 10 80 00 05 b 40005224 <rtems_semaphore_create+0xd4>
40005214: c2 27 bf e8 st %g1, [ %fp + -24 ]
else if ( _Attributes_Is_priority( attribute_set ) )
40005218: 12 bf ff fe bne 40005210 <rtems_semaphore_create+0xc0>
4000521c: 82 10 20 01 mov 1, %g1
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
40005220: c0 27 bf e8 clr [ %fp + -24 ]
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
40005224: 80 a4 60 10 cmp %l1, 0x10
40005228: 12 80 00 0f bne 40005264 <rtems_semaphore_create+0x114>
4000522c: 82 10 20 02 mov 2, %g1
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
switch ( the_mutex_attributes.discipline ) {
40005230: c2 07 bf e8 ld [ %fp + -24 ], %g1
40005234: 80 a0 60 01 cmp %g1, 1
40005238: 08 80 00 07 bleu 40005254 <rtems_semaphore_create+0x104>
4000523c: c0 27 bf e0 clr [ %fp + -32 ]
40005240: 80 a0 60 03 cmp %g1, 3
40005244: 38 80 00 0b bgu,a 40005270 <rtems_semaphore_create+0x120><== NEVER TAKEN
40005248: 82 1e 60 01 xor %i1, 1, %g1 <== NOT EXECUTED
case CORE_MUTEX_DISCIPLINES_PRIORITY:
the_mutex_attributes.only_owner_release = FALSE;
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
4000524c: 10 80 00 04 b 4000525c <rtems_semaphore_create+0x10c>
40005250: 82 10 20 01 mov 1, %g1
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
switch ( the_mutex_attributes.discipline ) {
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
the_mutex_attributes.only_owner_release = FALSE;
40005254: 10 80 00 06 b 4000526c <rtems_semaphore_create+0x11c>
40005258: c0 2f bf e4 clrb [ %fp + -28 ]
break;
case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING:
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
4000525c: 10 80 00 04 b 4000526c <rtems_semaphore_create+0x11c>
40005260: c2 2f bf e4 stb %g1, [ %fp + -28 ]
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attributes.only_owner_release = FALSE;
40005264: c0 2f bf e4 clrb [ %fp + -28 ]
case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT:
the_mutex_attributes.only_owner_release = TRUE;
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
40005268: c2 27 bf e0 st %g1, [ %fp + -32 ]
the_mutex_attributes.only_owner_release = FALSE;
}
the_mutex_attributes.priority_ceiling = priority_ceiling;
mutex_status = _CORE_mutex_Initialize(
4000526c: 82 1e 60 01 xor %i1, 1, %g1
40005270: 80 a0 00 01 cmp %g0, %g1
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attributes.only_owner_release = FALSE;
}
the_mutex_attributes.priority_ceiling = priority_ceiling;
40005274: f6 27 bf ec st %i3, [ %fp + -20 ]
mutex_status = _CORE_mutex_Initialize(
40005278: 94 60 3f ff subx %g0, -1, %o2
4000527c: 90 04 20 14 add %l0, 0x14, %o0
40005280: 40 00 03 03 call 40005e8c <_CORE_mutex_Initialize>
40005284: 92 07 bf e0 add %fp, -32, %o1
&the_semaphore->Core_control.mutex,
&the_mutex_attributes,
(count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED
);
if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) {
40005288: 80 a2 20 06 cmp %o0, 6
4000528c: 32 80 00 19 bne,a 400052f0 <rtems_semaphore_create+0x1a0><== ALWAYS TAKEN
40005290: c4 04 20 08 ld [ %l0 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
40005294: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40005298: 11 10 00 5f sethi %hi(0x40017c00), %o0 <== NOT EXECUTED
4000529c: 90 12 21 94 or %o0, 0x194, %o0 ! 40017d94 <_Semaphore_Information><== NOT EXECUTED
400052a0: 40 00 05 e7 call 40006a3c <_Objects_Free> <== NOT EXECUTED
400052a4: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
400052a8: 40 00 08 a5 call 4000753c <_Thread_Enable_dispatch> <== NOT EXECUTED
400052ac: 01 00 00 00 nop <== NOT EXECUTED
400052b0: 81 c7 e0 08 ret <== NOT EXECUTED
400052b4: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INVALID_PRIORITY;
}
} else {
if ( _Attributes_Is_priority( attribute_set ) )
400052b8: 80 8e a0 04 btst 4, %i2
400052bc: 22 80 00 04 be,a 400052cc <rtems_semaphore_create+0x17c>
400052c0: c0 27 bf f4 clr [ %fp + -12 ]
the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
400052c4: 82 10 20 01 mov 1, %g1
400052c8: c2 27 bf f4 st %g1, [ %fp + -12 ]
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
400052cc: 82 10 3f ff mov -1, %g1
/*
* The following are just to make Purify happy.
*/
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
400052d0: c0 27 bf e0 clr [ %fp + -32 ]
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
400052d4: c0 27 bf ec clr [ %fp + -20 ]
_CORE_semaphore_Initialize(
400052d8: 94 10 00 19 mov %i1, %o2
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
400052dc: c2 27 bf f0 st %g1, [ %fp + -16 ]
*/
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
_CORE_semaphore_Initialize(
400052e0: 90 04 20 14 add %l0, 0x14, %o0
400052e4: 40 00 03 c1 call 400061e8 <_CORE_semaphore_Initialize>
400052e8: 92 07 bf f0 add %fp, -16, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400052ec: c4 04 20 08 ld [ %l0 + 8 ], %g2
400052f0: 03 10 00 5f sethi %hi(0x40017c00), %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
400052f4: e4 24 20 0c st %l2, [ %l0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400052f8: c6 00 61 b0 ld [ %g1 + 0x1b0 ], %g3
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
400052fc: c4 27 00 00 st %g2, [ %i4 ]
40005300: 03 00 00 3f sethi %hi(0xfc00), %g1
40005304: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
40005308: 84 08 80 01 and %g2, %g1, %g2
4000530c: 85 28 a0 02 sll %g2, 2, %g2
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
40005310: b0 10 20 00 clr %i0
40005314: 40 00 08 8a call 4000753c <_Thread_Enable_dispatch>
40005318: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
4000531c: 81 c7 e0 08 ret
40005320: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
40005324: b0 10 20 0b mov 0xb, %i0
}
40005328: 81 c7 e0 08 ret
4000532c: 81 e8 00 00 restore
40010750 <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
40010750: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
40010754: 11 10 00 c6 sethi %hi(0x40031800), %o0
40010758: 92 10 00 18 mov %i0, %o1
4001075c: 90 12 20 ac or %o0, 0xac, %o0
40010760: 40 00 0d d0 call 40013ea0 <_Objects_Get>
40010764: 94 07 bf f4 add %fp, -12, %o2
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
40010768: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001076c: 80 a0 60 00 cmp %g1, 0
40010770: 12 80 00 0f bne 400107ac <rtems_semaphore_flush+0x5c>
40010774: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
40010778: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4001077c: 80 88 60 30 btst 0x30, %g1
40010780: 02 80 00 06 be 40010798 <rtems_semaphore_flush+0x48> <== NEVER TAKEN
40010784: 90 02 20 14 add %o0, 0x14, %o0
_CORE_mutex_Flush(
40010788: 92 10 20 00 clr %o1
4001078c: 40 00 08 4c call 400128bc <_CORE_mutex_Flush>
40010790: 94 10 20 01 mov 1, %o2
40010794: 30 80 00 04 b,a 400107a4 <rtems_semaphore_flush+0x54>
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
40010798: 92 10 20 00 clr %o1 <== NOT EXECUTED
4001079c: 40 00 09 1f call 40012c18 <_CORE_semaphore_Flush> <== NOT EXECUTED
400107a0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
&the_semaphore->Core_control.semaphore,
SEND_OBJECT_WAS_DELETED,
CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT
);
}
_Thread_Enable_dispatch();
400107a4: 40 00 10 12 call 400147ec <_Thread_Enable_dispatch>
400107a8: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400107ac: 81 c7 e0 08 ret
400107b0: 81 e8 00 00 restore
40015710 <rtems_shutdown_executive>:
*/
void rtems_shutdown_executive(
uint32_t result
)
{
40015710: 9d e3 bf 10 save %sp, -240, %sp
if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
40015714: 05 10 00 60 sethi %hi(0x40018000), %g2
40015718: c2 00 a0 74 ld [ %g2 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
4001571c: 80 a0 60 04 cmp %g1, 4
40015720: 02 80 00 07 be 4001573c <rtems_shutdown_executive+0x2c> <== NEVER TAKEN
40015724: 82 10 20 04 mov 4, %g1
Context_Control *context_p = &context_area;
if ( _System_state_Is_up(_System_state_Get ()) )
context_p = &_Thread_Executing->Registers;
_Context_Switch( context_p, &_Thread_BSP_context );
40015728: 13 10 00 5f sethi %hi(0x40017c00), %o1
4001572c: c2 20 a0 74 st %g1, [ %g2 + 0x74 ]
40015730: 92 12 62 48 or %o1, 0x248, %o1
40015734: 7f ff cc c4 call 40008a44 <_CPU_Context_switch>
40015738: 90 07 bf 70 add %fp, -144, %o0
4001573c: 81 c7 e0 08 ret <== NOT EXECUTED
40015740: 81 e8 00 00 restore <== NOT EXECUTED
400109b4 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
Objects_Id id,
rtems_signal_set signal_set
)
{
400109b4: 9d e3 bf 90 save %sp, -112, %sp
400109b8: 90 10 00 18 mov %i0, %o0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
400109bc: 80 a6 60 00 cmp %i1, 0
400109c0: 02 80 00 2f be 40010a7c <rtems_signal_send+0xc8> <== NEVER TAKEN
400109c4: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
400109c8: 40 00 0f 96 call 40014820 <_Thread_Get>
400109cc: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
400109d0: c2 07 bf f4 ld [ %fp + -12 ], %g1
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
400109d4: a0 10 00 08 mov %o0, %l0
switch ( location ) {
400109d8: 80 a0 60 00 cmp %g1, 0
400109dc: 12 80 00 28 bne 40010a7c <rtems_signal_send+0xc8>
400109e0: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
400109e4: f0 02 21 5c ld [ %o0 + 0x15c ], %i0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
400109e8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400109ec: 80 a0 60 00 cmp %g1, 0
400109f0: 02 80 00 25 be 40010a84 <rtems_signal_send+0xd0>
400109f4: 01 00 00 00 nop
if ( asr->is_enabled ) {
400109f8: c2 0e 20 08 ldub [ %i0 + 8 ], %g1
400109fc: 80 a0 60 00 cmp %g1, 0
40010a00: 02 80 00 16 be 40010a58 <rtems_signal_send+0xa4>
40010a04: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40010a08: 7f ff ea a3 call 4000b494 <sparc_disable_interrupts>
40010a0c: 01 00 00 00 nop
*signal_set |= signals;
40010a10: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40010a14: 82 10 40 19 or %g1, %i1, %g1
40010a18: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
_ISR_Enable( _level );
40010a1c: 7f ff ea a2 call 4000b4a4 <sparc_enable_interrupts>
40010a20: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
the_thread->do_post_task_switch_extension = true;
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40010a24: 03 10 00 c6 sethi %hi(0x40031800), %g1
40010a28: c2 00 62 cc ld [ %g1 + 0x2cc ], %g1 ! 40031acc <_ISR_Nest_level>
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
if ( asr->is_enabled ) {
_ASR_Post_signals( signal_set, &asr->signals_posted );
the_thread->do_post_task_switch_extension = true;
40010a2c: 84 10 20 01 mov 1, %g2
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
40010a30: 80 a0 60 00 cmp %g1, 0
40010a34: 02 80 00 10 be 40010a74 <rtems_signal_send+0xc0>
40010a38: c4 2c 20 75 stb %g2, [ %l0 + 0x75 ]
40010a3c: 03 10 00 c6 sethi %hi(0x40031800), %g1
40010a40: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 40031af0 <_Thread_Executing>
40010a44: 80 a4 00 01 cmp %l0, %g1
40010a48: 12 80 00 0b bne 40010a74 <rtems_signal_send+0xc0> <== NEVER TAKEN
40010a4c: 03 10 00 c6 sethi %hi(0x40031800), %g1
_ISR_Signals_to_thread_executing = TRUE;
40010a50: 10 80 00 09 b 40010a74 <rtems_signal_send+0xc0>
40010a54: c4 28 63 88 stb %g2, [ %g1 + 0x388 ] ! 40031b88 <_ISR_Signals_to_thread_executing>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
40010a58: 7f ff ea 8f call 4000b494 <sparc_disable_interrupts>
40010a5c: 01 00 00 00 nop
*signal_set |= signals;
40010a60: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40010a64: 82 10 40 19 or %g1, %i1, %g1
40010a68: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( _level );
40010a6c: 7f ff ea 8e call 4000b4a4 <sparc_enable_interrupts>
40010a70: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
40010a74: 40 00 0f 5e call 400147ec <_Thread_Enable_dispatch>
40010a78: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40010a7c: 81 c7 e0 08 ret
40010a80: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40010a84: 40 00 0f 5a call 400147ec <_Thread_Enable_dispatch>
40010a88: b0 10 20 0b mov 0xb, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40010a8c: 81 c7 e0 08 ret
40010a90: 81 e8 00 00 restore
400025e8 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
400025e8: 9d e3 bf 98 save %sp, -104, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
400025ec: c2 06 20 08 ld [ %i0 + 8 ], %g1
400025f0: 80 a0 60 00 cmp %g1, 0
400025f4: 02 80 00 07 be 40002610 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
400025f8: 13 10 00 6e sethi %hi(0x4001b800), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
400025fc: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
40002600: 90 02 20 08 add %o0, 8, %o0
40002604: 92 12 63 bc or %o1, 0x3bc, %o1
40002608: 40 00 2e 99 call 4000e06c <memcpy>
4000260c: 94 10 20 10 mov 0x10, %o2
40002610: 81 c7 e0 08 ret
40002614: 81 e8 00 00 restore
40002a28 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running,
Thread_Control *the_thread
)
{
40002a28: 9d e3 bf 98 save %sp, -104, %sp
Stack_check_Initialize();
40002a2c: 7f ff ff d6 call 40002984 <Stack_check_Initialize>
40002a30: 01 00 00 00 nop
if (the_thread)
40002a34: 80 a6 60 00 cmp %i1, 0
40002a38: 02 80 00 06 be 40002a50 <rtems_stack_checker_create_extension+0x28><== NEVER TAKEN
40002a3c: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
40002a40: d4 06 60 c4 ld [ %i1 + 0xc4 ], %o2
40002a44: d0 06 60 c8 ld [ %i1 + 0xc8 ], %o0
40002a48: 40 00 2d c2 call 4000e150 <memset>
40002a4c: 92 10 20 a5 mov 0xa5, %o1
return true;
}
40002a50: 81 c7 e0 08 ret
40002a54: 91 e8 20 01 restore %g0, 1, %o0
40002884 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
40002884: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
40002888: 03 10 00 6f sethi %hi(0x4001bc00), %g1 <== NOT EXECUTED
4000288c: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 4001be70 <_Thread_Executing><== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
40002890: d0 00 60 c8 ld [ %g1 + 0xc8 ], %o0 <== NOT EXECUTED
40002894: 80 a7 80 08 cmp %fp, %o0 <== NOT EXECUTED
40002898: 0a 80 00 07 bcs 400028b4 <rtems_stack_checker_is_blown+0x30><== NOT EXECUTED
4000289c: b0 10 20 00 clr %i0 <== NOT EXECUTED
400028a0: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 <== NOT EXECUTED
400028a4: 82 02 00 01 add %o0, %g1, %g1 <== NOT EXECUTED
400028a8: 80 a0 40 1e cmp %g1, %fp <== NOT EXECUTED
400028ac: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
400028b0: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
400028b4: 03 10 00 6e sethi %hi(0x4001b800), %g1 <== NOT EXECUTED
400028b8: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 4001ba20 <Stack_check_Initialized><== NOT EXECUTED
400028bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400028c0: 02 80 00 0a be 400028e8 <rtems_stack_checker_is_blown+0x64><== NOT EXECUTED
400028c4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
pattern_ok = (!memcmp(
400028c8: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
400028cc: 13 10 00 6e sethi %hi(0x4001b800), %o1 <== NOT EXECUTED
400028d0: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
400028d4: 40 00 2d b8 call 4000dfb4 <memcmp> <== NOT EXECUTED
400028d8: 92 12 63 bc or %o1, 0x3bc, %o1 <== NOT EXECUTED
400028dc: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
400028e0: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
400028e4: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
400028e8: 80 8e 20 ff btst 0xff, %i0 <== NOT EXECUTED
400028ec: 02 80 00 04 be 400028fc <rtems_stack_checker_is_blown+0x78><== NOT EXECUTED
400028f0: 80 8a 60 ff btst 0xff, %o1 <== NOT EXECUTED
400028f4: 12 80 00 07 bne 40002910 <rtems_stack_checker_is_blown+0x8c><== NOT EXECUTED
400028f8: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
400028fc: 03 10 00 6f sethi %hi(0x4001bc00), %g1 <== NOT EXECUTED
40002900: d0 00 62 70 ld [ %g1 + 0x270 ], %o0 ! 4001be70 <_Thread_Executing><== NOT EXECUTED
40002904: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
40002908: 7f ff ff c6 call 40002820 <Stack_check_report_blown_task> <== NOT EXECUTED
4000290c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return true;
}
40002910: 81 c7 e0 08 ret <== NOT EXECUTED
40002914: 81 e8 00 00 restore <== NOT EXECUTED
40002804 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
40002804: 13 10 00 0f sethi %hi(0x40003c00), %o1 <== NOT EXECUTED
40002808: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000280c: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED
40002810: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40002814: 7f ff ff e6 call 400027ac <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
40002818: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400027ac <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
400027ac: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
print_context = context;
400027b0: 23 10 00 6e sethi %hi(0x4001b800), %l1 <== NOT EXECUTED
print_handler = print;
400027b4: 21 10 00 6e sethi %hi(0x4001b800), %l0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
print_context = context;
400027b8: f0 24 62 24 st %i0, [ %l1 + 0x224 ] <== NOT EXECUTED
print_handler = print;
400027bc: f2 24 22 28 st %i1, [ %l0 + 0x228 ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
400027c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400027c4: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
400027c8: 9f c6 40 00 call %i1 <== NOT EXECUTED
400027cc: 92 12 63 28 or %o1, 0x328, %o1 ! 40019328 <__func__.4755+0x298><== NOT EXECUTED
(*print)( context,
400027d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400027d4: 13 10 00 64 sethi %hi(0x40019000), %o1 <== NOT EXECUTED
400027d8: 9f c6 40 00 call %i1 <== NOT EXECUTED
400027dc: 92 12 63 40 or %o1, 0x340, %o1 ! 40019340 <__func__.4755+0x2b0><== 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 );
400027e0: 11 10 00 09 sethi %hi(0x40002400), %o0 <== NOT EXECUTED
400027e4: 40 00 14 79 call 400079c8 <rtems_iterate_over_all_threads><== NOT EXECUTED
400027e8: 90 12 22 58 or %o0, 0x258, %o0 ! 40002658 <Stack_check_Dump_threads_usage><== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
400027ec: 7f ff ff 9b call 40002658 <Stack_check_Dump_threads_usage><== NOT EXECUTED
400027f0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
print_context = NULL;
400027f4: c0 24 62 24 clr [ %l1 + 0x224 ] <== NOT EXECUTED
print_handler = NULL;
400027f8: c0 24 22 28 clr [ %l0 + 0x228 ] <== NOT EXECUTED
}
400027fc: 81 c7 e0 08 ret <== NOT EXECUTED
40002800: 81 e8 00 00 restore <== NOT EXECUTED
40002918 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running,
Thread_Control *heir
)
{
40002918: 9d e3 bf 98 save %sp, -104, %sp
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
4000291c: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
40002920: 80 a7 80 08 cmp %fp, %o0
40002924: 0a 80 00 07 bcs 40002940 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
40002928: b2 10 20 00 clr %i1
4000292c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1
40002930: 82 02 00 01 add %o0, %g1, %g1
40002934: 80 a0 40 1e cmp %g1, %fp
40002938: 82 60 3f ff subx %g0, -1, %g1
4000293c: b2 10 00 01 mov %g1, %i1
/*
* 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,
40002940: 90 02 20 08 add %o0, 8, %o0
40002944: 13 10 00 6e sethi %hi(0x4001b800), %o1
40002948: 94 10 20 10 mov 0x10, %o2
4000294c: 40 00 2d 9a call 4000dfb4 <memcmp>
40002950: 92 12 63 bc or %o1, 0x3bc, %o1
40002954: 80 a0 00 08 cmp %g0, %o0
40002958: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
4000295c: 80 8e 60 ff btst 0xff, %i1
40002960: 02 80 00 04 be 40002970 <rtems_stack_checker_switch_extension+0x58><== NEVER TAKEN
40002964: 80 a0 60 00 cmp %g1, 0
40002968: 12 80 00 05 bne 4000297c <rtems_stack_checker_switch_extension+0x64><== ALWAYS TAKEN
4000296c: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
40002970: b2 08 60 01 and %g1, 1, %i1 <== NOT EXECUTED
40002974: 7f ff ff ab call 40002820 <Stack_check_report_blown_task> <== NOT EXECUTED
40002978: 81 e8 00 00 restore <== NOT EXECUTED
4000297c: 81 c7 e0 08 ret
40002980: 81 e8 00 00 restore
40002e70 <rtems_status_text>:
const char *
rtems_status_text(
rtems_status_code status
)
{
40002e70: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
40002e74: 11 10 00 68 sethi %hi(0x4001a000), %o0 <== NOT EXECUTED
40002e78: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4001a0f8 <rtems_status_assoc><== NOT EXECUTED
40002e7c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40002e80: 40 00 23 5d call 4000bbf4 <rtems_assoc_name_by_local> <== NOT EXECUTED
40002e84: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400055b4 <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
Objects_Id *id
)
{
400055b4: 9d e3 bf 78 save %sp, -136, %sp
400055b8: a4 10 00 18 mov %i0, %l2
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
400055bc: 80 a7 60 00 cmp %i5, 0
400055c0: 02 80 00 1e be 40005638 <rtems_task_create+0x84> <== NEVER TAKEN
400055c4: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
400055c8: 80 a4 a0 00 cmp %l2, 0
400055cc: 02 80 00 1b be 40005638 <rtems_task_create+0x84>
400055d0: b0 10 20 03 mov 3, %i0
/*
* Validate the RTEMS API priority and convert it to the core priority range.
*/
if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
400055d4: 03 00 00 20 sethi %hi(0x8000), %g1
400055d8: 80 8f 00 01 btst %i4, %g1
400055dc: 12 80 00 0b bne 40005608 <rtems_task_create+0x54>
400055e0: 80 a6 60 00 cmp %i1, 0
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
400055e4: 02 80 00 06 be 400055fc <rtems_task_create+0x48>
400055e8: 82 10 20 00 clr %g1
400055ec: 03 10 00 5c sethi %hi(0x40017000), %g1
400055f0: c2 08 62 04 ldub [ %g1 + 0x204 ], %g1 ! 40017204 <rtems_maximum_priority>
400055f4: 80 a0 40 19 cmp %g1, %i1
400055f8: 82 60 3f ff subx %g0, -1, %g1
if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
400055fc: 80 a0 60 00 cmp %g1, 0
40005600: 02 80 00 0e be 40005638 <rtems_task_create+0x84>
40005604: b0 10 20 13 mov 0x13, %i0
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
40005608: 23 10 00 5f sethi %hi(0x40017c00), %l1
4000560c: d0 04 63 88 ld [ %l1 + 0x388 ], %o0 ! 40017f88 <_RTEMS_Allocator_Mutex>
40005610: 40 00 01 ed call 40005dc4 <_API_Mutex_Lock>
40005614: 21 10 00 5f sethi %hi(0x40017c00), %l0
* 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 );
40005618: 40 00 04 1c call 40006688 <_Objects_Allocate>
4000561c: 90 14 21 d4 or %l0, 0x1d4, %o0 ! 40017dd4 <_RTEMS_tasks_Information>
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
40005620: b8 92 20 00 orcc %o0, 0, %i4
40005624: 12 80 00 07 bne 40005640 <rtems_task_create+0x8c>
40005628: 83 36 e0 08 srl %i3, 8, %g1
_RTEMS_Unlock_allocator();
4000562c: d0 04 63 88 ld [ %l1 + 0x388 ], %o0
40005630: 40 00 01 fb call 40005e1c <_API_Mutex_Unlock>
40005634: b0 10 20 05 mov 5, %i0
40005638: 81 c7 e0 08 ret
4000563c: 81 e8 00 00 restore
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
40005640: 82 18 60 01 xor %g1, 1, %g1
40005644: 82 08 60 01 and %g1, 1, %g1
40005648: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
4000564c: 83 36 e0 09 srl %i3, 9, %g1
40005650: 82 08 60 01 and %g1, 1, %g1
40005654: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
40005658: 82 0e e0 0f and %i3, 0xf, %g1
4000565c: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
40005660: 82 07 bf f4 add %fp, -12, %g1
40005664: e4 27 bf f4 st %l2, [ %fp + -12 ]
40005668: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
4000566c: c0 23 a0 64 clr [ %sp + 0x64 ]
40005670: 90 14 21 d4 or %l0, 0x1d4, %o0
40005674: 96 10 00 1a mov %i2, %o3
40005678: 9a 10 00 19 mov %i1, %o5
4000567c: 92 10 00 1c mov %i4, %o1
40005680: 94 10 20 00 clr %o2
40005684: 40 00 07 e7 call 40007620 <_Thread_Initialize>
40005688: 98 10 20 00 clr %o4
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
4000568c: 80 8a 20 ff btst 0xff, %o0
40005690: 12 80 00 0b bne 400056bc <rtems_task_create+0x108>
40005694: c2 07 20 08 ld [ %i4 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
40005698: 40 00 05 0d call 40006acc <_Objects_Get_information_id>
4000569c: 90 10 00 01 mov %g1, %o0
400056a0: 40 00 04 e7 call 40006a3c <_Objects_Free>
400056a4: 92 10 00 1c mov %i4, %o1
#if defined(RTEMS_MULTIPROCESSING)
if ( is_global )
_Objects_MP_Free_global_object( the_global_object );
#endif
_RTEMS_tasks_Free( the_thread );
_RTEMS_Unlock_allocator();
400056a8: d0 04 63 88 ld [ %l1 + 0x388 ], %o0
400056ac: 40 00 01 dc call 40005e1c <_API_Mutex_Unlock>
400056b0: b0 10 20 0d mov 0xd, %i0
400056b4: 81 c7 e0 08 ret
400056b8: 81 e8 00 00 restore
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
400056bc: c4 07 21 5c ld [ %i4 + 0x15c ], %g2
);
}
#endif
_RTEMS_Unlock_allocator();
400056c0: d0 04 63 88 ld [ %l1 + 0x388 ], %o0
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;
400056c4: c2 27 40 00 st %g1, [ %i5 ]
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
400056c8: 83 36 e0 0a srl %i3, 0xa, %g1
400056cc: 82 18 60 01 xor %g1, 1, %g1
400056d0: 82 08 60 01 and %g1, 1, %g1
);
}
#endif
_RTEMS_Unlock_allocator();
400056d4: b0 10 20 00 clr %i0
400056d8: 40 00 01 d1 call 40005e1c <_API_Mutex_Unlock>
400056dc: c2 28 a0 08 stb %g1, [ %g2 + 8 ]
return RTEMS_SUCCESSFUL;
}
400056e0: 81 c7 e0 08 ret
400056e4: 81 e8 00 00 restore
4000740c <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
4000740c: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
40007410: 03 10 00 76 sethi %hi(0x4001d800), %g1
40007414: c2 00 60 d8 ld [ %g1 + 0xd8 ], %g1 ! 4001d8d8 <_Configuration_Table>
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
40007418: 90 10 00 18 mov %i0, %o0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
4000741c: c2 00 60 40 ld [ %g1 + 0x40 ], %g1
40007420: c2 08 60 04 ldub [ %g1 + 4 ], %g1
40007424: 80 a0 60 00 cmp %g1, 0
40007428: 02 80 00 26 be 400074c0 <rtems_task_get_note+0xb4> <== NEVER TAKEN
4000742c: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if ( !note )
40007430: 80 a6 a0 00 cmp %i2, 0
40007434: 02 80 00 23 be 400074c0 <rtems_task_get_note+0xb4> <== NEVER TAKEN
40007438: b0 10 20 09 mov 9, %i0
/*
* 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 )
4000743c: 80 a6 60 0f cmp %i1, 0xf
40007440: 18 80 00 20 bgu 400074c0 <rtems_task_get_note+0xb4>
40007444: b0 10 20 0a mov 0xa, %i0
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
40007448: 80 a2 20 00 cmp %o0, 0
4000744c: 02 80 00 07 be 40007468 <rtems_task_get_note+0x5c>
40007450: 03 10 00 76 sethi %hi(0x4001d800), %g1
40007454: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001d900 <_Thread_Executing>
40007458: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000745c: 80 a2 00 01 cmp %o0, %g1
40007460: 12 80 00 0b bne 4000748c <rtems_task_get_note+0x80>
40007464: 01 00 00 00 nop
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
40007468: 03 10 00 76 sethi %hi(0x4001d800), %g1
4000746c: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 4001d900 <_Thread_Executing>
40007470: 82 06 60 08 add %i1, 8, %g1
40007474: c4 00 a1 5c ld [ %g2 + 0x15c ], %g2
40007478: 83 28 60 02 sll %g1, 2, %g1
4000747c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
40007480: c2 26 80 00 st %g1, [ %i2 ]
40007484: 81 c7 e0 08 ret
40007488: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
4000748c: 40 00 08 52 call 400095d4 <_Thread_Get>
40007490: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40007494: c2 07 bf f4 ld [ %fp + -12 ], %g1
40007498: 80 a0 60 00 cmp %g1, 0
4000749c: 12 80 00 09 bne 400074c0 <rtems_task_get_note+0xb4>
400074a0: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
400074a4: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
400074a8: 84 06 60 08 add %i1, 8, %g2
400074ac: 85 28 a0 02 sll %g2, 2, %g2
400074b0: c2 00 40 02 ld [ %g1 + %g2 ], %g1
_Thread_Enable_dispatch();
400074b4: b0 10 20 00 clr %i0
400074b8: 40 00 08 3a call 400095a0 <_Thread_Enable_dispatch>
400074bc: c2 26 80 00 st %g1, [ %i2 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400074c0: 81 c7 e0 08 ret
400074c4: 81 e8 00 00 restore
40005764 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
Objects_Id *id
)
{
40005764: 9d e3 bf 98 save %sp, -104, %sp
40005768: 92 10 00 18 mov %i0, %o1
4000576c: 96 10 00 1a mov %i2, %o3
40005770: 94 10 00 19 mov %i1, %o2
Objects_Name_or_id_lookup_errors status;
if ( !id )
40005774: 80 a6 a0 00 cmp %i2, 0
40005778: 02 80 00 11 be 400057bc <rtems_task_ident+0x58> <== NEVER TAKEN
4000577c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
40005780: 80 a2 60 00 cmp %o1, 0
40005784: 12 80 00 07 bne 400057a0 <rtems_task_ident+0x3c>
40005788: 03 10 00 5f sethi %hi(0x40017c00), %g1
*id = _Thread_Executing->Object.id;
4000578c: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 40017f90 <_Thread_Executing>
40005790: c2 00 60 08 ld [ %g1 + 8 ], %g1
40005794: c2 26 80 00 st %g1, [ %i2 ]
40005798: 81 c7 e0 08 ret
4000579c: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
400057a0: 11 10 00 5f sethi %hi(0x40017c00), %o0
400057a4: 40 00 05 72 call 40006d6c <_Objects_Name_to_id_u32>
400057a8: 90 12 21 d4 or %o0, 0x1d4, %o0 ! 40017dd4 <_RTEMS_tasks_Information>
return _Status_Object_name_errors_to_status[ status ];
400057ac: 03 10 00 59 sethi %hi(0x40016400), %g1
400057b0: 91 2a 20 02 sll %o0, 2, %o0
400057b4: 82 10 61 d8 or %g1, 0x1d8, %g1
400057b8: f0 00 40 08 ld [ %g1 + %o0 ], %i0
}
400057bc: 81 c7 e0 08 ret
400057c0: 81 e8 00 00 restore
40005dcc <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
Objects_Id id
)
{
40005dcc: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
40005dd0: 90 10 00 18 mov %i0, %o0
40005dd4: 40 00 07 61 call 40007b58 <_Thread_Get>
40005dd8: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40005ddc: c2 07 bf f4 ld [ %fp + -12 ], %g1
40005de0: 80 a0 60 00 cmp %g1, 0
40005de4: 12 80 00 08 bne 40005e04 <rtems_task_is_suspended+0x38> <== NEVER TAKEN
40005de8: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
40005dec: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40005df0: 80 88 60 02 btst 2, %g1
40005df4: 12 80 00 06 bne 40005e0c <rtems_task_is_suspended+0x40>
40005df8: 01 00 00 00 nop
_Thread_Enable_dispatch();
40005dfc: 40 00 07 4a call 40007b24 <_Thread_Enable_dispatch>
40005e00: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40005e04: 81 c7 e0 08 ret
40005e08: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
40005e0c: 40 00 07 46 call 40007b24 <_Thread_Enable_dispatch>
40005e10: b0 10 20 0f mov 0xf, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40005e14: 81 c7 e0 08 ret
40005e18: 81 e8 00 00 restore
4000bbec <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
4000bbec: 9d e3 bf 98 save %sp, -104, %sp
4000bbf0: a8 10 00 18 mov %i0, %l4
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
4000bbf4: 80 a6 a0 00 cmp %i2, 0
4000bbf8: 02 80 00 53 be 4000bd44 <rtems_task_mode+0x158> <== NEVER TAKEN
4000bbfc: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
4000bc00: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bc04: e6 00 63 90 ld [ %g1 + 0x390 ], %l3 ! 40017f90 <_Thread_Executing>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000bc08: c2 0c e0 76 ldub [ %l3 + 0x76 ], %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000bc0c: c4 04 e0 7c ld [ %l3 + 0x7c ], %g2
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000bc10: 80 a0 00 01 cmp %g0, %g1
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
4000bc14: e4 04 e1 5c ld [ %l3 + 0x15c ], %l2
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
4000bc18: 82 60 3f ff subx %g0, -1, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
4000bc1c: 80 a0 a0 00 cmp %g2, 0
4000bc20: 02 80 00 03 be 4000bc2c <rtems_task_mode+0x40>
4000bc24: a3 28 60 08 sll %g1, 8, %l1
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
4000bc28: a2 14 62 00 or %l1, 0x200, %l1
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
4000bc2c: c2 0c a0 08 ldub [ %l2 + 8 ], %g1
4000bc30: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
4000bc34: 7f ff f4 8d call 40008e68 <_CPU_ISR_Get_level>
4000bc38: a0 60 3f ff subx %g0, -1, %l0
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;
4000bc3c: a1 2c 20 0a sll %l0, 0xa, %l0
4000bc40: a0 14 00 08 or %l0, %o0, %l0
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
4000bc44: a0 14 00 11 or %l0, %l1, %l0
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
4000bc48: 80 8e 61 00 btst 0x100, %i1
4000bc4c: 02 80 00 06 be 4000bc64 <rtems_task_mode+0x78>
4000bc50: e0 26 80 00 st %l0, [ %i2 ]
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
4000bc54: 83 35 20 08 srl %l4, 8, %g1
4000bc58: 82 18 60 01 xor %g1, 1, %g1
4000bc5c: 82 08 60 01 and %g1, 1, %g1
4000bc60: c2 2c e0 76 stb %g1, [ %l3 + 0x76 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
4000bc64: 80 8e 62 00 btst 0x200, %i1
4000bc68: 02 80 00 0b be 4000bc94 <rtems_task_mode+0xa8>
4000bc6c: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
4000bc70: 80 8d 22 00 btst 0x200, %l4
4000bc74: 22 80 00 07 be,a 4000bc90 <rtems_task_mode+0xa4>
4000bc78: c0 24 e0 7c clr [ %l3 + 0x7c ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
4000bc7c: 03 10 00 5f sethi %hi(0x40017c00), %g1
4000bc80: c2 00 62 28 ld [ %g1 + 0x228 ], %g1 ! 40017e28 <_Thread_Ticks_per_timeslice>
4000bc84: c2 24 e0 78 st %g1, [ %l3 + 0x78 ]
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;
4000bc88: 82 10 20 01 mov 1, %g1
4000bc8c: c2 24 e0 7c st %g1, [ %l3 + 0x7c ]
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
4000bc90: 80 8e 60 0f btst 0xf, %i1
4000bc94: 02 80 00 06 be 4000bcac <rtems_task_mode+0xc0>
4000bc98: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
4000bc9c: 90 0d 20 0f and %l4, 0xf, %o0
4000bca0: 7f ff d8 13 call 40001cec <sparc_enable_interrupts>
4000bca4: 91 2a 20 08 sll %o0, 8, %o0
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
4000bca8: 80 8e 64 00 btst 0x400, %i1
4000bcac: 02 80 00 18 be 4000bd0c <rtems_task_mode+0x120>
4000bcb0: a0 10 20 00 clr %l0
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4000bcb4: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
4000bcb8: 83 35 20 0a srl %l4, 0xa, %g1
4000bcbc: 82 18 60 01 xor %g1, 1, %g1
4000bcc0: 82 08 60 01 and %g1, 1, %g1
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
4000bcc4: 80 a0 40 02 cmp %g1, %g2
4000bcc8: 22 80 00 12 be,a 4000bd10 <rtems_task_mode+0x124>
4000bccc: 03 10 00 60 sethi %hi(0x40018000), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
4000bcd0: 7f ff d8 03 call 40001cdc <sparc_disable_interrupts>
4000bcd4: c2 2c a0 08 stb %g1, [ %l2 + 8 ]
_signals = information->signals_pending;
4000bcd8: c2 04 a0 18 ld [ %l2 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
4000bcdc: c4 04 a0 14 ld [ %l2 + 0x14 ], %g2
information->signals_posted = _signals;
4000bce0: c2 24 a0 14 st %g1, [ %l2 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
4000bce4: c4 24 a0 18 st %g2, [ %l2 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
4000bce8: 7f ff d8 01 call 40001cec <sparc_enable_interrupts>
4000bcec: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
4000bcf0: c2 04 a0 14 ld [ %l2 + 0x14 ], %g1
4000bcf4: 80 a0 60 00 cmp %g1, 0
4000bcf8: 22 80 00 05 be,a 4000bd0c <rtems_task_mode+0x120>
4000bcfc: a0 10 20 00 clr %l0
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
4000bd00: 82 10 20 01 mov 1, %g1
4000bd04: a0 10 20 01 mov 1, %l0
4000bd08: c2 2c e0 75 stb %g1, [ %l3 + 0x75 ]
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
4000bd0c: 03 10 00 60 sethi %hi(0x40018000), %g1
4000bd10: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 40018074 <_System_state_Current>
4000bd14: 80 a0 60 03 cmp %g1, 3
4000bd18: 12 80 00 0b bne 4000bd44 <rtems_task_mode+0x158> <== NEVER TAKEN
4000bd1c: b0 10 20 00 clr %i0
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
4000bd20: 40 00 00 7b call 4000bf0c <_Thread_Evaluate_mode>
4000bd24: 01 00 00 00 nop
4000bd28: 80 8a 20 ff btst 0xff, %o0
4000bd2c: 12 80 00 04 bne 4000bd3c <rtems_task_mode+0x150>
4000bd30: 80 8c 20 ff btst 0xff, %l0
4000bd34: 02 80 00 06 be 4000bd4c <rtems_task_mode+0x160>
4000bd38: 01 00 00 00 nop
_Thread_Dispatch();
4000bd3c: 7f ff ed af call 400073f8 <_Thread_Dispatch>
4000bd40: b0 10 20 00 clr %i0 ! 0 <PROM_START>
4000bd44: 81 c7 e0 08 ret
4000bd48: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
4000bd4c: 81 c7 e0 08 ret
4000bd50: 81 e8 00 00 restore
400075d0 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
400075d0: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
400075d4: 03 10 00 76 sethi %hi(0x4001d800), %g1
400075d8: c2 00 60 d8 ld [ %g1 + 0xd8 ], %g1 ! 4001d8d8 <_Configuration_Table>
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
400075dc: 90 10 00 18 mov %i0, %o0
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
if ( !rtems_configuration_get_notepads_enabled() )
400075e0: c2 00 60 40 ld [ %g1 + 0x40 ], %g1
400075e4: c2 08 60 04 ldub [ %g1 + 4 ], %g1
400075e8: 80 a0 60 00 cmp %g1, 0
400075ec: 02 80 00 21 be 40007670 <rtems_task_set_note+0xa0> <== NEVER TAKEN
400075f0: b0 10 20 16 mov 0x16, %i0
/*
* 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 )
400075f4: 80 a6 60 0f cmp %i1, 0xf
400075f8: 18 80 00 1e bgu 40007670 <rtems_task_set_note+0xa0>
400075fc: b0 10 20 0a mov 0xa, %i0
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
40007600: 80 a2 20 00 cmp %o0, 0
40007604: 02 80 00 07 be 40007620 <rtems_task_set_note+0x50>
40007608: 03 10 00 76 sethi %hi(0x4001d800), %g1
4000760c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 4001d900 <_Thread_Executing>
40007610: c2 00 60 08 ld [ %g1 + 8 ], %g1
40007614: 80 a2 00 01 cmp %o0, %g1
40007618: 12 80 00 0a bne 40007640 <rtems_task_set_note+0x70> <== ALWAYS TAKEN
4000761c: 01 00 00 00 nop
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
40007620: 03 10 00 76 sethi %hi(0x4001d800), %g1
40007624: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 4001d900 <_Thread_Executing>
40007628: c4 00 a1 5c ld [ %g2 + 0x15c ], %g2
4000762c: 82 06 60 08 add %i1, 8, %g1
40007630: 83 28 60 02 sll %g1, 2, %g1
40007634: f4 20 80 01 st %i2, [ %g2 + %g1 ]
40007638: 81 c7 e0 08 ret
4000763c: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
40007640: 40 00 07 e5 call 400095d4 <_Thread_Get>
40007644: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40007648: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000764c: 80 a0 60 00 cmp %g1, 0
40007650: 12 80 00 08 bne 40007670 <rtems_task_set_note+0xa0>
40007654: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
40007658: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
4000765c: 82 06 60 08 add %i1, 8, %g1
40007660: 83 28 60 02 sll %g1, 2, %g1
_Thread_Enable_dispatch();
40007664: b0 10 20 00 clr %i0
40007668: 40 00 07 ce call 400095a0 <_Thread_Enable_dispatch>
4000766c: f4 20 80 01 st %i2, [ %g2 + %g1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40007670: 81 c7 e0 08 ret
40007674: 81 e8 00 00 restore
40006b28 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
Objects_Id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
40006b28: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
40006b2c: 80 a6 60 00 cmp %i1, 0
40006b30: 02 80 00 07 be 40006b4c <rtems_task_set_priority+0x24>
40006b34: 90 10 00 18 mov %i0, %o0
40006b38: 03 10 00 6c sethi %hi(0x4001b000), %g1
40006b3c: c2 08 63 34 ldub [ %g1 + 0x334 ], %g1 ! 4001b334 <rtems_maximum_priority>
40006b40: 80 a6 40 01 cmp %i1, %g1
40006b44: 18 80 00 1c bgu 40006bb4 <rtems_task_set_priority+0x8c>
40006b48: b0 10 20 13 mov 0x13, %i0
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
40006b4c: 80 a6 a0 00 cmp %i2, 0
40006b50: 02 80 00 19 be 40006bb4 <rtems_task_set_priority+0x8c> <== NEVER TAKEN
40006b54: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
40006b58: 40 00 07 b0 call 40008a18 <_Thread_Get>
40006b5c: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
40006b60: c2 07 bf f4 ld [ %fp + -12 ], %g1
40006b64: 80 a0 60 00 cmp %g1, 0
40006b68: 12 80 00 13 bne 40006bb4 <rtems_task_set_priority+0x8c>
40006b6c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
40006b70: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
40006b74: 80 a6 60 00 cmp %i1, 0
40006b78: 02 80 00 0d be 40006bac <rtems_task_set_priority+0x84>
40006b7c: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
40006b80: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
40006b84: 80 a0 60 00 cmp %g1, 0
40006b88: 02 80 00 06 be 40006ba0 <rtems_task_set_priority+0x78>
40006b8c: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
40006b90: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40006b94: 80 a0 40 19 cmp %g1, %i1
40006b98: 08 80 00 05 bleu 40006bac <rtems_task_set_priority+0x84> <== ALWAYS TAKEN
40006b9c: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, FALSE );
40006ba0: 92 10 00 19 mov %i1, %o1
40006ba4: 40 00 06 1d call 40008418 <_Thread_Change_priority>
40006ba8: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
40006bac: 40 00 07 8e call 400089e4 <_Thread_Enable_dispatch>
40006bb0: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40006bb4: 81 c7 e0 08 ret
40006bb8: 81 e8 00 00 restore
40007198 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
40007198: 9d e3 bf 90 save %sp, -112, %sp
4000719c: 90 10 00 18 mov %i0, %o0
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
400071a0: 80 a6 60 00 cmp %i1, 0
400071a4: 02 80 00 11 be 400071e8 <rtems_task_variable_add+0x50> <== NEVER TAKEN
400071a8: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
400071ac: 40 00 07 b7 call 40009088 <_Thread_Get>
400071b0: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
400071b4: c2 07 bf f4 ld [ %fp + -12 ], %g1
rtems_task_variable_t *tvp, *new;
if ( !ptr )
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
400071b8: a0 10 00 08 mov %o0, %l0
switch (location) {
400071bc: 80 a0 60 00 cmp %g1, 0
400071c0: 12 80 00 0a bne 400071e8 <rtems_task_variable_add+0x50> <== NEVER TAKEN
400071c4: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
400071c8: 10 80 00 0a b 400071f0 <rtems_task_variable_add+0x58>
400071cc: c4 02 21 6c ld [ %o0 + 0x16c ], %g2
while (tvp) {
if (tvp->ptr == ptr) {
400071d0: 80 a0 40 19 cmp %g1, %i1
400071d4: 32 80 00 07 bne,a 400071f0 <rtems_task_variable_add+0x58>
400071d8: c4 00 80 00 ld [ %g2 ], %g2
tvp->dtor = dtor;
400071dc: f4 20 a0 10 st %i2, [ %g2 + 0x10 ]
_Thread_Enable_dispatch();
400071e0: 40 00 07 9d call 40009054 <_Thread_Enable_dispatch>
400071e4: b0 10 20 00 clr %i0
400071e8: 81 c7 e0 08 ret
400071ec: 81 e8 00 00 restore
case OBJECTS_LOCAL:
/*
* Figure out if the variable is already in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
400071f0: 80 a0 a0 00 cmp %g2, 0
400071f4: 32 bf ff f7 bne,a 400071d0 <rtems_task_variable_add+0x38>
400071f8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
400071fc: 40 00 0d 0a call 4000a624 <_Workspace_Allocate>
40007200: 90 10 20 14 mov 0x14, %o0
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
40007204: 80 a2 20 00 cmp %o0, 0
40007208: 32 80 00 06 bne,a 40007220 <rtems_task_variable_add+0x88>
4000720c: c4 04 21 6c ld [ %l0 + 0x16c ], %g2
_Thread_Enable_dispatch();
40007210: 40 00 07 91 call 40009054 <_Thread_Enable_dispatch>
40007214: b0 10 20 1a mov 0x1a, %i0
40007218: 81 c7 e0 08 ret
4000721c: 81 e8 00 00 restore
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
40007220: c2 06 40 00 ld [ %i1 ], %g1
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
the_thread->task_variables = new;
40007224: d0 24 21 6c st %o0, [ %l0 + 0x16c ]
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
40007228: c2 22 20 08 st %g1, [ %o0 + 8 ]
new->ptr = ptr;
4000722c: f2 22 20 04 st %i1, [ %o0 + 4 ]
new->dtor = dtor;
40007230: f4 22 20 10 st %i2, [ %o0 + 0x10 ]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
40007234: c4 22 00 00 st %g2, [ %o0 ]
the_thread->task_variables = new;
_Thread_Enable_dispatch();
40007238: 40 00 07 87 call 40009054 <_Thread_Enable_dispatch>
4000723c: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40007240: 81 c7 e0 08 ret
40007244: 81 e8 00 00 restore
40007248 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
40007248: 9d e3 bf 90 save %sp, -112, %sp
4000724c: 90 10 00 18 mov %i0, %o0
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
40007250: 80 a6 60 00 cmp %i1, 0
40007254: 02 80 00 18 be 400072b4 <rtems_task_variable_delete+0x6c>
40007258: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
4000725c: 40 00 07 8b call 40009088 <_Thread_Get>
40007260: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
40007264: c2 07 bf f4 ld [ %fp + -12 ], %g1
40007268: 80 a0 60 00 cmp %g1, 0
4000726c: 12 80 00 12 bne 400072b4 <rtems_task_variable_delete+0x6c><== NEVER TAKEN
40007270: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
40007274: d2 02 21 6c ld [ %o0 + 0x16c ], %o1
40007278: 10 80 00 12 b 400072c0 <rtems_task_variable_delete+0x78>
4000727c: 84 10 20 00 clr %g2
while (tvp) {
if (tvp->ptr == ptr) {
40007280: 80 a0 40 19 cmp %g1, %i1
40007284: 32 80 00 0e bne,a 400072bc <rtems_task_variable_delete+0x74>
40007288: 84 10 00 09 mov %o1, %g2
if (prev)
4000728c: 80 a0 a0 00 cmp %g2, 0
40007290: 02 80 00 04 be 400072a0 <rtems_task_variable_delete+0x58>
40007294: c2 02 40 00 ld [ %o1 ], %g1
prev->next = tvp->next;
40007298: 10 80 00 03 b 400072a4 <rtems_task_variable_delete+0x5c>
4000729c: c2 20 80 00 st %g1, [ %g2 ]
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
400072a0: c2 22 21 6c st %g1, [ %o0 + 0x16c ]
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
400072a4: 40 00 00 30 call 40007364 <_RTEMS_Tasks_Invoke_task_variable_dtor>
400072a8: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
400072ac: 40 00 07 6a call 40009054 <_Thread_Enable_dispatch>
400072b0: 01 00 00 00 nop
400072b4: 81 c7 e0 08 ret
400072b8: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
400072bc: d2 02 40 00 ld [ %o1 ], %o1
the_thread = _Thread_Get (tid, &location);
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
400072c0: 80 a2 60 00 cmp %o1, 0
400072c4: 32 bf ff ef bne,a 40007280 <rtems_task_variable_delete+0x38>
400072c8: c2 02 60 04 ld [ %o1 + 4 ], %g1
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
400072cc: 40 00 07 62 call 40009054 <_Thread_Enable_dispatch>
400072d0: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400072d4: 81 c7 e0 08 ret
400072d8: 81 e8 00 00 restore
400072dc <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
400072dc: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
400072e0: 80 a6 60 00 cmp %i1, 0
400072e4: 02 80 00 1d be 40007358 <rtems_task_variable_get+0x7c>
400072e8: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
if ( !result )
400072ec: 80 a6 a0 00 cmp %i2, 0
400072f0: 02 80 00 11 be 40007334 <rtems_task_variable_get+0x58>
400072f4: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
400072f8: 40 00 07 64 call 40009088 <_Thread_Get>
400072fc: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
40007300: c2 07 bf f4 ld [ %fp + -12 ], %g1
40007304: 80 a0 60 00 cmp %g1, 0
40007308: 12 80 00 0b bne 40007334 <rtems_task_variable_get+0x58> <== NEVER TAKEN
4000730c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
40007310: 10 80 00 0b b 4000733c <rtems_task_variable_get+0x60>
40007314: d0 02 21 6c ld [ %o0 + 0x16c ], %o0
while (tvp) {
if (tvp->ptr == ptr) {
40007318: 80 a0 40 19 cmp %g1, %i1
4000731c: 32 80 00 08 bne,a 4000733c <rtems_task_variable_get+0x60>
40007320: d0 02 00 00 ld [ %o0 ], %o0
/*
* Should this return the current (i.e not the
* saved) value if `tid' is the current task?
*/
*result = tvp->tval;
40007324: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
40007328: b0 10 20 00 clr %i0
4000732c: 40 00 07 4a call 40009054 <_Thread_Enable_dispatch>
40007330: c2 26 80 00 st %g1, [ %i2 ]
40007334: 81 c7 e0 08 ret
40007338: 81 e8 00 00 restore
case OBJECTS_LOCAL:
/*
* Figure out if the variable is in this task's list.
*/
tvp = the_thread->task_variables;
while (tvp) {
4000733c: 80 a2 20 00 cmp %o0, 0
40007340: 32 bf ff f6 bne,a 40007318 <rtems_task_variable_get+0x3c>
40007344: c2 02 20 04 ld [ %o0 + 4 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
40007348: 40 00 07 43 call 40009054 <_Thread_Enable_dispatch>
4000734c: b0 10 20 09 mov 9, %i0
40007350: 81 c7 e0 08 ret
40007354: 81 e8 00 00 restore
return RTEMS_INVALID_ADDRESS;
40007358: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4000735c: 81 c7 e0 08 ret
40007360: 81 e8 00 00 restore
40006e30 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
40006e30: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
40006e34: 03 10 00 6d sethi %hi(0x4001b400), %g1
40006e38: c2 08 63 c4 ldub [ %g1 + 0x3c4 ], %g1 ! 4001b7c4 <_TOD_Is_set>
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
40006e3c: a0 10 00 18 mov %i0, %l0
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
40006e40: 80 a0 60 00 cmp %g1, 0
40006e44: 02 80 00 2c be 40006ef4 <rtems_task_wake_when+0xc4>
40006e48: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
40006e4c: 80 a4 20 00 cmp %l0, 0
40006e50: 02 80 00 29 be 40006ef4 <rtems_task_wake_when+0xc4> <== NEVER TAKEN
40006e54: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
40006e58: c0 24 20 18 clr [ %l0 + 0x18 ]
if ( !_TOD_Validate( time_buffer ) )
40006e5c: 7f ff fc d0 call 4000619c <_TOD_Validate>
40006e60: 90 10 00 10 mov %l0, %o0
40006e64: 80 8a 20 ff btst 0xff, %o0
40006e68: 22 80 00 23 be,a 40006ef4 <rtems_task_wake_when+0xc4>
40006e6c: b0 10 20 14 mov 0x14, %i0
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
40006e70: 7f ff fc 98 call 400060d0 <_TOD_To_seconds>
40006e74: 90 10 00 10 mov %l0, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
40006e78: 23 10 00 6e sethi %hi(0x4001b800), %l1
40006e7c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 4001b840 <_TOD_Now>
40006e80: 80 a2 00 01 cmp %o0, %g1
40006e84: 08 80 00 1e bleu 40006efc <rtems_task_wake_when+0xcc>
40006e88: b0 10 00 08 mov %o0, %i0
40006e8c: 05 10 00 6d sethi %hi(0x4001b400), %g2
40006e90: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 4001b7b0 <_Thread_Dispatch_disable_level>
40006e94: 82 00 60 01 inc %g1
40006e98: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ]
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
40006e9c: 21 10 00 6e sethi %hi(0x4001b800), %l0
40006ea0: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 ! 4001b870 <_Thread_Executing>
40006ea4: 40 00 09 72 call 4000946c <_Thread_Set_state>
40006ea8: 92 10 20 10 mov 0x10, %o1
_Watchdog_Initialize(
40006eac: c4 04 20 70 ld [ %l0 + 0x70 ], %g2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40006eb0: 11 10 00 6e sethi %hi(0x4001b800), %o0
40006eb4: c2 00 a0 08 ld [ %g2 + 8 ], %g1
40006eb8: 90 12 20 84 or %o0, 0x84, %o0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
40006ebc: c2 20 a0 68 st %g1, [ %g2 + 0x68 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006ec0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40006ec4: 92 00 a0 48 add %g2, 0x48, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
40006ec8: 82 26 00 01 sub %i0, %g1, %g1
40006ecc: c2 20 a0 54 st %g1, [ %g2 + 0x54 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006ed0: 03 10 00 22 sethi %hi(0x40008800), %g1
40006ed4: 82 10 61 74 or %g1, 0x174, %g1 ! 40008974 <_Thread_Delay_ended>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40006ed8: c0 20 a0 50 clr [ %g2 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40006edc: c0 20 a0 6c clr [ %g2 + 0x6c ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40006ee0: c2 20 a0 64 st %g1, [ %g2 + 0x64 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
40006ee4: 40 00 0b 85 call 40009cf8 <_Watchdog_Insert>
40006ee8: b0 10 20 00 clr %i0
);
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
40006eec: 40 00 07 03 call 40008af8 <_Thread_Enable_dispatch>
40006ef0: 01 00 00 00 nop
40006ef4: 81 c7 e0 08 ret
40006ef8: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
40006efc: b0 10 20 14 mov 0x14, %i0
}
40006f00: 81 c7 e0 08 ret
40006f04: 81 e8 00 00 restore
40002d04 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
40002d04: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
40002d08: d0 20 62 6c st %o0, [ %g1 + 0x26c ] ! 4001766c <rtems_termios_cbufsize><== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
40002d0c: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
return RTEMS_SUCCESSFUL;
}
40002d10: 90 10 20 00 clr %o0 <== NOT EXECUTED
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
rtems_termios_raw_input_size = raw_input;
40002d14: d2 20 62 70 st %o1, [ %g1 + 0x270 ] <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
40002d18: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
40002d1c: 81 c3 e0 08 retl <== NOT EXECUTED
40002d20: d4 20 62 74 st %o2, [ %g1 + 0x274 ] ! 40017674 <rtems_termios_raw_output_size><== NOT EXECUTED
40004398 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
40004398: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4000439c: 03 10 00 5f sethi %hi(0x40017c00), %g1
400043a0: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 40017d88 <rtems_termios_ttyMutex>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400043a4: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400043a8: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
400043ac: e0 00 60 28 ld [ %g1 + 0x28 ], %l0
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
400043b0: 40 00 04 0e call 400053e8 <rtems_semaphore_obtain>
400043b4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
400043b8: 80 a2 20 00 cmp %o0, 0
400043bc: 12 80 00 26 bne 40004454 <rtems_termios_close+0xbc> <== NEVER TAKEN
400043c0: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
400043c4: c2 04 20 08 ld [ %l0 + 8 ], %g1
400043c8: 82 00 7f ff add %g1, -1, %g1
400043cc: 80 a0 60 00 cmp %g1, 0
400043d0: 12 80 00 58 bne 40004530 <rtems_termios_close+0x198>
400043d4: c2 24 20 08 st %g1, [ %l0 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
400043d8: c4 04 20 cc ld [ %l0 + 0xcc ], %g2
400043dc: 03 10 00 5e sethi %hi(0x40017800), %g1
400043e0: 85 28 a0 05 sll %g2, 5, %g2
400043e4: 82 10 63 80 or %g1, 0x380, %g1
400043e8: 82 00 40 02 add %g1, %g2, %g1
400043ec: c2 00 60 04 ld [ %g1 + 4 ], %g1
400043f0: 80 a0 60 00 cmp %g1, 0
400043f4: 02 80 00 06 be 4000440c <rtems_termios_close+0x74> <== ALWAYS TAKEN
400043f8: 01 00 00 00 nop
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
400043fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004400: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
* default: just flush output buffer
*/
drainOutput (tty);
}
if (tty->device.outputUsesInterrupts
40004404: 10 80 00 05 b 40004418 <rtems_termios_close+0x80> <== NOT EXECUTED
40004408: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
drainOutput (tty);
4000440c: 7f ff fd c2 call 40003b14 <drainOutput>
40004410: 90 10 00 10 mov %l0, %o0
}
if (tty->device.outputUsesInterrupts
40004414: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
40004418: 80 a0 60 02 cmp %g1, 2
4000441c: 32 80 00 10 bne,a 4000445c <rtems_termios_close+0xc4> <== ALWAYS TAKEN
40004420: c2 04 20 9c ld [ %l0 + 0x9c ], %g1
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
40004424: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0
40004428: 40 00 02 a2 call 40004eb0 <rtems_event_send> <== NOT EXECUTED
4000442c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
40004430: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004434: 12 80 00 08 bne 40004454 <rtems_termios_close+0xbc> <== NOT EXECUTED
40004438: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
4000443c: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED
40004440: 40 00 02 9c call 40004eb0 <rtems_event_send> <== NOT EXECUTED
40004444: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
40004448: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000444c: 22 80 00 04 be,a 4000445c <rtems_termios_close+0xc4> <== NOT EXECUTED
40004450: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40004454: 40 00 05 a5 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004458: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
4000445c: 80 a0 60 00 cmp %g1, 0
40004460: 22 80 00 07 be,a 4000447c <rtems_termios_close+0xe4> <== ALWAYS TAKEN
40004464: c2 04 00 00 ld [ %l0 ], %g1
(*tty->device.lastClose)(tty->major, tty->minor, arg);
40004468: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED
4000446c: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED
40004470: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004474: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
40004478: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
4000447c: 80 a0 60 00 cmp %g1, 0
40004480: 12 80 00 08 bne 400044a0 <rtems_termios_close+0x108> <== NEVER TAKEN
40004484: c4 04 20 04 ld [ %l0 + 4 ], %g2
rtems_termios_ttyTail = tty->back;
40004488: 03 10 00 5f sethi %hi(0x40017c00), %g1
if ( rtems_termios_ttyTail != NULL ) {
4000448c: 80 a0 a0 00 cmp %g2, 0
40004490: 02 80 00 05 be 400044a4 <rtems_termios_close+0x10c> <== ALWAYS TAKEN
40004494: c4 20 61 8c st %g2, [ %g1 + 0x18c ]
rtems_termios_ttyTail->forw = NULL;
40004498: 10 80 00 03 b 400044a4 <rtems_termios_close+0x10c> <== NOT EXECUTED
4000449c: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED
}
}
else {
tty->forw->back = tty->back;
400044a0: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
}
if (tty->back == NULL) {
400044a4: c2 04 20 04 ld [ %l0 + 4 ], %g1
400044a8: 80 a0 60 00 cmp %g1, 0
400044ac: 12 80 00 08 bne 400044cc <rtems_termios_close+0x134> <== NEVER TAKEN
400044b0: c4 04 00 00 ld [ %l0 ], %g2
rtems_termios_ttyHead = tty->forw;
400044b4: 03 10 00 5f sethi %hi(0x40017c00), %g1
if ( rtems_termios_ttyHead != NULL ) {
400044b8: 80 a0 a0 00 cmp %g2, 0
400044bc: 02 80 00 05 be 400044d0 <rtems_termios_close+0x138> <== ALWAYS TAKEN
400044c0: c4 20 61 90 st %g2, [ %g1 + 0x190 ]
rtems_termios_ttyHead->back = NULL;
400044c4: 10 80 00 03 b 400044d0 <rtems_termios_close+0x138>
400044c8: c0 20 a0 04 clr [ %g2 + 4 ] <== NOT EXECUTED
}
}
else {
tty->back->forw = tty->forw;
400044cc: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
400044d0: 40 00 03 98 call 40005330 <rtems_semaphore_delete>
400044d4: d0 04 20 14 ld [ %l0 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
400044d8: 40 00 03 96 call 40005330 <rtems_semaphore_delete>
400044dc: d0 04 20 18 ld [ %l0 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
400044e0: 40 00 03 94 call 40005330 <rtems_semaphore_delete>
400044e4: d0 04 20 8c ld [ %l0 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
400044e8: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1
400044ec: 80 a0 60 00 cmp %g1, 0
400044f0: 02 80 00 06 be 40004508 <rtems_termios_close+0x170> <== NEVER TAKEN
400044f4: 01 00 00 00 nop
400044f8: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
400044fc: 80 a0 60 02 cmp %g1, 2
40004500: 12 80 00 04 bne 40004510 <rtems_termios_close+0x178> <== ALWAYS TAKEN
40004504: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
40004508: 40 00 03 8a call 40005330 <rtems_semaphore_delete> <== NOT EXECUTED
4000450c: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
free (tty->rawInBuf.theBuf);
40004510: 40 00 16 66 call 40009ea8 <free>
40004514: d0 04 20 58 ld [ %l0 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
40004518: 40 00 16 64 call 40009ea8 <free>
4000451c: d0 04 20 7c ld [ %l0 + 0x7c ], %o0
free (tty->cbuf);
40004520: 40 00 16 62 call 40009ea8 <free>
40004524: d0 04 20 1c ld [ %l0 + 0x1c ], %o0
free (tty);
40004528: 40 00 16 60 call 40009ea8 <free>
4000452c: 90 10 00 10 mov %l0, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
40004530: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004534: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 40017d88 <rtems_termios_ttyMutex>
40004538: 40 00 03 f3 call 40005504 <rtems_semaphore_release>
4000453c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
40004540: 81 c7 e0 08 ret
40004544: 81 e8 00 00 restore
40002f30 <rtems_termios_dequeue_characters>:
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
40002f30: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40002f34: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40002f38: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
40002f3c: 82 00 40 19 add %g1, %i1, %g1 <== NOT EXECUTED
40002f40: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40002f44: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED
40002f48: 12 80 00 0a bne 40002f70 <rtems_termios_dequeue_characters+0x40><== NOT EXECUTED
40002f4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
40002f50: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED
40002f54: 40 00 07 d7 call 40004eb0 <rtems_event_send> <== NOT EXECUTED
40002f58: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
40002f5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40002f60: 02 80 00 11 be 40002fa4 <rtems_termios_dequeue_characters+0x74><== NOT EXECUTED
40002f64: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40002f68: 40 00 0a e0 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002f6c: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
40002f70: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
40002f74: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED
40002f78: 12 80 00 09 bne 40002f9c <rtems_termios_dequeue_characters+0x6c><== NOT EXECUTED
40002f7c: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
40002f80: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 ! 40017c34 <rtems_termios_linesw+0xb4><== NOT EXECUTED
40002f84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002f88: 02 80 00 07 be 40002fa4 <rtems_termios_dequeue_characters+0x74><== NOT EXECUTED
40002f8c: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
40002f90: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002f94: 01 00 00 00 nop <== NOT EXECUTED
40002f98: 30 80 00 03 b,a 40002fa4 <rtems_termios_dequeue_characters+0x74><== NOT EXECUTED
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
40002f9c: 7f ff ff 68 call 40002d3c <rtems_termios_refill_transmitter><== NOT EXECUTED
40002fa0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
40002fa4: 81 c7 e0 08 ret <== NOT EXECUTED
40002fa8: 81 e8 00 00 restore <== NOT EXECUTED
40002fac <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)
{
40002fac: 9d e3 bf 98 save %sp, -104, %sp <== 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) {
40002fb0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
40002fb4: 05 10 00 5e sethi %hi(0x40017800), %g2 <== NOT EXECUTED
40002fb8: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
40002fbc: 84 10 a3 80 or %g2, 0x380, %g2 <== NOT EXECUTED
40002fc0: 82 00 60 10 add %g1, 0x10, %g1 <== NOT EXECUTED
40002fc4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED
40002fc8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002fcc: 12 80 00 10 bne 4000300c <rtems_termios_enqueue_raw_characters+0x60><== NOT EXECUTED
40002fd0: a0 10 00 02 mov %g2, %l0 <== 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,
40002fd4: ac 06 20 4a add %i0, 0x4a, %l6 <== 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);
40002fd8: aa 06 20 30 add %i0, 0x30, %l5 <== NOT EXECUTED
40002fdc: a2 10 20 00 clr %l1 <== NOT EXECUTED
40002fe0: 10 80 00 ac b 40003290 <rtems_termios_enqueue_raw_characters+0x2e4><== NOT EXECUTED
40002fe4: a4 10 20 00 clr %l2 <== NOT EXECUTED
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--) {
c = *buf++;
40002fe8: d0 0e 40 00 ldub [ %i1 ], %o0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40002fec: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
40002ff0: 82 00 60 10 add %g1, 0x10, %g1 <== NOT EXECUTED
40002ff4: c2 04 00 01 ld [ %l0 + %g1 ], %g1 <== NOT EXECUTED
40002ff8: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
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--) {
c = *buf++;
40002ffc: b2 06 60 01 inc %i1 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
40003000: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED
40003004: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003008: 92 10 00 18 mov %i0, %o1 <== 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--) {
4000300c: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
40003010: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
40003014: 32 bf ff f5 bne,a 40002fe8 <rtems_termios_enqueue_raw_characters+0x3c><== NOT EXECUTED
40003018: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
4000301c: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED
40003020: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003024: 12 80 00 a6 bne 400032bc <rtems_termios_enqueue_raw_characters+0x310><== NOT EXECUTED
40003028: a2 10 20 00 clr %l1 <== NOT EXECUTED
4000302c: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED
40003030: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003034: 22 80 00 a3 be,a 400032c0 <rtems_termios_enqueue_raw_characters+0x314><== NOT EXECUTED
40003038: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
4000303c: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED
40003040: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003044: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
40003048: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
4000304c: a2 10 20 00 clr %l1 <== NOT EXECUTED
40003050: 10 80 00 9b b 400032bc <rtems_termios_enqueue_raw_characters+0x310><== NOT EXECUTED
40003054: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
40003058: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
4000305c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
40003060: 02 80 00 1a be 400030c8 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
40003064: e8 0e 40 00 ldub [ %i1 ], %l4 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
40003068: c4 0e 20 4a ldub [ %i0 + 0x4a ], %g2 <== NOT EXECUTED
4000306c: 83 2d 20 18 sll %l4, 0x18, %g1 <== NOT EXECUTED
40003070: 87 38 60 18 sra %g1, 0x18, %g3 <== NOT EXECUTED
40003074: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
40003078: 12 80 00 0c bne 400030a8 <rtems_termios_enqueue_raw_characters+0xfc><== NOT EXECUTED
4000307c: c2 0e 20 49 ldub [ %i0 + 0x49 ], %g1 <== NOT EXECUTED
if (c == tty->termios.c_cc[VSTART]) {
40003080: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
40003084: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
40003088: 12 80 00 05 bne 4000309c <rtems_termios_enqueue_raw_characters+0xf0><== NOT EXECUTED
4000308c: 01 00 00 00 nop <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
40003090: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40003094: 10 80 00 0b b 400030c0 <rtems_termios_enqueue_raw_characters+0x114><== NOT EXECUTED
40003098: 82 18 60 10 xor %g1, 0x10, %g1 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
4000309c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400030a0: 10 80 00 08 b 400030c0 <rtems_termios_enqueue_raw_characters+0x114><== NOT EXECUTED
400030a4: 82 10 60 10 or %g1, 0x10, %g1 <== NOT EXECUTED
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
400030a8: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED
400030ac: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
400030b0: 12 80 00 07 bne 400030cc <rtems_termios_enqueue_raw_characters+0x120><== NOT EXECUTED
400030b4: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
400030b8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400030bc: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
400030c0: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
400030c4: 30 80 00 04 b,a 400030d4 <rtems_termios_enqueue_raw_characters+0x128><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
400030c8: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
400030cc: 02 80 00 1d be 40003140 <rtems_termios_enqueue_raw_characters+0x194><== NOT EXECUTED
400030d0: 01 00 00 00 nop <== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
400030d4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400030d8: 82 08 60 30 and %g1, 0x30, %g1 <== NOT EXECUTED
400030dc: 80 a0 60 20 cmp %g1, 0x20 <== NOT EXECUTED
400030e0: 12 80 00 6b bne 4000328c <rtems_termios_enqueue_raw_characters+0x2e0><== NOT EXECUTED
400030e4: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
400030e8: 7f ff fa fd call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
400030ec: 01 00 00 00 nop <== NOT EXECUTED
400030f0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400030f4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400030f8: c4 06 20 94 ld [ %i0 + 0x94 ], %g2 <== 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;
400030fc: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
40003100: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
40003104: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003108: 02 80 00 09 be 4000312c <rtems_termios_enqueue_raw_characters+0x180><== NOT EXECUTED
4000310c: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
40003110: d2 06 20 84 ld [ %i0 + 0x84 ], %o1 <== NOT EXECUTED
40003114: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
40003118: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED
4000311c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40003120: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
40003124: 9f c0 80 00 call %g2 <== NOT EXECUTED
40003128: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
4000312c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
40003130: 7f ff fa ef call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40003134: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
40003138: 10 80 00 56 b 40003290 <rtems_termios_enqueue_raw_characters+0x2e4><== NOT EXECUTED
4000313c: b2 06 60 01 inc %i1 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
40003140: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
40003144: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED
40003148: 40 00 40 7d call 4001333c <.urem> <== NOT EXECUTED
4000314c: 90 02 20 01 inc %o0 <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
40003150: 7f ff fa e3 call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40003154: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
40003158: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
4000315c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
40003160: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED
40003164: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED
40003168: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
4000316c: 40 00 40 74 call 4001333c <.urem> <== NOT EXECUTED
40003170: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
40003174: c2 06 20 c0 ld [ %i0 + 0xc0 ], %g1 <== NOT EXECUTED
40003178: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
4000317c: 08 80 00 2d bleu 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
40003180: 01 00 00 00 nop <== NOT EXECUTED
40003184: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40003188: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
4000318c: 12 80 00 29 bne 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
40003190: 01 00 00 00 nop <== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
40003194: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40003198: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
4000319c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
400031a0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400031a4: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
400031a8: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
400031ac: 12 80 00 13 bne 400031f8 <rtems_termios_enqueue_raw_characters+0x24c><== NOT EXECUTED
400031b0: 01 00 00 00 nop <== NOT EXECUTED
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
400031b4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400031b8: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400031bc: 12 80 00 06 bne 400031d4 <rtems_termios_enqueue_raw_characters+0x228><== NOT EXECUTED
400031c0: 01 00 00 00 nop <== NOT EXECUTED
400031c4: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
400031c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400031cc: 12 80 00 19 bne 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
400031d0: 01 00 00 00 nop <== 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;
400031d4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400031d8: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED
400031dc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== 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;
400031e0: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400031e4: 92 10 00 16 mov %l6, %o1 <== 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;
400031e8: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400031ec: 9f c0 80 00 call %g2 <== NOT EXECUTED
400031f0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400031f4: 30 80 00 0f b,a 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
400031f8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
400031fc: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
40003200: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
40003204: 12 80 00 0b bne 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
40003208: 01 00 00 00 nop <== NOT EXECUTED
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
4000320c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
40003210: c4 06 20 ac ld [ %i0 + 0xac ], %g2 <== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
40003214: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
40003218: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
4000321c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003220: 02 80 00 04 be 40003230 <rtems_termios_enqueue_raw_characters+0x284><== NOT EXECUTED
40003224: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
40003228: 9f c0 80 00 call %g2 <== NOT EXECUTED
4000322c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40003230: 7f ff fa af call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40003234: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
40003238: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
4000323c: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
40003240: 32 80 00 04 bne,a 40003250 <rtems_termios_enqueue_raw_characters+0x2a4><== NOT EXECUTED
40003244: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
dropped++;
40003248: 10 80 00 11 b 4000328c <rtems_termios_enqueue_raw_characters+0x2e0><== NOT EXECUTED
4000324c: a2 04 60 01 inc %l1 <== NOT EXECUTED
}
else {
tty->rawInBuf.theBuf[newTail] = c;
40003250: e8 28 40 10 stb %l4, [ %g1 + %l0 ] <== 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 )) {
40003254: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
40003258: e0 26 20 60 st %l0, [ %i0 + 0x60 ] <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
4000325c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003260: 32 80 00 0c bne,a 40003290 <rtems_termios_enqueue_raw_characters+0x2e4><== NOT EXECUTED
40003264: b2 06 60 01 inc %i1 <== NOT EXECUTED
40003268: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED
4000326c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003270: 22 80 00 08 be,a 40003290 <rtems_termios_enqueue_raw_characters+0x2e4><== NOT EXECUTED
40003274: b2 06 60 01 inc %i1 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
40003278: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED
4000327c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003280: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
40003284: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
40003288: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
4000328c: b2 06 60 01 inc %i1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
40003290: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
40003294: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
40003298: 12 bf ff 70 bne 40003058 <rtems_termios_enqueue_raw_characters+0xac><== NOT EXECUTED
4000329c: 01 00 00 00 nop <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
400032a0: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
400032a4: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
400032a8: 82 00 40 11 add %g1, %l1, %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
400032ac: 40 00 08 96 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
400032b0: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
return dropped;
}
400032b4: 81 c7 e0 08 ret <== NOT EXECUTED
400032b8: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
400032bc: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
400032c0: 81 c7 e0 08 ret <== NOT EXECUTED
400032c4: 81 e8 00 00 restore <== NOT EXECUTED
40002cb8 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
40002cb8: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
40002cbc: 03 10 00 5f sethi %hi(0x40017c00), %g1
40002cc0: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 40017d88 <rtems_termios_ttyMutex>
40002cc4: 80 a0 a0 00 cmp %g2, 0
40002cc8: 12 80 00 0d bne 40002cfc <rtems_termios_initialize+0x44> <== NEVER TAKEN
40002ccc: 98 10 61 88 or %g1, 0x188, %o4
sc = rtems_semaphore_create (
40002cd0: 11 15 14 9b sethi %hi(0x54526c00), %o0
40002cd4: 92 10 20 01 mov 1, %o1
40002cd8: 90 12 21 69 or %o0, 0x169, %o0
40002cdc: 94 10 20 54 mov 0x54, %o2
40002ce0: 40 00 09 1c call 40005150 <rtems_semaphore_create>
40002ce4: 96 10 20 00 clr %o3
rtems_build_name ('T', 'R', 'm', 'i'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
40002ce8: 80 a2 20 00 cmp %o0, 0
40002cec: 02 80 00 04 be 40002cfc <rtems_termios_initialize+0x44> <== ALWAYS TAKEN
40002cf0: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
40002cf4: 40 00 0b 7d call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40002cf8: 01 00 00 00 nop <== NOT EXECUTED
40002cfc: 81 c7 e0 08 ret
40002d00: 81 e8 00 00 restore
40003f8c <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40003f8c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40003f90: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
40003f94: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40003f98: e2 00 60 28 ld [ %g1 + 0x28 ], %l1 <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
40003f9c: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003fa0: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
40003fa4: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003fa8: 92 10 20 00 clr %o1 <== NOT EXECUTED
40003fac: 40 00 05 0f call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003fb0: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
40003fb4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40003fb8: 22 80 00 05 be,a 40003fcc <rtems_termios_ioctl+0x40> <== NOT EXECUTED
40003fbc: c4 04 a0 04 ld [ %l2 + 4 ], %g2 <== NOT EXECUTED
args->ioctl_return = sc;
40003fc0: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED
40003fc4: 81 c7 e0 08 ret <== NOT EXECUTED
40003fc8: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
switch (args->command) {
40003fcc: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED
40003fd0: 22 80 00 bf be,a 400042cc <rtems_termios_ioctl+0x340> <== NOT EXECUTED
40003fd4: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
40003fd8: 18 80 00 0b bgu 40004004 <rtems_termios_ioctl+0x78> <== NOT EXECUTED
40003fdc: 03 10 01 19 sethi %hi(0x40046400), %g1 <== NOT EXECUTED
40003fe0: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED
40003fe4: 22 80 00 2c be,a 40004094 <rtems_termios_ioctl+0x108> <== NOT EXECUTED
40003fe8: d2 04 a0 08 ld [ %l2 + 8 ], %o1 <== NOT EXECUTED
40003fec: 18 80 00 b1 bgu 400042b0 <rtems_termios_ioctl+0x324> <== NOT EXECUTED
40003ff0: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
40003ff4: 32 80 00 17 bne,a 40004050 <rtems_termios_ioctl+0xc4> <== NOT EXECUTED
40003ff8: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40003ffc: 10 80 00 22 b 40004084 <rtems_termios_ioctl+0xf8> <== NOT EXECUTED
40004000: d0 04 a0 08 ld [ %l2 + 8 ], %o0 <== 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) {
40004004: 82 10 62 7f or %g1, 0x27f, %g1 <== NOT EXECUTED
40004008: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000400c: 02 80 00 d1 be 40004350 <rtems_termios_ioctl+0x3c4> <== NOT EXECUTED
40004010: 01 00 00 00 nop <== NOT EXECUTED
40004014: 38 80 00 07 bgu,a 40004030 <rtems_termios_ioctl+0xa4> <== NOT EXECUTED
40004018: 03 10 01 1d sethi %hi(0x40047400), %g1 <== NOT EXECUTED
4000401c: 80 a0 a0 05 cmp %g2, 5 <== NOT EXECUTED
40004020: 32 80 00 0c bne,a 40004050 <rtems_termios_ioctl+0xc4> <== NOT EXECUTED
40004024: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
40004028: 10 80 00 a5 b 400042bc <rtems_termios_ioctl+0x330> <== NOT EXECUTED
4000402c: c2 04 00 00 ld [ %l0 ], %g1 <== 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) {
40004030: 82 10 60 1a or %g1, 0x1a, %g1 <== NOT EXECUTED
40004034: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40004038: 02 80 00 c2 be 40004340 <rtems_termios_ioctl+0x3b4> <== NOT EXECUTED
4000403c: 03 20 01 1d sethi %hi(0x80047400), %g1 <== NOT EXECUTED
40004040: 82 10 60 1b or %g1, 0x1b, %g1 ! 8004741b <LEON_REG+0x4741b><== NOT EXECUTED
40004044: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40004048: 02 80 00 a5 be 400042dc <rtems_termios_ioctl+0x350> <== NOT EXECUTED
4000404c: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
40004050: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
40004054: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED
40004058: 82 10 63 80 or %g1, 0x380, %g1 <== NOT EXECUTED
4000405c: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
40004060: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
40004064: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004068: 02 80 00 c7 be 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
4000406c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
40004070: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40004074: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004078: 92 10 00 12 mov %l2, %o1 <== 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) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
4000407c: 10 80 00 c2 b 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
40004080: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
40004084: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED
40004088: 40 00 22 23 call 4000c914 <memcpy> <== NOT EXECUTED
4000408c: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED
40004090: 30 80 00 bd b,a 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
40004094: 90 04 60 30 add %l1, 0x30, %o0 <== NOT EXECUTED
40004098: 40 00 22 1f call 4000c914 <memcpy> <== NOT EXECUTED
4000409c: 94 10 20 24 mov 0x24, %o2 <== 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) &&
400040a0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400040a4: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
400040a8: 02 80 00 20 be 40004128 <rtems_termios_ioctl+0x19c> <== NOT EXECUTED
400040ac: 01 00 00 00 nop <== NOT EXECUTED
400040b0: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED
400040b4: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED
400040b8: 12 80 00 1c bne 40004128 <rtems_termios_ioctl+0x19c> <== NOT EXECUTED
400040bc: 01 00 00 00 nop <== NOT EXECUTED
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
400040c0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400040c4: 82 08 7d ef and %g1, -529, %g1 <== NOT EXECUTED
400040c8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
400040cc: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400040d0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
400040d4: 02 80 00 15 be 40004128 <rtems_termios_ioctl+0x19c> <== NOT EXECUTED
400040d8: 01 00 00 00 nop <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
400040dc: 7f ff f7 00 call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
400040e0: 01 00 00 00 nop <== NOT EXECUTED
400040e4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
400040e8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400040ec: c4 04 60 94 ld [ %l1 + 0x94 ], %g2 <== 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;
400040f0: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
400040f4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
400040f8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
400040fc: 02 80 00 09 be 40004120 <rtems_termios_ioctl+0x194> <== NOT EXECUTED
40004100: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
40004104: d2 04 60 84 ld [ %l1 + 0x84 ], %o1 <== NOT EXECUTED
40004108: c2 04 60 7c ld [ %l1 + 0x7c ], %g1 <== NOT EXECUTED
4000410c: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 <== NOT EXECUTED
40004110: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
40004114: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
40004118: 9f c0 80 00 call %g2 <== NOT EXECUTED
4000411c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
40004120: 7f ff f6 f3 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40004124: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
40004128: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
4000412c: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED
40004130: 02 80 00 0c be 40004160 <rtems_termios_ioctl+0x1d4> <== NOT EXECUTED
40004134: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
40004138: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
4000413c: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
40004140: 12 80 00 08 bne 40004160 <rtems_termios_ioctl+0x1d4> <== NOT EXECUTED
40004144: 01 00 00 00 nop <== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
40004148: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
4000414c: 82 08 7b ff and %g1, -1025, %g1 <== NOT EXECUTED
40004150: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
40004154: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
40004158: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
4000415c: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
40004160: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
40004164: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40004168: 02 80 00 16 be 400041c0 <rtems_termios_ioctl+0x234> <== NOT EXECUTED
4000416c: c2 04 60 38 ld [ %l1 + 0x38 ], %g1 <== NOT EXECUTED
40004170: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004174: 06 80 00 14 bl 400041c4 <rtems_termios_ioctl+0x238> <== NOT EXECUTED
40004178: 01 00 00 00 nop <== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
4000417c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
40004180: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
40004184: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
40004188: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
4000418c: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
40004190: 02 80 00 08 be 400041b0 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
40004194: 01 00 00 00 nop <== NOT EXECUTED
40004198: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED
4000419c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400041a0: 02 80 00 04 be 400041b0 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
400041a4: 01 00 00 00 nop <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
400041a8: 9f c0 40 00 call %g1 <== NOT EXECUTED
400041ac: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
400041b0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400041b4: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
400041b8: c2 24 60 b8 st %g1, [ %l1 + 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) {
400041bc: c2 04 60 38 ld [ %l1 + 0x38 ], %g1 <== NOT EXECUTED
400041c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400041c4: 36 80 00 06 bge,a 400041dc <rtems_termios_ioctl+0x250> <== NOT EXECUTED
400041c8: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
400041cc: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400041d0: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
400041d4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
400041d8: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
400041dc: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
400041e0: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
400041e4: 22 80 00 06 be,a 400041fc <rtems_termios_ioctl+0x270> <== NOT EXECUTED
400041e8: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
400041ec: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
400041f0: 82 10 64 00 or %g1, 0x400, %g1 <== NOT EXECUTED
400041f4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
400041f8: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED
400041fc: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED
40004200: 22 80 00 06 be,a 40004218 <rtems_termios_ioctl+0x28c> <== NOT EXECUTED
40004204: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
40004208: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
4000420c: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED
40004210: c2 24 60 b8 st %g1, [ %l1 + 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) {
40004214: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED
40004218: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
4000421c: 32 80 00 19 bne,a 40004280 <rtems_termios_ioctl+0x2f4> <== NOT EXECUTED
40004220: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
rtems_interval ticksPerSecond;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
40004224: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
40004228: 40 00 02 22 call 40004ab0 <rtems_clock_get> <== NOT EXECUTED
4000422c: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
40004230: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
40004234: e0 0c 60 46 ldub [ %l1 + 0x46 ], %l0 <== NOT EXECUTED
40004238: 40 00 3b 5b call 40012fa4 <.umul> <== NOT EXECUTED
4000423c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40004240: 40 00 3b 93 call 4001308c <.udiv> <== NOT EXECUTED
40004244: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
40004248: d0 24 60 54 st %o0, [ %l1 + 0x54 ] <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
4000424c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
40004250: 02 80 00 08 be 40004270 <rtems_termios_ioctl+0x2e4> <== NOT EXECUTED
40004254: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
40004258: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
4000425c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004260: 12 80 00 09 bne 40004284 <rtems_termios_ioctl+0x2f8> <== NOT EXECUTED
40004264: d0 24 60 70 st %o0, [ %l1 + 0x70 ] <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
40004268: 10 80 00 0a b 40004290 <rtems_termios_ioctl+0x304> <== NOT EXECUTED
4000426c: d0 24 60 74 st %o0, [ %l1 + 0x74 ] <== NOT EXECUTED
}
else {
if (tty->termios.c_cc[VMIN]) {
40004270: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004274: 02 80 00 06 be 4000428c <rtems_termios_ioctl+0x300> <== NOT EXECUTED
40004278: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4000427c: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
40004280: c0 24 60 70 clr [ %l1 + 0x70 ] <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
40004284: 10 80 00 03 b 40004290 <rtems_termios_ioctl+0x304> <== NOT EXECUTED
40004288: c0 24 60 74 clr [ %l1 + 0x74 ] <== NOT EXECUTED
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
4000428c: c2 24 60 6c st %g1, [ %l1 + 0x6c ] <== NOT EXECUTED
}
}
}
if (tty->device.setAttributes)
40004290: c2 04 60 a8 ld [ %l1 + 0xa8 ], %g1 <== NOT EXECUTED
40004294: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004298: 02 80 00 3b be 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
4000429c: 01 00 00 00 nop <== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
400042a0: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
400042a4: 9f c0 40 00 call %g1 <== NOT EXECUTED
400042a8: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED
400042ac: 30 80 00 36 b,a 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
400042b0: 7f ff fe 19 call 40003b14 <drainOutput> <== NOT EXECUTED
400042b4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
400042b8: 30 80 00 33 b,a 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
400042bc: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] <== NOT EXECUTED
400042c0: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
400042c4: 10 80 00 30 b 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
400042c8: c2 24 60 d8 st %g1, [ %l1 + 0xd8 ] <== NOT EXECUTED
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
400042cc: c2 24 60 dc st %g1, [ %l1 + 0xdc ] <== NOT EXECUTED
400042d0: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
400042d4: 10 80 00 2c b 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
400042d8: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
400042dc: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
400042e0: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED
400042e4: 82 10 63 80 or %g1, 0x380, %g1 <== NOT EXECUTED
400042e8: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
400042ec: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
400042f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400042f4: 22 80 00 06 be,a 4000430c <rtems_termios_ioctl+0x380> <== NOT EXECUTED
400042f8: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
400042fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004300: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40004304: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
40004308: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
4000430c: c0 24 60 d0 clr [ %l1 + 0xd0 ] <== 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);
40004310: c6 00 40 00 ld [ %g1 ], %g3 <== 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) {
40004314: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
40004318: 85 28 e0 05 sll %g3, 5, %g2 <== NOT EXECUTED
4000431c: 82 10 63 80 or %g1, 0x380, %g1 <== NOT EXECUTED
40004320: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED
40004324: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004328: 02 80 00 17 be 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
4000432c: c6 24 60 cc st %g3, [ %l1 + 0xcc ] <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
40004330: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004334: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
40004338: 10 80 00 13 b 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
4000433c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
40004340: c4 04 a0 08 ld [ %l2 + 8 ], %g2 <== NOT EXECUTED
40004344: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED
40004348: 10 80 00 0f b 40004384 <rtems_termios_ioctl+0x3f8> <== NOT EXECUTED
4000434c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
40004350: c4 04 60 60 ld [ %l1 + 0x60 ], %g2 <== NOT EXECUTED
40004354: c2 04 60 5c ld [ %l1 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
40004358: 88 a0 80 01 subcc %g2, %g1, %g4 <== NOT EXECUTED
4000435c: 3c 80 00 05 bpos,a 40004370 <rtems_termios_ioctl+0x3e4> <== NOT EXECUTED
40004360: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
40004364: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 <== NOT EXECUTED
40004368: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
4000436c: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED
40004370: c4 04 60 24 ld [ %l1 + 0x24 ], %g2 <== NOT EXECUTED
40004374: c6 04 a0 08 ld [ %l2 + 8 ], %g3 <== NOT EXECUTED
40004378: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
4000437c: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED
40004380: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
40004384: 40 00 04 60 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40004388: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED
args->ioctl_return = sc;
4000438c: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED
return sc;
}
40004390: 81 c7 e0 08 ret <== NOT EXECUTED
40004394: 81 e8 00 00 restore <== NOT EXECUTED
40004548 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
40004548: 9d e3 bf 98 save %sp, -104, %sp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
4000454c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004550: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 40017d88 <rtems_termios_ttyMutex>
40004554: 92 10 20 00 clr %o1
40004558: 40 00 03 a4 call 400053e8 <rtems_semaphore_obtain>
4000455c: 94 10 20 00 clr %o2
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
40004560: a6 92 20 00 orcc %o0, 0, %l3
40004564: 12 80 01 0a bne 4000498c <rtems_termios_open+0x444> <== NEVER TAKEN
40004568: 03 10 00 5f sethi %hi(0x40017c00), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
4000456c: 10 80 00 0a b 40004594 <rtems_termios_open+0x4c>
40004570: e2 00 61 90 ld [ %g1 + 0x190 ], %l1 ! 40017d90 <rtems_termios_ttyHead>
if ((tty->major == major) && (tty->minor == minor))
40004574: 80 a0 40 18 cmp %g1, %i0
40004578: 32 80 00 07 bne,a 40004594 <rtems_termios_open+0x4c> <== NEVER TAKEN
4000457c: e2 04 40 00 ld [ %l1 ], %l1 <== NOT EXECUTED
40004580: c2 04 60 10 ld [ %l1 + 0x10 ], %g1
40004584: 80 a0 40 19 cmp %g1, %i1
40004588: 22 80 00 da be,a 400048f0 <rtems_termios_open+0x3a8> <== ALWAYS TAKEN
4000458c: c2 04 60 08 ld [ %l1 + 8 ], %g1
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
40004590: e2 04 40 00 ld [ %l1 ], %l1 <== NOT EXECUTED
40004594: 80 a4 60 00 cmp %l1, 0
40004598: 32 bf ff f7 bne,a 40004574 <rtems_termios_open+0x2c>
4000459c: c2 04 60 0c ld [ %l1 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
400045a0: 10 80 00 fd b 40004994 <rtems_termios_open+0x44c>
400045a4: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
400045a8: 03 10 00 5d sethi %hi(0x40017400), %g1
400045ac: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 40017670 <rtems_termios_raw_input_size>
400045b0: c2 24 60 64 st %g1, [ %l1 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
400045b4: d0 04 60 64 ld [ %l1 + 0x64 ], %o0
400045b8: 40 00 17 9c call 4000a428 <malloc>
400045bc: 01 00 00 00 nop
if (tty->rawInBuf.theBuf == NULL) {
400045c0: 80 a2 20 00 cmp %o0, 0
400045c4: 12 80 00 08 bne 400045e4 <rtems_termios_open+0x9c> <== ALWAYS TAKEN
400045c8: d0 24 60 58 st %o0, [ %l1 + 0x58 ]
free(tty);
400045cc: 40 00 16 37 call 40009ea8 <free> <== NOT EXECUTED
400045d0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
400045d4: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
400045d8: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED
400045dc: 10 80 00 ea b 40004984 <rtems_termios_open+0x43c> <== NOT EXECUTED
400045e0: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
400045e4: 03 10 00 5d sethi %hi(0x40017400), %g1
400045e8: c2 00 62 74 ld [ %g1 + 0x274 ], %g1 ! 40017674 <rtems_termios_raw_output_size>
400045ec: c2 24 60 88 st %g1, [ %l1 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
400045f0: d0 04 60 88 ld [ %l1 + 0x88 ], %o0
400045f4: 40 00 17 8d call 4000a428 <malloc>
400045f8: 01 00 00 00 nop
if (tty->rawOutBuf.theBuf == NULL) {
400045fc: 80 a2 20 00 cmp %o0, 0
40004600: 12 80 00 05 bne 40004614 <rtems_termios_open+0xcc> <== ALWAYS TAKEN
40004604: d0 24 60 7c st %o0, [ %l1 + 0x7c ]
free((void *)(tty->rawInBuf.theBuf));
40004608: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
4000460c: 10 80 00 0c b 4000463c <rtems_termios_open+0xf4> <== NOT EXECUTED
40004610: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
40004614: 03 10 00 5d sethi %hi(0x40017400), %g1
40004618: 40 00 17 84 call 4000a428 <malloc>
4000461c: d0 00 62 6c ld [ %g1 + 0x26c ], %o0 ! 4001766c <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
40004620: 80 a2 20 00 cmp %o0, 0
40004624: 12 80 00 0c bne 40004654 <rtems_termios_open+0x10c> <== ALWAYS TAKEN
40004628: d0 24 60 1c st %o0, [ %l1 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
4000462c: d0 04 60 7c ld [ %l1 + 0x7c ], %o0 <== NOT EXECUTED
40004630: 40 00 16 1e call 40009ea8 <free> <== NOT EXECUTED
40004634: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
40004638: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED
4000463c: 40 00 16 1b call 40009ea8 <free> <== NOT EXECUTED
40004640: 01 00 00 00 nop <== NOT EXECUTED
free(tty);
40004644: 40 00 16 19 call 40009ea8 <free> <== NOT EXECUTED
40004648: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
4000464c: 10 80 00 cd b 40004980 <rtems_termios_open+0x438> <== NOT EXECUTED
40004650: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40004654: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004658: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 40017d90 <rtems_termios_ttyHead>
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
4000465c: c0 24 60 d4 clr [ %l1 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
40004660: c0 24 60 d8 clr [ %l1 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
40004664: c0 24 60 dc clr [ %l1 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
40004668: c0 24 60 e0 clr [ %l1 + 0xe0 ]
tty->tty_rcvwakeup = 0;
4000466c: c0 24 60 e4 clr [ %l1 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
40004670: c2 24 40 00 st %g1, [ %l1 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
40004674: 80 a0 60 00 cmp %g1, 0
40004678: 02 80 00 03 be 40004684 <rtems_termios_open+0x13c> <== ALWAYS TAKEN
4000467c: c0 24 60 04 clr [ %l1 + 4 ]
rtems_termios_ttyHead->back = tty;
40004680: e2 20 60 04 st %l1, [ %g1 + 4 ] <== NOT EXECUTED
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
40004684: 07 10 00 5f sethi %hi(0x40017c00), %g3
40004688: c4 00 e1 8c ld [ %g3 + 0x18c ], %g2 ! 40017d8c <rtems_termios_ttyTail>
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
4000468c: 03 10 00 5f sethi %hi(0x40017c00), %g1
if (rtems_termios_ttyTail == NULL)
40004690: 80 a0 a0 00 cmp %g2, 0
40004694: 12 80 00 03 bne 400046a0 <rtems_termios_open+0x158> <== NEVER TAKEN
40004698: e0 20 61 90 st %l0, [ %g1 + 0x190 ]
rtems_termios_ttyTail = tty;
4000469c: e0 20 e1 8c st %l0, [ %g3 + 0x18c ]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
400046a0: 25 10 00 5d sethi %hi(0x40017400), %l2
400046a4: c2 4c a2 78 ldsb [ %l2 + 0x278 ], %g1 ! 40017678 <c.6053>
400046a8: 11 15 14 9a sethi %hi(0x54526800), %o0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
400046ac: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
tty->major = major;
400046b0: f0 24 20 0c st %i0, [ %l0 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
400046b4: 90 12 21 00 or %o0, 0x100, %o0
400046b8: 92 10 20 01 mov 1, %o1
400046bc: 90 10 40 08 or %g1, %o0, %o0
400046c0: 94 10 20 54 mov 0x54, %o2
400046c4: 96 10 20 00 clr %o3
400046c8: 40 00 02 a2 call 40005150 <rtems_semaphore_create>
400046cc: 98 04 20 14 add %l0, 0x14, %o4
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)
400046d0: 80 a2 20 00 cmp %o0, 0
400046d4: 12 80 00 a8 bne 40004974 <rtems_termios_open+0x42c> <== NEVER TAKEN
400046d8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
400046dc: c2 4c a2 78 ldsb [ %l2 + 0x278 ], %g1
400046e0: 11 15 14 9b sethi %hi(0x54526c00), %o0
400046e4: 92 10 20 01 mov 1, %o1
400046e8: 90 12 23 00 or %o0, 0x300, %o0
400046ec: 94 10 20 54 mov 0x54, %o2
400046f0: 90 10 40 08 or %g1, %o0, %o0
400046f4: 96 10 20 00 clr %o3
400046f8: 40 00 02 96 call 40005150 <rtems_semaphore_create>
400046fc: 98 04 20 18 add %l0, 0x18, %o4
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)
40004700: 80 a2 20 00 cmp %o0, 0
40004704: 12 80 00 9c bne 40004974 <rtems_termios_open+0x42c> <== NEVER TAKEN
40004708: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
4000470c: c2 4c a2 78 ldsb [ %l2 + 0x278 ], %g1
40004710: 11 15 14 9e sethi %hi(0x54527800), %o0
40004714: 92 10 20 00 clr %o1
40004718: 90 10 40 08 or %g1, %o0, %o0
4000471c: 94 10 20 20 mov 0x20, %o2
40004720: 96 10 20 00 clr %o3
40004724: 40 00 02 8b call 40005150 <rtems_semaphore_create>
40004728: 98 04 20 8c add %l0, 0x8c, %o4
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
4000472c: 80 a2 20 00 cmp %o0, 0
40004730: 12 80 00 91 bne 40004974 <rtems_termios_open+0x42c> <== NEVER TAKEN
40004734: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
40004738: c0 24 20 94 clr [ %l0 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
4000473c: 92 10 00 1b mov %i3, %o1
40004740: 90 04 20 98 add %l0, 0x98, %o0
40004744: 40 00 20 74 call 4000c914 <memcpy>
40004748: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4000474c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
40004750: 80 a0 60 02 cmp %g1, 2
40004754: 32 80 00 1b bne,a 400047c0 <rtems_termios_open+0x278> <== ALWAYS TAKEN
40004758: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1
sc = rtems_task_create (
4000475c: c2 4c a2 78 ldsb [ %l2 + 0x278 ], %g1 <== NOT EXECUTED
40004760: 11 15 1e 15 sethi %hi(0x54785400), %o0 <== NOT EXECUTED
40004764: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
40004768: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
4000476c: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED
40004770: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED
40004774: 98 10 20 00 clr %o4 <== NOT EXECUTED
40004778: 40 00 03 8f call 400055b4 <rtems_task_create> <== NOT EXECUTED
4000477c: 9a 04 20 c8 add %l0, 0xc8, %o5 <== 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)
40004780: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004784: 12 80 00 7c bne 40004974 <rtems_termios_open+0x42c> <== NOT EXECUTED
40004788: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
4000478c: c2 4c a2 78 ldsb [ %l2 + 0x278 ], %g1 <== NOT EXECUTED
40004790: 11 14 9e 15 sethi %hi(0x52785400), %o0 <== NOT EXECUTED
40004794: 92 10 20 09 mov 9, %o1 <== NOT EXECUTED
40004798: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
4000479c: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED
400047a0: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED
400047a4: 98 10 20 00 clr %o4 <== NOT EXECUTED
400047a8: 40 00 03 83 call 400055b4 <rtems_task_create> <== NOT EXECUTED
400047ac: 9a 04 20 c4 add %l0, 0xc4, %o5 <== 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)
400047b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400047b4: 12 80 00 70 bne 40004974 <rtems_termios_open+0x42c> <== NOT EXECUTED
400047b8: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
400047bc: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
400047c0: 80 a0 60 00 cmp %g1, 0
400047c4: 02 80 00 07 be 400047e0 <rtems_termios_open+0x298> <== NEVER TAKEN
400047c8: 03 10 00 5d sethi %hi(0x40017400), %g1
400047cc: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
400047d0: 80 a0 60 02 cmp %g1, 2
400047d4: 12 80 00 0f bne 40004810 <rtems_termios_open+0x2c8> <== ALWAYS TAKEN
400047d8: 82 10 20 03 mov 3, %g1
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
400047dc: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
400047e0: c2 48 62 78 ldsb [ %g1 + 0x278 ], %g1 ! 40017678 <c.6053> <== NOT EXECUTED
400047e4: 11 15 14 9c sethi %hi(0x54527000), %o0 <== NOT EXECUTED
400047e8: 92 10 20 00 clr %o1 <== NOT EXECUTED
400047ec: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
400047f0: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED
400047f4: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
400047f8: 96 10 20 00 clr %o3 <== NOT EXECUTED
400047fc: 40 00 02 55 call 40005150 <rtems_semaphore_create> <== NOT EXECUTED
40004800: 98 04 20 68 add %l0, 0x68, %o4 <== 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)
40004804: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004808: 12 80 00 5b bne 40004974 <rtems_termios_open+0x42c> <== NOT EXECUTED
4000480c: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
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 = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
40004810: c2 2c 20 41 stb %g1, [ %l0 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
40004814: 82 10 20 1c mov 0x1c, %g1
40004818: c2 2c 20 42 stb %g1, [ %l0 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
4000481c: 82 10 20 7f mov 0x7f, %g1
40004820: c2 2c 20 43 stb %g1, [ %l0 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
40004824: 82 10 20 15 mov 0x15, %g1
40004828: c2 2c 20 44 stb %g1, [ %l0 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
4000482c: 82 10 20 04 mov 4, %g1
40004830: c2 2c 20 45 stb %g1, [ %l0 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
40004834: 82 10 20 11 mov 0x11, %g1
40004838: c2 2c 20 49 stb %g1, [ %l0 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
4000483c: 82 10 20 13 mov 0x13, %g1
40004840: c2 2c 20 4a stb %g1, [ %l0 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
40004844: 82 10 20 1a mov 0x1a, %g1
40004848: c2 2c 20 4b stb %g1, [ %l0 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
4000484c: 82 10 20 12 mov 0x12, %g1
40004850: c2 2c 20 4d stb %g1, [ %l0 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
40004854: 82 10 20 0f mov 0xf, %g1
40004858: c2 2c 20 4e stb %g1, [ %l0 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
4000485c: 82 10 20 17 mov 0x17, %g1
40004860: c2 2c 20 4f stb %g1, [ %l0 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
40004864: 82 10 20 16 mov 0x16, %g1
40004868: c2 2c 20 50 stb %g1, [ %l0 + 0x50 ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
4000486c: 03 00 00 09 sethi %hi(0x2400), %g1
40004870: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
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';
40004874: c0 2c 20 4c clrb [ %l0 + 0x4c ]
tty->termios.c_cc[VEOL2] = '\000';
40004878: c0 2c 20 51 clrb [ %l0 + 0x51 ]
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
4000487c: 1b 10 00 5d sethi %hi(0x40017400), %o5
40004880: c4 0b 62 78 ldub [ %o5 + 0x278 ], %g2 ! 40017678 <c.6053>
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
40004884: c2 24 20 30 st %g1, [ %l0 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
40004888: 03 00 00 06 sethi %hi(0x1800), %g1
4000488c: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
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;
40004890: c0 24 20 b8 clr [ %l0 + 0xb8 ]
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
40004894: c2 24 20 34 st %g1, [ %l0 + 0x34 ]
/* 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;
40004898: c6 04 20 64 ld [ %l0 + 0x64 ], %g3
/*
* 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;
4000489c: 82 10 28 bd mov 0x8bd, %g1
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;
400048a0: c8 04 20 64 ld [ %l0 + 0x64 ], %g4
/*
* 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;
400048a4: c2 24 20 38 st %g1, [ %l0 + 0x38 ]
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
400048a8: 03 00 00 20 sethi %hi(0x8000), %g1
400048ac: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
/* 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;
400048b0: 87 30 e0 01 srl %g3, 1, %g3
* 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 = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
400048b4: c2 24 20 3c st %g1, [ %l0 + 0x3c ]
/* 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;
400048b8: c6 24 20 bc st %g3, [ %l0 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
400048bc: 83 29 20 01 sll %g4, 1, %g1
400048c0: 82 00 40 04 add %g1, %g4, %g1
400048c4: 83 30 60 02 srl %g1, 2, %g1
400048c8: c2 24 20 c0 st %g1, [ %l0 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
400048cc: 82 00 a0 01 add %g2, 1, %g1
400048d0: 85 28 a0 18 sll %g2, 0x18, %g2
400048d4: 85 38 a0 18 sra %g2, 0x18, %g2
400048d8: 80 a0 a0 7a cmp %g2, 0x7a
400048dc: 12 80 00 04 bne 400048ec <rtems_termios_open+0x3a4> <== ALWAYS TAKEN
400048e0: c2 2b 62 78 stb %g1, [ %o5 + 0x278 ]
c = 'a';
400048e4: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED
400048e8: c2 2b 62 78 stb %g1, [ %o5 + 0x278 ] <== NOT EXECUTED
}
args->iop->data1 = tty;
if (!tty->refcount++) {
400048ec: c2 04 60 08 ld [ %l1 + 8 ], %g1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
400048f0: c4 06 80 00 ld [ %i2 ], %g2
if (!tty->refcount++) {
400048f4: 86 00 60 01 add %g1, 1, %g3
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
400048f8: e2 20 a0 28 st %l1, [ %g2 + 0x28 ]
if (!tty->refcount++) {
400048fc: 80 a0 60 00 cmp %g1, 0
40004900: 12 80 00 1f bne 4000497c <rtems_termios_open+0x434>
40004904: c6 24 60 08 st %g3, [ %l1 + 8 ]
if (tty->device.firstOpen)
40004908: c2 04 60 98 ld [ %l1 + 0x98 ], %g1
4000490c: 80 a0 60 00 cmp %g1, 0
40004910: 02 80 00 05 be 40004924 <rtems_termios_open+0x3dc> <== ALWAYS TAKEN
40004914: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
40004918: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
4000491c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004920: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
40004924: c2 04 60 b4 ld [ %l1 + 0xb4 ], %g1
40004928: 80 a0 60 02 cmp %g1, 2
4000492c: 12 80 00 15 bne 40004980 <rtems_termios_open+0x438> <== ALWAYS TAKEN
40004930: 03 10 00 5f sethi %hi(0x40017c00), %g1
sc = rtems_task_start(tty->rxTaskId,
40004934: d0 04 60 c4 ld [ %l1 + 0xc4 ], %o0 <== NOT EXECUTED
40004938: 13 10 00 12 sethi %hi(0x40004800), %o1 <== NOT EXECUTED
4000493c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40004940: 40 00 03 c9 call 40005864 <rtems_task_start> <== NOT EXECUTED
40004944: 92 12 62 2c or %o1, 0x22c, %o1 <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004948: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000494c: 12 80 00 0a bne 40004974 <rtems_termios_open+0x42c> <== NOT EXECUTED
40004950: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
40004954: d0 04 60 c8 ld [ %l1 + 0xc8 ], %o0 <== NOT EXECUTED
40004958: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4000495c: 13 10 00 12 sethi %hi(0x40004800), %o1 <== NOT EXECUTED
40004960: 40 00 03 c1 call 40005864 <rtems_task_start> <== NOT EXECUTED
40004964: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 400049b0 <rtems_termios_txdaemon><== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
40004968: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000496c: 02 80 00 05 be 40004980 <rtems_termios_open+0x438> <== NOT EXECUTED
40004970: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40004974: 40 00 04 5d call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40004978: 01 00 00 00 nop <== NOT EXECUTED
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
4000497c: 03 10 00 5f sethi %hi(0x40017c00), %g1
40004980: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 40017d88 <rtems_termios_ttyMutex>
40004984: 40 00 02 e0 call 40005504 <rtems_semaphore_release>
40004988: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
4000498c: 81 c7 e0 08 ret
40004990: 91 e8 00 13 restore %g0, %l3, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
40004994: 40 00 14 fb call 40009d80 <calloc>
40004998: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
4000499c: a2 92 20 00 orcc %o0, 0, %l1
400049a0: 12 bf ff 02 bne 400045a8 <rtems_termios_open+0x60> <== ALWAYS TAKEN
400049a4: a0 10 00 11 mov %l1, %l0
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
400049a8: 10 bf ff 0c b 400045d8 <rtems_termios_open+0x90> <== NOT EXECUTED
400049ac: 03 10 00 5f sethi %hi(0x40017c00), %g1 <== NOT EXECUTED
400032c8 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
400032c8: 9d e3 bf 98 save %sp, -104, %sp
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
400032cc: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
400032d0: 92 10 00 18 mov %i0, %o1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
400032d4: 80 a0 60 00 cmp %g1, 0
400032d8: 12 80 00 08 bne 400032f8 <rtems_termios_puts+0x30> <== NEVER TAKEN
400032dc: a2 10 00 18 mov %i0, %l1
(*tty->device.write)(tty->minor, (void *)buf, len);
400032e0: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
400032e4: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
400032e8: 9f c0 40 00 call %g1
400032ec: 94 10 00 19 mov %i1, %o2
400032f0: 81 c7 e0 08 ret
400032f4: 81 e8 00 00 restore
return;
}
newHead = tty->rawOutBuf.Head;
400032f8: e0 06 a0 80 ld [ %i2 + 0x80 ], %l0 <== NOT EXECUTED
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
400032fc: a6 10 20 02 mov 2, %l3 <== NOT EXECUTED
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
40003300: 10 80 00 39 b 400033e4 <rtems_termios_puts+0x11c> <== NOT EXECUTED
40003304: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
40003308: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1 <== NOT EXECUTED
4000330c: 40 00 40 0c call 4001333c <.urem> <== NOT EXECUTED
40003310: 90 04 20 01 add %l0, 1, %o0 <== NOT EXECUTED
rtems_interrupt_disable (level);
40003314: 7f ff fa 72 call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40003318: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
4000331c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
40003320: 30 80 00 0f b,a 4000335c <rtems_termios_puts+0x94> <== NOT EXECUTED
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
40003324: 7f ff fa 72 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40003328: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
4000332c: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0 <== NOT EXECUTED
40003330: 92 10 20 00 clr %o1 <== NOT EXECUTED
40003334: 40 00 08 2d call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003338: 94 10 20 00 clr %o2 <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
4000333c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003340: 02 80 00 04 be 40003350 <rtems_termios_puts+0x88> <== NOT EXECUTED
40003344: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
40003348: 40 00 09 e8 call 40005ae8 <rtems_fatal_error_occurred> <== NOT EXECUTED
4000334c: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
40003350: 7f ff fa 63 call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40003354: 01 00 00 00 nop <== NOT EXECUTED
40003358: b0 10 00 08 mov %o0, %i0 <== 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) {
4000335c: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1 <== NOT EXECUTED
40003360: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
40003364: 22 bf ff f0 be,a 40003324 <rtems_termios_puts+0x5c> <== NOT EXECUTED
40003368: e6 26 a0 94 st %l3, [ %i2 + 0x94 ] <== NOT EXECUTED
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
4000336c: c6 06 a0 80 ld [ %i2 + 0x80 ], %g3 <== NOT EXECUTED
40003370: c4 0c 40 00 ldub [ %l1 ], %g2 <== NOT EXECUTED
40003374: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED
40003378: c4 28 40 03 stb %g2, [ %g1 + %g3 ] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
4000337c: c2 06 a0 94 ld [ %i2 + 0x94 ], %g1 <== 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;
40003380: e0 26 a0 80 st %l0, [ %i2 + 0x80 ] <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
40003384: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003388: 32 80 00 14 bne,a 400033d8 <rtems_termios_puts+0x110> <== NOT EXECUTED
4000338c: a2 04 60 01 inc %l1 <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
40003390: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
40003394: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
40003398: 12 80 00 0b bne 400033c4 <rtems_termios_puts+0xfc> <== NOT EXECUTED
4000339c: 01 00 00 00 nop <== NOT EXECUTED
(*tty->device.write)(tty->minor,
400033a0: d2 06 a0 84 ld [ %i2 + 0x84 ], %o1 <== NOT EXECUTED
400033a4: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED
400033a8: c4 06 a0 a4 ld [ %i2 + 0xa4 ], %g2 <== NOT EXECUTED
400033ac: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 <== NOT EXECUTED
400033b0: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
400033b4: 9f c0 80 00 call %g2 <== NOT EXECUTED
400033b8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
400033bc: 10 80 00 06 b 400033d4 <rtems_termios_puts+0x10c> <== NOT EXECUTED
400033c0: e4 26 a0 94 st %l2, [ %i2 + 0x94 ] <== 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;
400033c4: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
400033c8: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
400033cc: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
400033d0: e4 26 a0 94 st %l2, [ %i2 + 0x94 ] <== NOT EXECUTED
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
400033d4: a2 04 60 01 inc %l1 <== NOT EXECUTED
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
400033d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
400033dc: 7f ff fa 44 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
400033e0: b2 06 7f ff add %i1, -1, %i1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
400033e4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
400033e8: 12 bf ff c8 bne 40003308 <rtems_termios_puts+0x40> <== NOT EXECUTED
400033ec: 01 00 00 00 nop <== NOT EXECUTED
400033f0: 81 c7 e0 08 ret <== NOT EXECUTED
400033f4: 81 e8 00 00 restore <== NOT EXECUTED
40003b90 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40003b90: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40003b94: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
uint32_t count = args->count;
40003b98: e6 06 20 0c ld [ %i0 + 0xc ], %l3 <== 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;
40003b9c: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
40003ba0: ea 06 20 08 ld [ %i0 + 8 ], %l5 <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003ba4: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
40003ba8: ac 10 00 18 mov %i0, %l6 <== 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);
40003bac: 92 10 20 00 clr %o1 <== NOT EXECUTED
40003bb0: 40 00 06 0e call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003bb4: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
40003bb8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40003bbc: 12 80 00 10 bne 40003bfc <rtems_termios_read+0x6c> <== NOT EXECUTED
40003bc0: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
40003bc4: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 <== NOT EXECUTED
40003bc8: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED
40003bcc: 82 10 63 80 or %g1, 0x380, %g1 <== NOT EXECUTED
40003bd0: 84 00 a0 08 add %g2, 8, %g2 <== NOT EXECUTED
40003bd4: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED
40003bd8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003bdc: 02 80 00 0a be 40003c04 <rtems_termios_read+0x74> <== NOT EXECUTED
40003be0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
40003be4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003be8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40003bec: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
40003bf0: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
40003bf4: 40 00 06 44 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40003bf8: c0 24 20 e4 clr [ %l0 + 0xe4 ] <== NOT EXECUTED
40003bfc: 81 c7 e0 08 ret <== NOT EXECUTED
40003c00: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
if (tty->cindex == tty->ccount) {
40003c04: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
40003c08: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
40003c0c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003c10: 12 80 00 d0 bne 40003f50 <rtems_termios_read+0x3c0> <== NOT EXECUTED
40003c14: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
40003c18: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
if (tty->device.pollRead != NULL
40003c1c: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
40003c20: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
40003c24: c0 24 20 20 clr [ %l0 + 0x20 ] <== NOT EXECUTED
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
40003c28: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003c2c: 02 80 00 5b be 40003d98 <rtems_termios_read+0x208> <== NOT EXECUTED
40003c30: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED
40003c34: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED
40003c38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003c3c: 12 80 00 58 bne 40003d9c <rtems_termios_read+0x20c> <== NOT EXECUTED
40003c40: 03 10 00 5d sethi %hi(0x40017400), %g1 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
40003c44: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
40003c48: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40003c4c: 22 80 00 13 be,a 40003c98 <rtems_termios_read+0x108> <== NOT EXECUTED
40003c50: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40003c54: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
40003c58: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003c5c: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
if (n < 0) {
40003c60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003c64: 16 80 00 06 bge 40003c7c <rtems_termios_read+0xec> <== NOT EXECUTED
40003c68: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
rtems_task_wake_after (1);
40003c6c: 40 00 07 19 call 400058d0 <rtems_task_wake_after> <== NOT EXECUTED
40003c70: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40003c74: 10 bf ff f9 b 40003c58 <rtems_termios_read+0xc8> <== NOT EXECUTED
40003c78: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
if (n < 0) {
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
40003c7c: 7f ff ff 63 call 40003a08 <siproc> <== NOT EXECUTED
40003c80: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40003c84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003c88: 22 bf ff f4 be,a 40003c58 <rtems_termios_read+0xc8> <== NOT EXECUTED
40003c8c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
40003c90: 10 80 00 b0 b 40003f50 <rtems_termios_read+0x3c0> <== NOT EXECUTED
40003c94: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
40003c98: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003c9c: 12 80 00 0a bne 40003cc4 <rtems_termios_read+0x134> <== NOT EXECUTED
40003ca0: a4 07 bf f4 add %fp, -12, %l2 <== NOT EXECUTED
40003ca4: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED
40003ca8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003cac: 02 80 00 07 be 40003cc8 <rtems_termios_read+0x138> <== NOT EXECUTED
40003cb0: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
40003cb4: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
40003cb8: 40 00 03 7e call 40004ab0 <rtems_clock_get> <== NOT EXECUTED
40003cbc: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
else {
siproc (n, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
40003cc0: a4 07 bf f4 add %fp, -12, %l2 <== NOT EXECUTED
}
}
else {
if (!tty->termios.c_cc[VTIME])
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
40003cc4: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40003cc8: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
40003ccc: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003cd0: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
if (n < 0) {
40003cd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003cd8: 36 80 00 1e bge,a 40003d50 <rtems_termios_read+0x1c0> <== NOT EXECUTED
40003cdc: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
40003ce0: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED
40003ce4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003ce8: 02 80 00 0a be 40003d10 <rtems_termios_read+0x180> <== NOT EXECUTED
40003cec: c4 0c 20 46 ldub [ %l0 + 0x46 ], %g2 <== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
40003cf0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003cf4: 02 80 00 13 be 40003d40 <rtems_termios_read+0x1b0> <== NOT EXECUTED
40003cf8: 01 00 00 00 nop <== NOT EXECUTED
40003cfc: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
40003d00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003d04: 02 80 00 0f be 40003d40 <rtems_termios_read+0x1b0> <== NOT EXECUTED
40003d08: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
40003d0c: 30 80 00 04 b,a 40003d1c <rtems_termios_read+0x18c> <== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
40003d10: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003d14: 02 80 00 8e be 40003f4c <rtems_termios_read+0x3bc> <== NOT EXECUTED
40003d18: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
40003d1c: 40 00 03 65 call 40004ab0 <rtems_clock_get> <== NOT EXECUTED
40003d20: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
40003d24: c6 04 20 54 ld [ %l0 + 0x54 ], %g3 <== NOT EXECUTED
40003d28: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED
40003d2c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
40003d30: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
40003d34: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
40003d38: 18 80 00 86 bgu 40003f50 <rtems_termios_read+0x3c0> <== NOT EXECUTED
40003d3c: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
break;
}
}
rtems_task_wake_after (1);
40003d40: 40 00 06 e4 call 400058d0 <rtems_task_wake_after> <== NOT EXECUTED
40003d44: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40003d48: 10 bf ff e1 b 40003ccc <rtems_termios_read+0x13c> <== NOT EXECUTED
40003d4c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
}
}
rtems_task_wake_after (1);
}
else {
siproc (n, tty);
40003d50: 7f ff ff 2e call 40003a08 <siproc> <== NOT EXECUTED
40003d54: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
40003d58: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED
40003d5c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
40003d60: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40003d64: 16 80 00 7a bge 40003f4c <rtems_termios_read+0x3bc> <== NOT EXECUTED
40003d68: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
40003d6c: 22 bf ff d8 be,a 40003ccc <rtems_termios_read+0x13c> <== NOT EXECUTED
40003d70: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
40003d74: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED
40003d78: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003d7c: 22 bf ff d4 be,a 40003ccc <rtems_termios_read+0x13c> <== NOT EXECUTED
40003d80: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
40003d84: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
40003d88: 40 00 03 4a call 40004ab0 <rtems_clock_get> <== NOT EXECUTED
40003d8c: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then);
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
40003d90: 10 bf ff cf b 40003ccc <rtems_termios_read+0x13c> <== NOT EXECUTED
40003d94: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40003d98: 03 10 00 5d sethi %hi(0x40017400), %g1 <== 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;
40003d9c: e4 04 20 74 ld [ %l0 + 0x74 ], %l2 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40003da0: ba 10 62 6c or %g1, 0x26c, %i5 <== 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)(tty->minor,
40003da4: ae 04 20 49 add %l0, 0x49, %l7 <== NOT EXECUTED
40003da8: 10 80 00 60 b 40003f28 <rtems_termios_read+0x398> <== NOT EXECUTED
40003dac: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
40003db0: d0 04 20 5c ld [ %l0 + 0x5c ], %o0 <== NOT EXECUTED
40003db4: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED
40003db8: 40 00 3d 61 call 4001333c <.urem> <== NOT EXECUTED
40003dbc: 90 02 20 01 inc %o0 <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
40003dc0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
40003dc4: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
40003dc8: e2 08 40 08 ldub [ %g1 + %o0 ], %l1 <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
40003dcc: d0 24 20 5c st %o0, [ %l0 + 0x5c ] <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
40003dd0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED
40003dd4: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED
40003dd8: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED
40003ddc: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
40003de0: 40 00 3d 57 call 4001333c <.urem> <== NOT EXECUTED
40003de4: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
40003de8: c2 04 20 bc ld [ %l0 + 0xbc ], %g1 <== NOT EXECUTED
40003dec: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
40003df0: 3a 80 00 27 bcc,a 40003e8c <rtems_termios_read+0x2fc> <== NOT EXECUTED
40003df4: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
40003df8: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
40003dfc: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED
40003e00: c2 24 20 b8 st %g1, [ %l0 + 0xb8 ] <== NOT EXECUTED
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
40003e04: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
40003e08: 82 08 62 02 and %g1, 0x202, %g1 <== NOT EXECUTED
40003e0c: 80 a0 62 02 cmp %g1, 0x202 <== NOT EXECUTED
40003e10: 12 80 00 11 bne 40003e54 <rtems_termios_read+0x2c4> <== NOT EXECUTED
40003e14: 01 00 00 00 nop <== NOT EXECUTED
40003e18: c2 04 20 94 ld [ %l0 + 0x94 ], %g1 <== NOT EXECUTED
40003e1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003e20: 22 80 00 07 be,a 40003e3c <rtems_termios_read+0x2ac> <== NOT EXECUTED
40003e24: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED
40003e28: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
40003e2c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
40003e30: 02 80 00 09 be 40003e54 <rtems_termios_read+0x2c4> <== NOT EXECUTED
40003e34: 01 00 00 00 nop <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
40003e38: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED
40003e3c: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
40003e40: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
40003e44: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003e48: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40003e4c: 10 80 00 10 b 40003e8c <rtems_termios_read+0x2fc> <== NOT EXECUTED
40003e50: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
40003e54: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
40003e58: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
40003e5c: 22 80 00 0c be,a 40003e8c <rtems_termios_read+0x2fc> <== NOT EXECUTED
40003e60: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
40003e64: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
40003e68: c4 04 20 b0 ld [ %l0 + 0xb0 ], %g2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
40003e6c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
40003e70: c2 24 20 b8 st %g1, [ %l0 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
40003e74: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40003e78: 22 80 00 05 be,a 40003e8c <rtems_termios_read+0x2fc> <== NOT EXECUTED
40003e7c: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
40003e80: 9f c0 80 00 call %g2 <== NOT EXECUTED
40003e84: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40003e88: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
40003e8c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
40003e90: 02 80 00 09 be 40003eb4 <rtems_termios_read+0x324> <== NOT EXECUTED
40003e94: 90 0c 60 ff and %l1, 0xff, %o0 <== NOT EXECUTED
if (siproc (c, tty))
40003e98: 7f ff fe dc call 40003a08 <siproc> <== NOT EXECUTED
40003e9c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
40003ea0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003ea4: 32 80 00 0c bne,a 40003ed4 <rtems_termios_read+0x344> <== NOT EXECUTED
40003ea8: a8 10 20 00 clr %l4 <== NOT EXECUTED
else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
40003eac: 10 80 00 0b b 40003ed8 <rtems_termios_read+0x348> <== NOT EXECUTED
40003eb0: d4 04 20 70 ld [ %l0 + 0x70 ], %o2 <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
}
else {
siproc (c, tty);
40003eb4: 7f ff fe d5 call 40003a08 <siproc> <== NOT EXECUTED
40003eb8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
40003ebc: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED
40003ec0: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
40003ec4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40003ec8: 26 80 00 04 bl,a 40003ed8 <rtems_termios_read+0x348> <== NOT EXECUTED
40003ecc: d4 04 20 70 ld [ %l0 + 0x70 ], %o2 <== NOT EXECUTED
40003ed0: a8 10 20 00 clr %l4 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
40003ed4: d4 04 20 70 ld [ %l0 + 0x70 ], %o2 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40003ed8: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED
40003edc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED
40003ee0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003ee4: 02 80 00 08 be 40003f04 <rtems_termios_read+0x374> <== NOT EXECUTED
40003ee8: a2 10 00 14 mov %l4, %l1 <== NOT EXECUTED
40003eec: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
40003ef0: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
40003ef4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
40003ef8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003efc: 06 bf ff ad bl 40003db0 <rtems_termios_read+0x220> <== NOT EXECUTED
40003f00: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
40003f04: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
40003f08: 02 80 00 11 be 40003f4c <rtems_termios_read+0x3bc> <== NOT EXECUTED
40003f0c: a4 10 00 0a mov %o2, %l2 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
40003f10: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
40003f14: 40 00 05 35 call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003f18: d2 04 20 6c ld [ %l0 + 0x6c ], %o1 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
40003f1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003f20: 12 80 00 0c bne 40003f50 <rtems_termios_read+0x3c0> <== NOT EXECUTED
40003f24: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
rtems_status_code sc;
int wait = (int)1;
while ( wait ) {
40003f28: a8 10 00 11 mov %l1, %l4 <== NOT EXECUTED
40003f2c: 10 bf ff eb b 40003ed8 <rtems_termios_read+0x348> <== NOT EXECUTED
40003f30: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
40003f34: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
count--;
40003f38: a6 04 ff ff add %l3, -1, %l3 <== NOT EXECUTED
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
40003f3c: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 <== NOT EXECUTED
40003f40: c2 2d 40 00 stb %g1, [ %l5 ] <== NOT EXECUTED
40003f44: c6 24 20 24 st %g3, [ %l0 + 0x24 ] <== NOT EXECUTED
40003f48: aa 05 60 01 inc %l5 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
40003f4c: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
40003f50: 22 80 00 08 be,a 40003f70 <rtems_termios_read+0x3e0> <== NOT EXECUTED
40003f54: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
40003f58: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
40003f5c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
40003f60: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40003f64: 06 bf ff f4 bl 40003f34 <rtems_termios_read+0x3a4> <== NOT EXECUTED
40003f68: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
40003f6c: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
40003f70: c0 24 20 e4 clr [ %l0 + 0xe4 ] <== NOT EXECUTED
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
40003f74: 82 20 40 13 sub %g1, %l3, %g1 <== NOT EXECUTED
40003f78: c2 25 a0 14 st %g1, [ %l6 + 0x14 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
40003f7c: 40 00 05 62 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40003f80: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
return sc;
}
40003f84: 81 c7 e0 08 ret <== NOT EXECUTED
40003f88: 81 e8 00 00 restore <== NOT EXECUTED
40002d3c <rtems_termios_refill_transmitter>:
* 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)
{
40002d3c: 9d e3 bf 98 save %sp, -104, %sp <== 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))
40002d40: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40002d44: 82 08 64 03 and %g1, 0x403, %g1 <== NOT EXECUTED
40002d48: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED
40002d4c: 12 80 00 10 bne 40002d8c <rtems_termios_refill_transmitter+0x50><== NOT EXECUTED
40002d50: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
40002d54: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
40002d58: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40002d5c: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
40002d60: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002d64: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
40002d68: 7f ff fb dd call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40002d6c: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40002d70: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40002d74: c4 06 20 b8 ld [ %i0 + 0xb8 ], %g2 <== NOT EXECUTED
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40002d78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40002d7c: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40002d80: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
40002d84: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40002d88: 30 80 00 12 b,a 40002dd0 <rtems_termios_refill_transmitter+0x94><== NOT EXECUTED
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
40002d8c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
40002d90: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
40002d94: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40002d98: 12 80 00 12 bne 40002de0 <rtems_termios_refill_transmitter+0xa4><== NOT EXECUTED
40002d9c: 92 06 20 49 add %i0, 0x49, %o1 <== 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,
40002da0: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
40002da4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
40002da8: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002dac: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
40002db0: 7f ff fb cb call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40002db4: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
40002db8: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40002dbc: c4 06 20 b8 ld [ %i0 + 0xb8 ], %g2 <== NOT EXECUTED
*/
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40002dc0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40002dc4: 84 08 bf fd and %g2, -3, %g2 <== NOT EXECUTED
*/
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
40002dc8: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
40002dcc: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40002dd0: 7f ff fb c7 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40002dd4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
40002dd8: 81 c7 e0 08 ret <== NOT EXECUTED
40002ddc: 81 e8 00 00 restore <== NOT EXECUTED
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
40002de0: c4 06 20 80 ld [ %i0 + 0x80 ], %g2 <== NOT EXECUTED
40002de4: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 <== NOT EXECUTED
40002de8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40002dec: 12 80 00 0a bne 40002e14 <rtems_termios_refill_transmitter+0xd8><== NOT EXECUTED
40002df0: 01 00 00 00 nop <== NOT EXECUTED
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
40002df4: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
40002df8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40002dfc: 12 bf ff f7 bne 40002dd8 <rtems_termios_refill_transmitter+0x9c><== NOT EXECUTED
40002e00: b0 10 20 00 clr %i0 <== NOT EXECUTED
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40002e04: 40 00 09 c0 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40002e08: d0 04 60 8c ld [ %l1 + 0x8c ], %o0 <== NOT EXECUTED
40002e0c: 81 c7 e0 08 ret <== NOT EXECUTED
40002e10: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
40002e14: 7f ff fb b2 call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40002e18: 01 00 00 00 nop <== NOT EXECUTED
len = tty->t_dqlen;
40002e1c: e0 06 20 90 ld [ %i0 + 0x90 ], %l0 <== NOT EXECUTED
tty->t_dqlen = 0;
40002e20: c0 26 20 90 clr [ %i0 + 0x90 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
40002e24: 7f ff fb b2 call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40002e28: 01 00 00 00 nop <== NOT EXECUTED
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
40002e2c: d0 06 20 84 ld [ %i0 + 0x84 ], %o0 <== NOT EXECUTED
40002e30: d2 06 20 88 ld [ %i0 + 0x88 ], %o1 <== NOT EXECUTED
40002e34: 40 00 41 42 call 4001333c <.urem> <== NOT EXECUTED
40002e38: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
40002e3c: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== 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;
40002e40: d0 24 60 84 st %o0, [ %l1 + 0x84 ] <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
40002e44: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40002e48: 12 80 00 04 bne 40002e58 <rtems_termios_refill_transmitter+0x11c><== NOT EXECUTED
40002e4c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
40002e50: 40 00 09 ad call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40002e54: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
40002e58: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED
40002e5c: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
40002e60: 12 80 00 0c bne 40002e90 <rtems_termios_refill_transmitter+0x154><== NOT EXECUTED
40002e64: 01 00 00 00 nop <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
40002e68: c2 04 60 d4 ld [ %l1 + 0xd4 ], %g1 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
40002e6c: c0 24 60 94 clr [ %l1 + 0x94 ] <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
40002e70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002e74: 02 80 00 2c be 40002f24 <rtems_termios_refill_transmitter+0x1e8><== NOT EXECUTED
40002e78: b0 10 20 00 clr %i0 <== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
40002e7c: d2 04 60 d8 ld [ %l1 + 0xd8 ], %o1 <== NOT EXECUTED
40002e80: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002e84: 90 04 60 30 add %l1, 0x30, %o0 <== NOT EXECUTED
/* 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;
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
40002e88: 10 80 00 27 b 40002f24 <rtems_termios_refill_transmitter+0x1e8><== NOT EXECUTED
40002e8c: b0 10 20 00 clr %i0 <== 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))
40002e90: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
40002e94: 82 08 62 10 and %g1, 0x210, %g1 <== NOT EXECUTED
40002e98: 80 a0 62 10 cmp %g1, 0x210 <== NOT EXECUTED
40002e9c: 12 80 00 0d bne 40002ed0 <rtems_termios_refill_transmitter+0x194><== NOT EXECUTED
40002ea0: 01 00 00 00 nop <== NOT EXECUTED
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
40002ea4: 7f ff fb 8e call 40001cdc <sparc_disable_interrupts> <== NOT EXECUTED
40002ea8: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
40002eac: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40002eb0: 84 10 20 01 mov 1, %g2 <== 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;
40002eb4: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
40002eb8: c4 24 60 94 st %g2, [ %l1 + 0x94 ] <== 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;
40002ebc: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
40002ec0: 7f ff fb 8b call 40001cec <sparc_enable_interrupts> <== NOT EXECUTED
40002ec4: 01 00 00 00 nop <== NOT EXECUTED
40002ec8: 10 80 00 17 b 40002f24 <rtems_termios_refill_transmitter+0x1e8><== NOT EXECUTED
40002ecc: b0 10 20 00 clr %i0 ! 0 <PROM_START> <== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
40002ed0: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED
40002ed4: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
40002ed8: 08 80 00 05 bleu 40002eec <rtems_termios_refill_transmitter+0x1b0><== NOT EXECUTED
40002edc: 01 00 00 00 nop <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
40002ee0: c2 04 60 88 ld [ %l1 + 0x88 ], %g1 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
40002ee4: 10 80 00 04 b 40002ef4 <rtems_termios_refill_transmitter+0x1b8><== NOT EXECUTED
40002ee8: b0 20 40 10 sub %g1, %l0, %i0 <== NOT EXECUTED
40002eec: c2 04 60 80 ld [ %l1 + 0x80 ], %g1 <== NOT EXECUTED
40002ef0: b0 20 40 10 sub %g1, %l0, %i0 <== 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)) {
40002ef4: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
40002ef8: 80 88 66 00 btst 0x600, %g1 <== NOT EXECUTED
40002efc: 32 80 00 02 bne,a 40002f04 <rtems_termios_refill_transmitter+0x1c8><== NOT EXECUTED
40002f00: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
40002f04: d2 04 60 7c ld [ %l1 + 0x7c ], %o1 <== NOT EXECUTED
40002f08: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 <== NOT EXECUTED
40002f0c: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
/* 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;
}
tty->rawOutBufState = rob_busy; /*apm*/
40002f10: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40002f14: 92 02 40 10 add %o1, %l0, %o1 <== NOT EXECUTED
/* 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;
}
tty->rawOutBufState = rob_busy; /*apm*/
40002f18: c2 24 60 94 st %g1, [ %l1 + 0x94 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
40002f1c: 9f c0 80 00 call %g2 <== NOT EXECUTED
40002f20: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
40002f24: e0 24 60 84 st %l0, [ %l1 + 0x84 ] <== NOT EXECUTED
}
return nToSend;
}
40002f28: 81 c7 e0 08 ret <== NOT EXECUTED
40002f2c: 81 e8 00 00 restore <== NOT EXECUTED
40004a2c <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
40004a2c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
40004a30: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
rtems_termios_enqueue_raw_characters (
40004a34: a0 07 bf f7 add %fp, -9, %l0 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
40004a38: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
40004a3c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40004a40: 94 10 20 00 clr %o2 <== NOT EXECUTED
40004a44: 40 00 00 b9 call 40004d28 <rtems_event_receive> <== NOT EXECUTED
40004a48: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
40004a4c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
40004a50: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
40004a54: 22 80 00 07 be,a 40004a70 <rtems_termios_rxdaemon+0x44> <== NOT EXECUTED
40004a58: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
tty->rxTaskId = 0;
40004a5c: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
40004a60: 40 00 03 22 call 400056e8 <rtems_task_delete> <== NOT EXECUTED
40004a64: 90 10 20 00 clr %o0 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
40004a68: 10 bf ff f5 b 40004a3c <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
40004a6c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
40004a70: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004a74: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
if (c != EOF) {
40004a78: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
40004a7c: 02 bf ff ef be 40004a38 <rtems_termios_rxdaemon+0xc> <== NOT EXECUTED
40004a80: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
40004a84: d0 2f bf f7 stb %o0, [ %fp + -9 ] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
40004a88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004a8c: 7f ff f9 48 call 40002fac <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
40004a90: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
40004a94: 10 bf ff ea b 40004a3c <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
40004a98: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
40004a9c: 40 00 4a e8 call 4001763c <libc_global_reent+0x3d4> <== NOT EXECUTED
40004aa0: 40 00 4a f0 call 40017660 <libc_global_reent+0x3f8> <== NOT EXECUTED
40004aa4: 40 00 4a f8 call 40017684 <_RTEMS_tasks_API_extensions+0x4><== NOT EXECUTED
40004aa8: 40 00 4b 08 call 400176c8 <__ctype_ptr> <== NOT EXECUTED
40004aac: 40 00 4b 1c call 4001771c <impure_data+0x44> <== NOT EXECUTED
40002d24 <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);
40002d24: d0 02 20 c4 ld [ %o0 + 0xc4 ], %o0 <== NOT EXECUTED
40002d28: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40002d2c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
40002d30: 40 00 08 60 call 40004eb0 <rtems_event_send> <== NOT EXECUTED
40002d34: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
400049b0 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
400049b0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400049b4: 03 10 00 5e sethi %hi(0x40017800), %g1 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
400049b8: a0 07 bf f4 add %fp, -12, %l0 <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400049bc: a2 10 63 80 or %g1, 0x380, %l1 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
400049c0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
400049c4: 94 10 20 00 clr %o2 <== NOT EXECUTED
400049c8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
400049cc: 40 00 00 d7 call 40004d28 <rtems_event_receive> <== NOT EXECUTED
400049d0: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
400049d4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
400049d8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
400049dc: 02 80 00 07 be 400049f8 <rtems_termios_txdaemon+0x48> <== NOT EXECUTED
400049e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
tty->txTaskId = 0;
400049e4: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
400049e8: 40 00 03 40 call 400056e8 <rtems_task_delete> <== NOT EXECUTED
400049ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
400049f0: 10 bf ff f5 b 400049c4 <rtems_termios_txdaemon+0x14> <== NOT EXECUTED
400049f4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
400049f8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
400049fc: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
40004a00: 82 04 40 01 add %l1, %g1, %g1 <== NOT EXECUTED
40004a04: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
40004a08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004a0c: 02 80 00 04 be 40004a1c <rtems_termios_txdaemon+0x6c> <== NOT EXECUTED
40004a10: 01 00 00 00 nop <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
40004a14: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004a18: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
40004a1c: 7f ff f8 c8 call 40002d3c <rtems_termios_refill_transmitter><== NOT EXECUTED
40004a20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
40004a24: 10 bf ff e8 b 400049c4 <rtems_termios_txdaemon+0x14> <== NOT EXECUTED
40004a28: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
40003a58 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
40003a58: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40003a5c: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003a60: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
40003a64: e4 00 60 28 ld [ %g1 + 0x28 ], %l2
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003a68: 94 10 20 00 clr %o2
40003a6c: 40 00 06 5f call 400053e8 <rtems_semaphore_obtain>
40003a70: d0 04 a0 18 ld [ %l2 + 0x18 ], %o0
if (sc != RTEMS_SUCCESSFUL)
40003a74: a6 92 20 00 orcc %o0, 0, %l3
40003a78: 12 80 00 25 bne 40003b0c <rtems_termios_write+0xb4> <== NEVER TAKEN
40003a7c: 03 10 00 5e sethi %hi(0x40017800), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
40003a80: c4 04 a0 cc ld [ %l2 + 0xcc ], %g2
40003a84: 85 28 a0 05 sll %g2, 5, %g2
40003a88: 82 10 63 80 or %g1, 0x380, %g1
40003a8c: 82 00 40 02 add %g1, %g2, %g1
40003a90: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40003a94: 80 a0 60 00 cmp %g1, 0
40003a98: 02 80 00 06 be 40003ab0 <rtems_termios_write+0x58> <== ALWAYS TAKEN
40003a9c: 92 10 00 18 mov %i0, %o1
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
40003aa0: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003aa4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40003aa8: 10 80 00 17 b 40003b04 <rtems_termios_write+0xac> <== NOT EXECUTED
40003aac: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
40003ab0: c2 04 a0 34 ld [ %l2 + 0x34 ], %g1
40003ab4: d2 06 20 0c ld [ %i0 + 0xc ], %o1
40003ab8: 80 88 60 01 btst 1, %g1
40003abc: 02 80 00 0e be 40003af4 <rtems_termios_write+0x9c> <== NEVER TAKEN
40003ac0: d0 06 20 08 ld [ %i0 + 8 ], %o0
uint32_t count = args->count;
40003ac4: a2 10 00 09 mov %o1, %l1
char *buffer = args->buffer;
40003ac8: 10 80 00 06 b 40003ae0 <rtems_termios_write+0x88>
40003acc: a0 10 00 08 mov %o0, %l0
while (count--)
oproc (*buffer++, tty);
40003ad0: a2 04 7f ff add %l1, -1, %l1
40003ad4: a0 04 20 01 inc %l0
40003ad8: 7f ff fe 48 call 400033f8 <oproc>
40003adc: 92 10 00 12 mov %l2, %o1
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
40003ae0: 80 a4 60 00 cmp %l1, 0
40003ae4: 32 bf ff fb bne,a 40003ad0 <rtems_termios_write+0x78>
40003ae8: d0 0c 00 00 ldub [ %l0 ], %o0
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
40003aec: 10 80 00 05 b 40003b00 <rtems_termios_write+0xa8>
40003af0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
40003af4: 7f ff fd f5 call 400032c8 <rtems_termios_puts> <== NOT EXECUTED
40003af8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
40003afc: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
40003b00: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
}
rtems_semaphore_release (tty->osem);
40003b04: 40 00 06 80 call 40005504 <rtems_semaphore_release>
40003b08: d0 04 a0 18 ld [ %l2 + 0x18 ], %o0
return sc;
}
40003b0c: 81 c7 e0 08 ret
40003b10: 91 e8 00 13 restore %g0, %l3, %o0
40011204 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
Objects_Id id
)
{
40011204: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40011208: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4001120c: 92 10 00 18 mov %i0, %o1
40011210: 90 12 21 50 or %o0, 0x150, %o0
40011214: 40 00 0b 23 call 40013ea0 <_Objects_Get>
40011218: 94 07 bf f4 add %fp, -12, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
4001121c: c2 07 bf f4 ld [ %fp + -12 ], %g1
40011220: 80 a0 60 00 cmp %g1, 0
40011224: 12 80 00 0a bne 4001124c <rtems_timer_cancel+0x48>
40011228: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
4001122c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40011230: 80 a0 60 04 cmp %g1, 4
40011234: 02 80 00 04 be 40011244 <rtems_timer_cancel+0x40> <== NEVER TAKEN
40011238: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
4001123c: 40 00 13 71 call 40016000 <_Watchdog_Remove>
40011240: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
40011244: 40 00 0d 6a call 400147ec <_Thread_Enable_dispatch>
40011248: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001124c: 81 c7 e0 08 ret
40011250: 81 e8 00 00 restore
40011254 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
Objects_Id *id
)
{
40011254: 9d e3 bf 98 save %sp, -104, %sp
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
40011258: a2 96 20 00 orcc %i0, 0, %l1
4001125c: 02 80 00 11 be 400112a0 <rtems_timer_create+0x4c>
40011260: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
40011264: 80 a6 60 00 cmp %i1, 0
40011268: 02 80 00 0e be 400112a0 <rtems_timer_create+0x4c> <== NEVER TAKEN
4001126c: b0 10 20 09 mov 9, %i0
40011270: 05 10 00 c6 sethi %hi(0x40031800), %g2
40011274: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
40011278: 82 00 60 01 inc %g1
4001127c: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
* 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 );
40011280: 21 10 00 c7 sethi %hi(0x40031c00), %l0
40011284: 40 00 09 9b call 400138f0 <_Objects_Allocate>
40011288: 90 14 21 50 or %l0, 0x150, %o0 ! 40031d50 <_Timer_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
4001128c: 80 a2 20 00 cmp %o0, 0
40011290: 32 80 00 06 bne,a 400112a8 <rtems_timer_create+0x54>
40011294: c4 02 20 08 ld [ %o0 + 8 ], %g2
_Thread_Enable_dispatch();
40011298: 40 00 0d 55 call 400147ec <_Thread_Enable_dispatch>
4001129c: b0 10 20 05 mov 5, %i0
400112a0: 81 c7 e0 08 ret
400112a4: 81 e8 00 00 restore
400112a8: 82 14 21 50 or %l0, 0x150, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
400112ac: e2 22 20 0c st %l1, [ %o0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
400112b0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
400112b4: c0 22 20 30 clr [ %o0 + 0x30 ]
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
400112b8: 82 10 20 04 mov 4, %g1
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
400112bc: c4 26 40 00 st %g2, [ %i1 ]
if ( !the_timer ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
400112c0: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
400112c4: 03 00 00 3f sethi %hi(0xfc00), %g1
400112c8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400112cc: 84 08 80 01 and %g2, %g1, %g2
400112d0: 85 28 a0 02 sll %g2, 2, %g2
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400112d4: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
400112d8: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
400112dc: c0 22 20 34 clr [ %o0 + 0x34 ]
400112e0: d0 20 c0 02 st %o0, [ %g3 + %g2 ]
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
400112e4: 40 00 0d 42 call 400147ec <_Thread_Enable_dispatch>
400112e8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
400112ec: 81 c7 e0 08 ret
400112f0: 81 e8 00 00 restore
40011354 <rtems_timer_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011354: 9d e3 bf 90 save %sp, -112, %sp
40011358: a4 10 00 18 mov %i0, %l2
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
4001135c: 80 a6 60 00 cmp %i1, 0
40011360: 02 80 00 1c be 400113d0 <rtems_timer_fire_after+0x7c>
40011364: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
if ( !routine )
40011368: 80 a6 a0 00 cmp %i2, 0
4001136c: 02 80 00 19 be 400113d0 <rtems_timer_fire_after+0x7c> <== NEVER TAKEN
40011370: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
40011374: 11 10 00 c7 sethi %hi(0x40031c00), %o0
40011378: 92 10 00 12 mov %l2, %o1
4001137c: 90 12 21 50 or %o0, 0x150, %o0
40011380: 40 00 0a c8 call 40013ea0 <_Objects_Get>
40011384: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40011388: c2 07 bf f4 ld [ %fp + -12 ], %g1
4001138c: a0 10 00 08 mov %o0, %l0
40011390: 80 a0 60 00 cmp %g1, 0
40011394: 12 80 00 0f bne 400113d0 <rtems_timer_fire_after+0x7c>
40011398: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
4001139c: a2 02 20 10 add %o0, 0x10, %l1
400113a0: 40 00 13 18 call 40016000 <_Watchdog_Remove>
400113a4: 90 10 00 11 mov %l1, %o0
_ISR_Disable( level );
400113a8: 7f ff e8 3b call 4000b494 <sparc_disable_interrupts>
400113ac: 01 00 00 00 nop
/*
* 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 ) {
400113b0: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
400113b4: 80 a0 60 00 cmp %g1, 0
400113b8: 22 80 00 08 be,a 400113d8 <rtems_timer_fire_after+0x84> <== ALWAYS TAKEN
400113bc: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
_ISR_Enable( level );
400113c0: 7f ff e8 39 call 4000b4a4 <sparc_enable_interrupts> <== NOT EXECUTED
400113c4: b0 10 20 00 clr %i0 <== NOT EXECUTED
_Thread_Enable_dispatch();
400113c8: 40 00 0d 09 call 400147ec <_Thread_Enable_dispatch> <== NOT EXECUTED
400113cc: 01 00 00 00 nop <== NOT EXECUTED
400113d0: 81 c7 e0 08 ret
400113d4: 81 e8 00 00 restore
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
400113d8: e4 24 20 30 st %l2, [ %l0 + 0x30 ]
the_watchdog->user_data = user_data;
400113dc: f6 24 20 34 st %i3, [ %l0 + 0x34 ]
/*
* 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;
400113e0: c0 24 20 38 clr [ %l0 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400113e4: c0 24 20 18 clr [ %l0 + 0x18 ]
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
400113e8: 7f ff e8 2f call 4000b4a4 <sparc_enable_interrupts>
400113ec: b0 10 20 00 clr %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
400113f0: 92 10 00 11 mov %l1, %o1
400113f4: 11 10 00 c6 sethi %hi(0x40031800), %o0
400113f8: 90 12 23 10 or %o0, 0x310, %o0 ! 40031b10 <_Watchdog_Ticks_chain>
400113fc: 40 00 12 a7 call 40015e98 <_Watchdog_Insert>
40011400: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
40011404: 40 00 0c fa call 400147ec <_Thread_Enable_dispatch>
40011408: 01 00 00 00 nop
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001140c: 81 c7 e0 08 ret
40011410: 81 e8 00 00 restore
40011414 <rtems_timer_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011414: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
40011418: 03 10 00 c6 sethi %hi(0x40031800), %g1
4001141c: c2 08 62 44 ldub [ %g1 + 0x244 ], %g1 ! 40031a44 <_TOD_Is_set>
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011420: a6 10 00 18 mov %i0, %l3
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
40011424: 80 a0 60 00 cmp %g1, 0
40011428: 02 80 00 2d be 400114dc <rtems_timer_fire_when+0xc8>
4001142c: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
40011430: 7f ff f5 34 call 4000e900 <_TOD_Validate>
40011434: 90 10 00 19 mov %i1, %o0
40011438: 80 8a 20 ff btst 0xff, %o0
4001143c: 02 80 00 2a be 400114e4 <rtems_timer_fire_when+0xd0>
40011440: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_CLOCK;
if ( !routine )
40011444: 02 80 00 26 be 400114dc <rtems_timer_fire_when+0xc8> <== NEVER TAKEN
40011448: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
4001144c: 7f ff f4 fa call 4000e834 <_TOD_To_seconds>
40011450: 90 10 00 19 mov %i1, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
40011454: 25 10 00 c6 sethi %hi(0x40031800), %l2
40011458: c2 04 a2 c0 ld [ %l2 + 0x2c0 ], %g1 ! 40031ac0 <_TOD_Now>
4001145c: 80 a2 00 01 cmp %o0, %g1
40011460: 08 80 00 21 bleu 400114e4 <rtems_timer_fire_when+0xd0>
40011464: a2 10 00 08 mov %o0, %l1
40011468: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4001146c: 92 10 00 13 mov %l3, %o1
40011470: 90 12 21 50 or %o0, 0x150, %o0
40011474: 40 00 0a 8b call 40013ea0 <_Objects_Get>
40011478: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
4001147c: c2 07 bf f4 ld [ %fp + -12 ], %g1
40011480: b2 10 00 08 mov %o0, %i1
40011484: 80 a0 60 00 cmp %g1, 0
40011488: 12 80 00 15 bne 400114dc <rtems_timer_fire_when+0xc8>
4001148c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
40011490: a0 02 20 10 add %o0, 0x10, %l0
40011494: 40 00 12 db call 40016000 <_Watchdog_Remove>
40011498: 90 10 00 10 mov %l0, %o0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
4001149c: e6 26 60 30 st %l3, [ %i1 + 0x30 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400114a0: c2 04 a2 c0 ld [ %l2 + 0x2c0 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
400114a4: 92 10 00 10 mov %l0, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400114a8: 82 24 40 01 sub %l1, %g1, %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
400114ac: 11 10 00 c6 sethi %hi(0x40031800), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
400114b0: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
400114b4: 90 12 23 04 or %o0, 0x304, %o0
the_timer->the_class = TIMER_TIME_OF_DAY;
400114b8: 82 10 20 02 mov 2, %g1
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400114bc: f4 26 60 2c st %i2, [ %i1 + 0x2c ]
400114c0: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
400114c4: f6 26 60 34 st %i3, [ %i1 + 0x34 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400114c8: c0 26 60 18 clr [ %i1 + 0x18 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
400114cc: 40 00 12 73 call 40015e98 <_Watchdog_Insert>
400114d0: b0 10 20 00 clr %i0
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_Watchdog_Insert_seconds(
&the_timer->Ticker,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
400114d4: 40 00 0c c6 call 400147ec <_Thread_Enable_dispatch>
400114d8: 01 00 00 00 nop
400114dc: 81 c7 e0 08 ret
400114e0: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
400114e4: b0 10 20 14 mov 0x14, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
400114e8: 81 c7 e0 08 ret
400114ec: 81 e8 00 00 restore
400114f0 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
Objects_Id id,
rtems_timer_information *the_info
)
{
400114f0: 9d e3 bf 90 save %sp, -112, %sp
400114f4: 92 10 00 18 mov %i0, %o1
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
400114f8: 80 a6 60 00 cmp %i1, 0
400114fc: 02 80 00 14 be 4001154c <rtems_timer_get_information+0x5c><== NEVER TAKEN
40011500: b0 10 20 09 mov 9, %i0
40011504: 11 10 00 c7 sethi %hi(0x40031c00), %o0
40011508: 94 07 bf f4 add %fp, -12, %o2
4001150c: 40 00 0a 65 call 40013ea0 <_Objects_Get>
40011510: 90 12 21 50 or %o0, 0x150, %o0
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
40011514: c2 07 bf f4 ld [ %fp + -12 ], %g1
40011518: 80 a0 60 00 cmp %g1, 0
4001151c: 12 80 00 0c bne 4001154c <rtems_timer_get_information+0x5c>
40011520: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
the_info->initial = the_timer->Ticker.initial;
40011524: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
40011528: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
the_info->initial = the_timer->Ticker.initial;
4001152c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->start_time = the_timer->Ticker.start_time;
40011530: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
40011534: c4 26 40 00 st %g2, [ %i1 ]
the_info->initial = the_timer->Ticker.initial;
the_info->start_time = the_timer->Ticker.start_time;
40011538: c2 26 60 08 st %g1, [ %i1 + 8 ]
the_info->stop_time = the_timer->Ticker.stop_time;
4001153c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
_Thread_Enable_dispatch();
40011540: b0 10 20 00 clr %i0
40011544: 40 00 0c aa call 400147ec <_Thread_Enable_dispatch>
40011548: c2 26 60 0c st %g1, [ %i1 + 0xc ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001154c: 81 c7 e0 08 ret
40011550: 81 e8 00 00 restore
40011818 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
40011818: 9d e3 bf 90 save %sp, -112, %sp
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
4001181c: 80 a6 20 00 cmp %i0, 0
40011820: 02 80 00 06 be 40011838 <rtems_timer_initiate_server+0x20>
40011824: 82 10 20 00 clr %g1
40011828: 03 10 00 b2 sethi %hi(0x4002c800), %g1
4001182c: c2 08 61 d4 ldub [ %g1 + 0x1d4 ], %g1 ! 4002c9d4 <rtems_maximum_priority>
40011830: 80 a0 40 18 cmp %g1, %i0
40011834: 82 60 3f ff subx %g0, -1, %g1
* Make sure the requested priority is valid. The if is
* 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 ) ) {
40011838: 80 a0 60 00 cmp %g1, 0
4001183c: 12 80 00 06 bne 40011854 <rtems_timer_initiate_server+0x3c><== NEVER TAKEN
40011840: a2 10 00 18 mov %i0, %l1
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
40011844: 80 a6 3f ff cmp %i0, -1
40011848: 12 80 00 56 bne 400119a0 <rtems_timer_initiate_server+0x188>
4001184c: 90 10 20 13 mov 0x13, %o0
40011850: a2 10 20 00 clr %l1
40011854: 05 10 00 c6 sethi %hi(0x40031800), %g2
40011858: c2 00 a2 30 ld [ %g2 + 0x230 ], %g1 ! 40031a30 <_Thread_Dispatch_disable_level>
4001185c: 82 00 60 01 inc %g1
40011860: c2 20 a2 30 st %g1, [ %g2 + 0x230 ]
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
40011864: 31 10 00 b5 sethi %hi(0x4002d400), %i0
initialized = true;
40011868: 82 10 20 01 mov 1, %g1
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
4001186c: e0 0e 20 a0 ldub [ %i0 + 0xa0 ], %l0
initialized = true;
_Thread_Enable_dispatch();
40011870: 40 00 0b df call 400147ec <_Thread_Enable_dispatch>
40011874: c2 2e 20 a0 stb %g1, [ %i0 + 0xa0 ]
if ( tmpInitialized )
40011878: 80 a4 20 00 cmp %l0, 0
4001187c: 12 80 00 49 bne 400119a0 <rtems_timer_initiate_server+0x188>
40011880: 90 10 20 0e mov 0xe, %o0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40011884: 05 10 00 c6 sethi %hi(0x40031800), %g2
40011888: 82 10 a1 4c or %g2, 0x14c, %g1 ! 4003194c <_Timer_To_be_inserted>
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
4001188c: c2 20 60 08 st %g1, [ %g1 + 8 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
40011890: c0 20 60 04 clr [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40011894: 82 00 60 04 add %g1, 4, %g1
* 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(
40011898: 92 10 00 11 mov %l1, %o1
4001189c: 94 10 00 19 mov %i1, %o2
400118a0: 19 00 00 20 sethi %hi(0x8000), %o4
400118a4: c2 20 a1 4c st %g1, [ %g2 + 0x14c ]
400118a8: 98 16 80 0c or %i2, %o4, %o4
400118ac: 11 15 12 53 sethi %hi(0x54494c00), %o0
400118b0: 96 10 21 00 mov 0x100, %o3
400118b4: 90 12 21 45 or %o0, 0x145, %o0
400118b8: 7f ff fc 77 call 40010a94 <rtems_task_create>
400118bc: 9a 07 bf f4 add %fp, -12, %o5
/* 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) {
400118c0: 80 a2 20 00 cmp %o0, 0
400118c4: 02 80 00 04 be 400118d4 <rtems_timer_initiate_server+0xbc>
400118c8: 03 10 00 c6 sethi %hi(0x40031800), %g1
initialized = false;
400118cc: 10 80 00 35 b 400119a0 <rtems_timer_initiate_server+0x188>
400118d0: c0 2e 20 a0 clrb [ %i0 + 0xa0 ]
* to a TCB pointer from here out.
*
* NOTE: Setting the pointer to the Timer Server TCB to a value other than
* NULL indicates that task-based timer support is initialized.
*/
_Timer_Server = (Thread_Control *)_Objects_Get_local_object(
400118d4: d6 07 bf f4 ld [ %fp + -12 ], %o3
RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object(
Objects_Information *information,
uint16_t index
)
{
if ( index > information->maximum )
400118d8: 86 10 60 ec or %g1, 0xec, %g3
400118dc: c4 10 e0 10 lduh [ %g3 + 0x10 ], %g2
400118e0: 03 00 00 3f sethi %hi(0xfc00), %g1
400118e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
400118e8: 82 0a c0 01 and %o3, %g1, %g1
400118ec: 80 a0 40 02 cmp %g1, %g2
400118f0: 18 80 00 05 bgu 40011904 <rtems_timer_initiate_server+0xec><== NEVER TAKEN
400118f4: 98 10 20 00 clr %o4
return NULL;
return information->local_table[ index ];
400118f8: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2
400118fc: 83 28 60 02 sll %g1, 2, %g1
40011900: d8 00 80 01 ld [ %g2 + %g1 ], %o4
40011904: 1b 10 00 c6 sethi %hi(0x40031800), %o5
40011908: 82 13 61 40 or %o5, 0x140, %g1 ! 40031940 <_Timer_Seconds_chain>
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
4001190c: c2 20 60 08 st %g1, [ %g1 + 8 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
40011910: c0 20 60 04 clr [ %g1 + 4 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40011914: 82 00 60 04 add %g1, 4, %g1
40011918: c2 23 61 40 st %g1, [ %o5 + 0x140 ]
4001191c: 03 10 00 c7 sethi %hi(0x40031c00), %g1
40011920: 09 10 00 c6 sethi %hi(0x40031800), %g4
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40011924: c0 23 20 6c clr [ %o4 + 0x6c ]
40011928: 84 11 21 2c or %g4, 0x12c, %g2
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
4001192c: c0 23 20 50 clr [ %o4 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
40011930: d6 23 20 68 st %o3, [ %o4 + 0x68 ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
40011934: c4 20 a0 08 st %g2, [ %g2 + 8 ]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
40011938: c0 20 a0 04 clr [ %g2 + 4 ]
4001193c: d8 20 61 94 st %o4, [ %g1 + 0x194 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
40011940: 84 00 a0 04 add %g2, 4, %g2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
40011944: 07 10 00 51 sethi %hi(0x40014400), %g3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40011948: 03 10 00 c6 sethi %hi(0x40031800), %g1
the_watchdog->routine = routine;
4001194c: 86 10 e2 68 or %g3, 0x268, %g3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40011950: 82 10 61 58 or %g1, 0x158, %g1
the_watchdog->routine = routine;
40011954: c6 23 20 64 st %g3, [ %o4 + 0x64 ]
40011958: c4 21 21 2c st %g2, [ %g4 + 0x12c ]
4001195c: c6 20 60 1c st %g3, [ %g1 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
40011960: c0 20 60 24 clr [ %g1 + 0x24 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
40011964: c0 20 60 08 clr [ %g1 + 8 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
40011968: d6 20 60 20 st %o3, [ %g1 + 0x20 ]
/*
* Initialize the pointer to the timer reset method so applications
* that do not use the Timer Server do not have to pull it in.
*/
_Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
4001196c: 05 10 00 c7 sethi %hi(0x40031c00), %g2
40011970: 03 10 00 46 sethi %hi(0x40011800), %g1
40011974: 82 10 61 a8 or %g1, 0x1a8, %g1 ! 400119a8 <_Timer_Server_schedule_operation_method>
/*
* Start the timer server
*/
status = rtems_task_start(
40011978: 90 10 00 0b mov %o3, %o0
/*
* Initialize the pointer to the timer reset method so applications
* that do not use the Timer Server do not have to pull it in.
*/
_Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;
4001197c: c2 20 a1 90 st %g1, [ %g2 + 0x190 ]
/*
* Start the timer server
*/
status = rtems_task_start(
40011980: 13 10 00 46 sethi %hi(0x40011800), %o1
40011984: 94 10 20 00 clr %o2
40011988: 7f ff fd 99 call 40010fec <rtems_task_start>
4001198c: 92 12 62 58 or %o1, 0x258, %o1
id, /* the id from create */
(rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
0 /* there is no argument */
);
if (status) {
40011990: 80 a2 20 00 cmp %o0, 0
40011994: 02 80 00 03 be 400119a0 <rtems_timer_initiate_server+0x188><== ALWAYS TAKEN
40011998: 03 10 00 b5 sethi %hi(0x4002d400), %g1
* but there is actually no way (in normal circumstances) that the
* start can fail. The id and starting address are known to be
* be good. If this service fails, something is weirdly wrong on the
* target such as a stray write in an ISR or incorrect memory layout.
*/
initialized = false;
4001199c: c0 28 60 a0 clrb [ %g1 + 0xa0 ] ! 4002d4a0 <initialized.4127><== NOT EXECUTED
}
return status;
}
400119a0: 81 c7 e0 08 ret
400119a4: 91 e8 00 08 restore %g0, %o0, %o0
4001158c <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
Objects_Id id
)
{
4001158c: 9d e3 bf 90 save %sp, -112, %sp
40011590: 11 10 00 c7 sethi %hi(0x40031c00), %o0
40011594: 92 10 00 18 mov %i0, %o1
40011598: 90 12 21 50 or %o0, 0x150, %o0
4001159c: 40 00 0a 41 call 40013ea0 <_Objects_Get>
400115a0: 94 07 bf f4 add %fp, -12, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
400115a4: c2 07 bf f4 ld [ %fp + -12 ], %g1
400115a8: a0 10 00 08 mov %o0, %l0
400115ac: 80 a0 60 00 cmp %g1, 0
400115b0: 12 80 00 19 bne 40011614 <rtems_timer_reset+0x88>
400115b4: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
400115b8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400115bc: 80 a0 60 01 cmp %g1, 1
400115c0: 22 80 00 0f be,a 400115fc <rtems_timer_reset+0x70>
400115c4: 31 10 00 c7 sethi %hi(0x40031c00), %i0
400115c8: 2a 80 00 06 bcs,a 400115e0 <rtems_timer_reset+0x54>
400115cc: a0 02 20 10 add %o0, 0x10, %l0
400115d0: 80 a0 60 04 cmp %g1, 4
400115d4: 18 80 00 1c bgu 40011644 <rtems_timer_reset+0xb8> <== NEVER TAKEN
400115d8: 01 00 00 00 nop
400115dc: 30 80 00 16 b,a 40011634 <rtems_timer_reset+0xa8>
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
400115e0: 40 00 12 88 call 40016000 <_Watchdog_Remove>
400115e4: 90 10 00 10 mov %l0, %o0
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
400115e8: 92 10 00 10 mov %l0, %o1
400115ec: 11 10 00 c6 sethi %hi(0x40031800), %o0
400115f0: 40 00 12 2a call 40015e98 <_Watchdog_Insert>
400115f4: 90 12 23 10 or %o0, 0x310, %o0 ! 40031b10 <_Watchdog_Ticks_chain>
400115f8: 30 80 00 13 b,a 40011644 <rtems_timer_reset+0xb8>
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
400115fc: c2 06 21 90 ld [ %i0 + 0x190 ], %g1
40011600: 80 a0 60 00 cmp %g1, 0
40011604: 12 80 00 06 bne 4001161c <rtems_timer_reset+0x90> <== ALWAYS TAKEN
40011608: 01 00 00 00 nop
_Thread_Enable_dispatch();
4001160c: 40 00 0c 78 call 400147ec <_Thread_Enable_dispatch> <== NOT EXECUTED
40011610: b0 10 20 0e mov 0xe, %i0 ! e <PROM_START+0xe> <== NOT EXECUTED
40011614: 81 c7 e0 08 ret
40011618: 81 e8 00 00 restore
return RTEMS_INCORRECT_STATE;
}
_Watchdog_Remove( &the_timer->Ticker );
4001161c: 40 00 12 79 call 40016000 <_Watchdog_Remove>
40011620: 90 02 20 10 add %o0, 0x10, %o0
(*_Timer_Server_schedule_operation)( the_timer );
40011624: c2 06 21 90 ld [ %i0 + 0x190 ], %g1
40011628: 9f c0 40 00 call %g1
4001162c: 90 10 00 10 mov %l0, %o0
40011630: 30 80 00 05 b,a 40011644 <rtems_timer_reset+0xb8>
break;
case TIMER_TIME_OF_DAY:
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
40011634: 40 00 0c 6e call 400147ec <_Thread_Enable_dispatch>
40011638: b0 10 20 0b mov 0xb, %i0
4001163c: 81 c7 e0 08 ret
40011640: 81 e8 00 00 restore
return RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
40011644: 40 00 0c 6a call 400147ec <_Thread_Enable_dispatch>
40011648: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
4001164c: 81 c7 e0 08 ret
40011650: 81 e8 00 00 restore
40011654 <rtems_timer_server_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011654: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
40011658: 03 10 00 c7 sethi %hi(0x40031c00), %g1
4001165c: c2 00 61 94 ld [ %g1 + 0x194 ], %g1 ! 40031d94 <_Timer_Server>
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011660: a2 10 00 18 mov %i0, %l1
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
40011664: 80 a0 60 00 cmp %g1, 0
40011668: 02 80 00 1e be 400116e0 <rtems_timer_server_fire_after+0x8c>
4001166c: b0 10 20 0e mov 0xe, %i0
return RTEMS_INCORRECT_STATE;
if ( !routine )
40011670: 80 a6 a0 00 cmp %i2, 0
40011674: 02 80 00 1b be 400116e0 <rtems_timer_server_fire_after+0x8c><== NEVER TAKEN
40011678: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
4001167c: 80 a6 60 00 cmp %i1, 0
40011680: 02 80 00 18 be 400116e0 <rtems_timer_server_fire_after+0x8c>
40011684: b0 10 20 0a mov 0xa, %i0
40011688: 11 10 00 c7 sethi %hi(0x40031c00), %o0
4001168c: 92 10 00 11 mov %l1, %o1
40011690: 90 12 21 50 or %o0, 0x150, %o0
40011694: 40 00 0a 03 call 40013ea0 <_Objects_Get>
40011698: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
4001169c: c2 07 bf f4 ld [ %fp + -12 ], %g1
400116a0: a0 10 00 08 mov %o0, %l0
400116a4: 80 a0 60 00 cmp %g1, 0
400116a8: 12 80 00 0e bne 400116e0 <rtems_timer_server_fire_after+0x8c>
400116ac: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
400116b0: 40 00 12 54 call 40016000 <_Watchdog_Remove>
400116b4: 90 02 20 10 add %o0, 0x10, %o0
_ISR_Disable( level );
400116b8: 7f ff e7 77 call 4000b494 <sparc_disable_interrupts>
400116bc: 01 00 00 00 nop
/*
* 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 ) {
400116c0: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
400116c4: 80 a0 60 00 cmp %g1, 0
400116c8: 02 80 00 08 be 400116e8 <rtems_timer_server_fire_after+0x94><== ALWAYS TAKEN
400116cc: 82 10 20 01 mov 1, %g1
_ISR_Enable( level );
400116d0: 7f ff e7 75 call 4000b4a4 <sparc_enable_interrupts> <== NOT EXECUTED
400116d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
_Thread_Enable_dispatch();
400116d8: 40 00 0c 45 call 400147ec <_Thread_Enable_dispatch> <== NOT EXECUTED
400116dc: 01 00 00 00 nop <== NOT EXECUTED
400116e0: 81 c7 e0 08 ret
400116e4: 81 e8 00 00 restore
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400116e8: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
400116ec: e2 24 20 30 st %l1, [ %l0 + 0x30 ]
the_watchdog->user_data = user_data;
400116f0: f6 24 20 34 st %i3, [ %l0 + 0x34 ]
* so we can atomically initialize it as in use.
*/
the_timer->the_class = TIMER_INTERVAL_ON_TASK;
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
400116f4: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400116f8: c0 24 20 18 clr [ %l0 + 0x18 ]
/*
* 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;
400116fc: c2 24 20 38 st %g1, [ %l0 + 0x38 ]
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
the_timer->Ticker.initial = ticks;
_ISR_Enable( level );
40011700: 7f ff e7 69 call 4000b4a4 <sparc_enable_interrupts>
40011704: b0 10 20 00 clr %i0
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
40011708: 03 10 00 c7 sethi %hi(0x40031c00), %g1
4001170c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 40031d90 <_Timer_Server_schedule_operation>
40011710: 9f c0 40 00 call %g1
40011714: 90 10 00 10 mov %l0, %o0
_Thread_Enable_dispatch();
40011718: 40 00 0c 35 call 400147ec <_Thread_Enable_dispatch>
4001171c: 01 00 00 00 nop
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40011720: 81 c7 e0 08 ret
40011724: 81 e8 00 00 restore
40011728 <rtems_timer_server_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011728: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
4001172c: 03 10 00 c7 sethi %hi(0x40031c00), %g1
40011730: c2 00 61 94 ld [ %g1 + 0x194 ], %g1 ! 40031d94 <_Timer_Server>
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
40011734: a4 10 00 18 mov %i0, %l2
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
40011738: 80 a0 60 00 cmp %g1, 0
4001173c: 02 80 00 32 be 40011804 <rtems_timer_server_fire_when+0xdc>
40011740: b0 10 20 0e mov 0xe, %i0
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
40011744: 03 10 00 c6 sethi %hi(0x40031800), %g1
40011748: c2 08 62 44 ldub [ %g1 + 0x244 ], %g1 ! 40031a44 <_TOD_Is_set>
4001174c: 80 a0 60 00 cmp %g1, 0
40011750: 02 80 00 2d be 40011804 <rtems_timer_server_fire_when+0xdc><== NEVER TAKEN
40011754: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !routine )
40011758: 80 a6 a0 00 cmp %i2, 0
4001175c: 02 80 00 2a be 40011804 <rtems_timer_server_fire_when+0xdc><== NEVER TAKEN
40011760: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
40011764: 7f ff f4 67 call 4000e900 <_TOD_Validate>
40011768: 90 10 00 19 mov %i1, %o0
4001176c: 80 8a 20 ff btst 0xff, %o0
40011770: 22 80 00 25 be,a 40011804 <rtems_timer_server_fire_when+0xdc>
40011774: b0 10 20 14 mov 0x14, %i0
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
40011778: 7f ff f4 2f call 4000e834 <_TOD_To_seconds>
4001177c: 90 10 00 19 mov %i1, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
40011780: 23 10 00 c6 sethi %hi(0x40031800), %l1
40011784: c2 04 62 c0 ld [ %l1 + 0x2c0 ], %g1 ! 40031ac0 <_TOD_Now>
40011788: 80 a2 00 01 cmp %o0, %g1
4001178c: 08 80 00 20 bleu 4001180c <rtems_timer_server_fire_when+0xe4>
40011790: a0 10 00 08 mov %o0, %l0
40011794: 11 10 00 c7 sethi %hi(0x40031c00), %o0
40011798: 92 10 00 12 mov %l2, %o1
4001179c: 90 12 21 50 or %o0, 0x150, %o0
400117a0: 40 00 09 c0 call 40013ea0 <_Objects_Get>
400117a4: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
400117a8: c2 07 bf f4 ld [ %fp + -12 ], %g1
400117ac: b2 10 00 08 mov %o0, %i1
400117b0: 80 a0 60 00 cmp %g1, 0
400117b4: 12 80 00 14 bne 40011804 <rtems_timer_server_fire_when+0xdc>
400117b8: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
400117bc: 40 00 12 11 call 40016000 <_Watchdog_Remove>
400117c0: 90 02 20 10 add %o0, 0x10, %o0
the_watchdog->routine = routine;
the_watchdog->id = id;
400117c4: e4 26 60 30 st %l2, [ %i1 + 0x30 ]
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;
400117c8: c4 04 62 c0 ld [ %l1 + 0x2c0 ], %g2
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
400117cc: 03 10 00 c7 sethi %hi(0x40031c00), %g1
400117d0: c6 00 61 90 ld [ %g1 + 0x190 ], %g3 ! 40031d90 <_Timer_Server_schedule_operation>
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;
400117d4: 84 24 00 02 sub %l0, %g2, %g2
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;
400117d8: 82 10 20 03 mov 3, %g1
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
400117dc: 90 10 00 19 mov %i1, %o0
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;
400117e0: c4 26 60 1c st %g2, [ %i1 + 0x1c ]
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;
400117e4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
400117e8: f4 26 60 2c st %i2, [ %i1 + 0x2c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
400117ec: f6 26 60 34 st %i3, [ %i1 + 0x34 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
400117f0: c0 26 60 18 clr [ %i1 + 0x18 ]
/*
* _Timer_Server_schedule_operation != NULL because we checked that
* _Timer_Server was != NULL above. Both are set at the same time.
*/
(*_Timer_Server_schedule_operation)( the_timer );
400117f4: 9f c0 c0 00 call %g3
400117f8: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
400117fc: 40 00 0b fc call 400147ec <_Thread_Enable_dispatch>
40011800: 01 00 00 00 nop
40011804: 81 c7 e0 08 ret
40011808: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
4001180c: b0 10 20 14 mov 0x14, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
40011810: 81 c7 e0 08 ret
40011814: 81 e8 00 00 restore
40002e8c <rtems_verror>:
static int rtems_verror(
uint32_t error_flag,
const char *printf_format,
va_list arglist
)
{
40002e8c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
40002e90: 03 08 00 00 sethi %hi(0x20000000), %g1 <== NOT EXECUTED
40002e94: a8 8e 00 01 andcc %i0, %g1, %l4 <== NOT EXECUTED
40002e98: 02 80 00 11 be 40002edc <rtems_verror+0x50> <== NOT EXECUTED
40002e9c: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
40002ea0: 03 10 00 90 sethi %hi(0x40024000), %g1 <== NOT EXECUTED
40002ea4: c6 00 61 d8 ld [ %g1 + 0x1d8 ], %g3 ! 400241d8 <rtems_panic_in_progress><== NOT EXECUTED
40002ea8: 84 00 e0 01 add %g3, 1, %g2 <== NOT EXECUTED
40002eac: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
40002eb0: 02 80 00 07 be 40002ecc <rtems_verror+0x40> <== NOT EXECUTED
40002eb4: c4 20 61 d8 st %g2, [ %g1 + 0x1d8 ] <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
40002eb8: 05 10 00 90 sethi %hi(0x40024000), %g2 <== NOT EXECUTED
40002ebc: c2 00 a3 b0 ld [ %g2 + 0x3b0 ], %g1 ! 400243b0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
40002ec0: 82 00 60 01 inc %g1 <== NOT EXECUTED
40002ec4: c2 20 a3 b0 st %g1, [ %g2 + 0x3b0 ] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
40002ec8: 03 10 00 90 sethi %hi(0x40024000), %g1 <== NOT EXECUTED
40002ecc: c2 00 61 d8 ld [ %g1 + 0x1d8 ], %g1 ! 400241d8 <rtems_panic_in_progress><== NOT EXECUTED
40002ed0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40002ed4: 34 80 00 5b bg,a 40003040 <rtems_verror+0x1b4> <== NOT EXECUTED
40002ed8: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40002edc: 03 10 00 6f sethi %hi(0x4001bc00), %g1 <== NOT EXECUTED
40002ee0: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 4001be58 <_impure_ptr><== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40002ee4: a4 10 20 00 clr %l2 <== NOT EXECUTED
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
40002ee8: 40 00 2c c3 call 4000e1f4 <fflush> <== NOT EXECUTED
40002eec: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
40002ef0: 03 1c 00 00 sethi %hi(0x70000000), %g1 <== NOT EXECUTED
40002ef4: a0 2c c0 01 andn %l3, %g1, %l0 <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
40002ef8: 03 10 00 00 sethi %hi(0x40000000), %g1 <== NOT EXECUTED
40002efc: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED
40002f00: 02 80 00 05 be 40002f14 <rtems_verror+0x88> <== NOT EXECUTED
40002f04: 23 10 00 6f sethi %hi(0x4001bc00), %l1 <== NOT EXECUTED
local_errno = errno;
40002f08: 40 00 2b ea call 4000deb0 <__errno> <== NOT EXECUTED
40002f0c: 01 00 00 00 nop <== NOT EXECUTED
40002f10: e4 02 00 00 ld [ %o0 ], %l2 <== 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);
40002f14: c2 04 62 58 ld [ %l1 + 0x258 ], %g1 <== NOT EXECUTED
40002f18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40002f1c: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40002f20: 40 00 40 fd call 40013314 <vfprintf> <== NOT EXECUTED
40002f24: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
if (status)
40002f28: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
40002f2c: 02 80 00 0e be 40002f64 <rtems_verror+0xd8> <== NOT EXECUTED
40002f30: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002f34: c2 04 62 58 ld [ %l1 + 0x258 ], %g1 <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
40002f38: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002f3c: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
40002f40: 11 10 00 68 sethi %hi(0x4001a000), %o0 <== NOT EXECUTED
40002f44: 40 00 23 2c call 4000bbf4 <rtems_assoc_name_by_local> <== NOT EXECUTED
40002f48: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4001a0f8 <rtems_status_assoc><== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002f4c: 13 10 00 67 sethi %hi(0x40019c00), %o1 <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
40002f50: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
40002f54: 92 12 61 78 or %o1, 0x178, %o1 <== NOT EXECUTED
40002f58: 40 00 2d 9a call 4000e5c0 <fprintf> <== NOT EXECUTED
40002f5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40002f60: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED
if (local_errno)
40002f64: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
40002f68: 02 80 00 1c be 40002fd8 <rtems_verror+0x14c> <== NOT EXECUTED
40002f6c: 23 10 00 6f sethi %hi(0x4001bc00), %l1 <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
40002f70: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
40002f74: 04 80 00 11 ble 40002fb8 <rtems_verror+0x12c> <== NOT EXECUTED
40002f78: 03 10 00 6f sethi %hi(0x4001bc00), %g1 <== NOT EXECUTED
40002f7c: 40 00 31 f2 call 4000f744 <strerror> <== NOT EXECUTED
40002f80: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40002f84: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
40002f88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40002f8c: 02 80 00 0b be 40002fb8 <rtems_verror+0x12c> <== NOT EXECUTED
40002f90: 03 10 00 6f sethi %hi(0x4001bc00), %g1 <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
40002f94: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 4001be58 <_impure_ptr><== NOT EXECUTED
40002f98: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
40002f9c: 40 00 31 ea call 4000f744 <strerror> <== NOT EXECUTED
40002fa0: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED
40002fa4: 13 10 00 67 sethi %hi(0x40019c00), %o1 <== NOT EXECUTED
40002fa8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40002fac: 92 12 61 88 or %o1, 0x188, %o1 <== NOT EXECUTED
40002fb0: 10 80 00 07 b 40002fcc <rtems_verror+0x140> <== NOT EXECUTED
40002fb4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
40002fb8: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 <== NOT EXECUTED
40002fbc: 13 10 00 67 sethi %hi(0x40019c00), %o1 <== NOT EXECUTED
40002fc0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40002fc4: 92 12 61 98 or %o1, 0x198, %o1 <== NOT EXECUTED
40002fc8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
40002fcc: 40 00 2d 7d call 4000e5c0 <fprintf> <== NOT EXECUTED
40002fd0: 23 10 00 6f sethi %hi(0x4001bc00), %l1 <== NOT EXECUTED
40002fd4: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
40002fd8: c2 04 62 58 ld [ %l1 + 0x258 ], %g1 <== NOT EXECUTED
40002fdc: 13 10 00 66 sethi %hi(0x40019800), %o1 <== NOT EXECUTED
40002fe0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40002fe4: 40 00 2d 77 call 4000e5c0 <fprintf> <== NOT EXECUTED
40002fe8: 92 12 60 40 or %o1, 0x40, %o1 <== NOT EXECUTED
(void) fflush(stderr);
40002fec: c2 04 62 58 ld [ %l1 + 0x258 ], %g1 <== 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");
40002ff0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
(void) fflush(stderr);
40002ff4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
40002ff8: 40 00 2c 7f call 4000e1f4 <fflush> <== NOT EXECUTED
40002ffc: b0 04 00 18 add %l0, %i0, %i0 <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
40003000: 03 0c 00 00 sethi %hi(0x30000000), %g1 <== NOT EXECUTED
40003004: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED
40003008: 02 80 00 0e be 40003040 <rtems_verror+0x1b4> <== NOT EXECUTED
4000300c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
40003010: 02 80 00 07 be 4000302c <rtems_verror+0x1a0> <== NOT EXECUTED
40003014: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
40003018: 13 10 00 67 sethi %hi(0x40019c00), %o1 <== NOT EXECUTED
4000301c: 40 00 00 18 call 4000307c <rtems_error> <== NOT EXECUTED
40003020: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 40019db0 <__func__.4755+0x368><== NOT EXECUTED
_exit(local_errno);
40003024: 40 00 01 6e call 400035dc <_exit> <== NOT EXECUTED
40003028: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
4000302c: 13 10 00 67 sethi %hi(0x40019c00), %o1 <== NOT EXECUTED
40003030: 40 00 00 13 call 4000307c <rtems_error> <== NOT EXECUTED
40003034: 92 12 61 c8 or %o1, 0x1c8, %o1 ! 40019dc8 <__func__.4755+0x380><== NOT EXECUTED
abort();
40003038: 40 00 2b 90 call 4000de78 <abort> <== NOT EXECUTED
4000303c: 01 00 00 00 nop <== NOT EXECUTED
}
}
return chars_written;
}
40003040: 81 c7 e0 08 ret <== NOT EXECUTED
40003044: 81 e8 00 00 restore <== NOT EXECUTED
40003a08 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
40003a08: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
40003a0c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
40003a10: 80 88 6e 78 btst 0xe78, %g1 <== NOT EXECUTED
40003a14: 02 80 00 0e be 40003a4c <siproc+0x44> <== NOT EXECUTED
40003a18: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
40003a1c: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED
40003a20: 94 10 20 00 clr %o2 <== NOT EXECUTED
40003a24: 40 00 06 71 call 400053e8 <rtems_semaphore_obtain> <== NOT EXECUTED
40003a28: 92 10 20 00 clr %o1 <== NOT EXECUTED
i = iproc (c, tty);
40003a2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40003a30: 7f ff ff 80 call 40003830 <iproc> <== NOT EXECUTED
40003a34: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40003a38: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
40003a3c: 40 00 06 b2 call 40005504 <rtems_semaphore_release> <== NOT EXECUTED
40003a40: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
40003a44: 81 c7 e0 08 ret <== NOT EXECUTED
40003a48: 81 e8 00 00 restore <== 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);
40003a4c: 7f ff ff 79 call 40003830 <iproc> <== NOT EXECUTED
40003a50: 81 e8 00 00 restore <== NOT EXECUTED
40002938 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
40002938: 9d e3 bf 80 save %sp, -128, %sp
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
4000293c: 03 10 00 5c sethi %hi(0x40017000), %g1
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
40002940: b8 07 bf e0 add %fp, -32, %i4
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
40002944: ac 10 62 5c or %g1, 0x25c, %l6
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
40002948: ba 07 bf f8 add %fp, -8, %i5
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)])]);
4000294c: 03 10 00 59 sethi %hi(0x40016400), %g1
40002950: 10 80 00 c8 b 40002c70 <vprintk+0x338>
40002954: b6 10 60 18 or %g1, 0x18, %i3 ! 40016418 <__func__.4755+0x290>
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
40002958: 32 80 00 c4 bne,a 40002c68 <vprintk+0x330>
4000295c: c2 05 80 00 ld [ %l6 ], %g1
fmt++;
40002960: b0 06 20 01 inc %i0
if (*fmt == '0' ) {
40002964: c2 4e 00 00 ldsb [ %i0 ], %g1
40002968: 80 a0 60 30 cmp %g1, 0x30
4000296c: 12 80 00 05 bne 40002980 <vprintk+0x48>
40002970: ae 10 20 20 mov 0x20, %l7
lead = '0';
fmt++;
40002974: b0 06 20 01 inc %i0
40002978: ae 10 20 30 mov 0x30, %l7
}
if (*fmt == '-' ) {
4000297c: c2 4e 00 00 ldsb [ %i0 ], %g1
40002980: 80 a0 60 2d cmp %g1, 0x2d
40002984: 12 80 00 04 bne 40002994 <vprintk+0x5c>
40002988: a6 10 20 00 clr %l3
minus = 1;
fmt++;
4000298c: b0 06 20 01 inc %i0
40002990: a6 10 20 01 mov 1, %l3
40002994: 10 80 00 08 b 400029b4 <vprintk+0x7c>
40002998: a8 10 20 00 clr %l4
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
width += (*fmt - '0');
4000299c: 85 38 60 18 sra %g1, 0x18, %g2
fmt++;
400029a0: b0 06 20 01 inc %i0
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
400029a4: 83 2d 20 01 sll %l4, 1, %g1
width += (*fmt - '0');
400029a8: 84 00 bf d0 add %g2, -48, %g2
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
400029ac: 82 00 40 03 add %g1, %g3, %g1
width += (*fmt - '0');
400029b0: a8 00 80 01 add %g2, %g1, %l4
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
400029b4: d0 0e 00 00 ldub [ %i0 ], %o0
width *= 10;
400029b8: 87 2d 20 03 sll %l4, 3, %g3
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
400029bc: 82 02 3f d0 add %o0, -48, %g1
400029c0: 82 08 60 ff and %g1, 0xff, %g1
400029c4: 80 a0 60 09 cmp %g1, 9
400029c8: 08 bf ff f5 bleu 4000299c <vprintk+0x64>
400029cc: 83 2a 20 18 sll %o0, 0x18, %g1
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
400029d0: 83 38 60 18 sra %g1, 0x18, %g1
400029d4: 80 a0 60 6c cmp %g1, 0x6c
400029d8: 12 80 00 05 bne 400029ec <vprintk+0xb4>
400029dc: 83 2a 20 18 sll %o0, 0x18, %g1
lflag = 1;
c = *++fmt;
400029e0: b0 06 20 01 inc %i0
400029e4: d0 0e 00 00 ldub [ %i0 ], %o0
}
switch (c) {
400029e8: 83 2a 20 18 sll %o0, 0x18, %g1
400029ec: 83 38 60 18 sra %g1, 0x18, %g1
400029f0: 80 a0 60 64 cmp %g1, 0x64
400029f4: 02 80 00 2c be 40002aa4 <vprintk+0x16c>
400029f8: aa 10 20 0a mov 0xa, %l5
400029fc: 14 80 00 16 bg 40002a54 <vprintk+0x11c>
40002a00: 80 a0 60 70 cmp %g1, 0x70
40002a04: 80 a0 60 4f cmp %g1, 0x4f
40002a08: 02 80 00 60 be 40002b88 <vprintk+0x250> <== NEVER TAKEN
40002a0c: aa 10 20 08 mov 8, %l5
40002a10: 14 80 00 09 bg 40002a34 <vprintk+0xfc> <== NEVER TAKEN
40002a14: 80 a0 60 58 cmp %g1, 0x58
40002a18: 80 a0 60 44 cmp %g1, 0x44
40002a1c: 02 80 00 21 be 40002aa0 <vprintk+0x168> <== NEVER TAKEN
40002a20: 80 a0 60 49 cmp %g1, 0x49
40002a24: 32 80 00 55 bne,a 40002b78 <vprintk+0x240> <== ALWAYS TAKEN
40002a28: 91 2a 20 18 sll %o0, 0x18, %o0
40002a2c: 10 80 00 1e b 40002aa4 <vprintk+0x16c> <== NOT EXECUTED
40002a30: aa 10 20 0a mov 0xa, %l5 <== NOT EXECUTED
40002a34: 02 80 00 54 be 40002b84 <vprintk+0x24c> <== NOT EXECUTED
40002a38: 80 a0 60 63 cmp %g1, 0x63 <== NOT EXECUTED
40002a3c: 02 80 00 4b be 40002b68 <vprintk+0x230> <== NOT EXECUTED
40002a40: 80 a0 60 55 cmp %g1, 0x55 <== NOT EXECUTED
40002a44: 32 80 00 4d bne,a 40002b78 <vprintk+0x240> <== NOT EXECUTED
40002a48: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
40002a4c: 10 80 00 4f b 40002b88 <vprintk+0x250> <== NOT EXECUTED
40002a50: aa 10 20 0a mov 0xa, %l5 <== NOT EXECUTED
40002a54: 02 80 00 4c be 40002b84 <vprintk+0x24c> <== NEVER TAKEN
40002a58: 80 a0 60 70 cmp %g1, 0x70
40002a5c: 14 80 00 09 bg 40002a80 <vprintk+0x148> <== ALWAYS TAKEN
40002a60: 80 a0 60 75 cmp %g1, 0x75
40002a64: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
40002a68: 02 80 00 0e be 40002aa0 <vprintk+0x168> <== NOT EXECUTED
40002a6c: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
40002a70: 32 80 00 42 bne,a 40002b78 <vprintk+0x240> <== NOT EXECUTED
40002a74: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
40002a78: 10 80 00 44 b 40002b88 <vprintk+0x250> <== NOT EXECUTED
40002a7c: aa 10 20 08 mov 8, %l5 <== NOT EXECUTED
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
40002a80: 02 80 00 0b be 40002aac <vprintk+0x174>
40002a84: 80 a0 60 78 cmp %g1, 0x78
40002a88: 02 80 00 3f be 40002b84 <vprintk+0x24c>
40002a8c: 80 a0 60 73 cmp %g1, 0x73
40002a90: 32 80 00 3a bne,a 40002b78 <vprintk+0x240> <== NEVER TAKEN
40002a94: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
40002a98: 10 80 00 07 b 40002ab4 <vprintk+0x17c>
40002a9c: e4 06 40 00 ld [ %i1 ], %l2
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
40002aa0: aa 10 20 0a mov 0xa, %l5 <== NOT EXECUTED
40002aa4: 10 80 00 3a b 40002b8c <vprintk+0x254>
40002aa8: 82 10 20 01 mov 1, %g1
40002aac: 10 80 00 37 b 40002b88 <vprintk+0x250>
40002ab0: aa 10 20 0a mov 0xa, %l5
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
40002ab4: a2 10 20 00 clr %l1
40002ab8: b2 06 60 04 add %i1, 4, %i1
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
40002abc: c2 4c 80 11 ldsb [ %l2 + %l1 ], %g1
40002ac0: 80 a0 60 00 cmp %g1, 0
40002ac4: 32 bf ff fe bne,a 40002abc <vprintk+0x184>
40002ac8: a2 04 60 01 inc %l1
;
/* leading spaces */
if ( !minus )
40002acc: 80 a4 e0 00 cmp %l3, 0
40002ad0: 02 80 00 07 be 40002aec <vprintk+0x1b4>
40002ad4: a0 10 00 11 mov %l1, %l0
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
/* no width option */
if (width == 0) {
40002ad8: 10 80 00 09 b 40002afc <vprintk+0x1c4>
40002adc: 80 a5 20 00 cmp %l4, 0
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
40002ae0: a0 04 20 01 inc %l0 <== NOT EXECUTED
BSP_output_char(' ');
40002ae4: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002ae8: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
40002aec: 80 a4 00 14 cmp %l0, %l4
40002af0: 26 bf ff fc bl,a 40002ae0 <vprintk+0x1a8> <== NEVER TAKEN
40002af4: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
BSP_output_char(' ');
/* no width option */
if (width == 0) {
40002af8: 80 a5 20 00 cmp %l4, 0
40002afc: 22 80 00 02 be,a 40002b04 <vprintk+0x1cc>
40002b00: a8 10 00 11 mov %l1, %l4
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40002b04: 80 a5 20 00 cmp %l4, 0
40002b08: 04 80 00 0c ble 40002b38 <vprintk+0x200> <== NEVER TAKEN
40002b0c: 80 a4 e0 00 cmp %l3, 0
40002b10: 10 80 00 06 b 40002b28 <vprintk+0x1f0>
40002b14: d0 4c 80 00 ldsb [ %l2 ], %o0
BSP_output_char(*str);
40002b18: c2 05 80 00 ld [ %l6 ], %g1
40002b1c: 9f c0 40 00 call %g1
40002b20: 01 00 00 00 nop
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
40002b24: d0 4c 80 00 ldsb [ %l2 ], %o0
40002b28: 80 a2 20 00 cmp %o0, 0
40002b2c: 12 bf ff fb bne 40002b18 <vprintk+0x1e0>
40002b30: a4 04 a0 01 inc %l2
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
40002b34: 80 a4 e0 00 cmp %l3, 0
40002b38: 12 80 00 07 bne 40002b54 <vprintk+0x21c>
40002b3c: a0 10 00 11 mov %l1, %l0
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
40002b40: 10 80 00 4c b 40002c70 <vprintk+0x338>
40002b44: b0 06 20 01 inc %i0
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
40002b48: a0 04 20 01 inc %l0
BSP_output_char(' ');
40002b4c: 9f c0 40 00 call %g1
40002b50: 90 10 20 20 mov 0x20, %o0
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
for ( i=len ; i<width ; i++ )
40002b54: 80 a4 00 14 cmp %l0, %l4
40002b58: 26 bf ff fc bl,a 40002b48 <vprintk+0x210>
40002b5c: c2 05 80 00 ld [ %l6 ], %g1
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
40002b60: 10 80 00 44 b 40002c70 <vprintk+0x338>
40002b64: b0 06 20 01 inc %i0
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
}
break;
case 'c':
BSP_output_char(va_arg(ap, int));
40002b68: d0 4e 60 03 ldsb [ %i1 + 3 ], %o0 <== NOT EXECUTED
40002b6c: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
40002b70: 10 80 00 3e b 40002c68 <vprintk+0x330> <== NOT EXECUTED
40002b74: b2 06 60 04 add %i1, 4, %i1 <== NOT EXECUTED
break;
default:
BSP_output_char(c);
40002b78: c2 05 80 00 ld [ %l6 ], %g1
40002b7c: 10 80 00 3b b 40002c68 <vprintk+0x330>
40002b80: 91 3a 20 18 sra %o0, 0x18, %o0
40002b84: aa 10 20 10 mov 0x10, %l5
40002b88: 82 10 20 00 clr %g1
40002b8c: 84 06 60 04 add %i1, 4, %g2
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
40002b90: e2 06 40 00 ld [ %i1 ], %l1
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
40002b94: 80 a0 60 01 cmp %g1, 1
40002b98: 12 80 00 0d bne 40002bcc <vprintk+0x294>
40002b9c: b2 10 00 02 mov %g2, %i1
40002ba0: 80 a4 60 00 cmp %l1, 0
40002ba4: 36 80 00 12 bge,a 40002bec <vprintk+0x2b4> <== ALWAYS TAKEN
40002ba8: a4 10 20 00 clr %l2
BSP_output_char('-');
40002bac: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
40002bb0: 9f c0 40 00 call %g1 <== NOT EXECUTED
40002bb4: 90 10 20 2d mov 0x2d, %o0 <== NOT EXECUTED
num = -num;
if (maxwidth) maxwidth--;
40002bb8: 82 1d 20 00 xor %l4, 0, %g1 <== NOT EXECUTED
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
BSP_output_char('-');
num = -num;
40002bbc: a2 20 00 11 neg %l1 <== NOT EXECUTED
if (maxwidth) maxwidth--;
40002bc0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
40002bc4: 82 40 20 00 addx %g0, 0, %g1 <== NOT EXECUTED
40002bc8: a8 25 00 01 sub %l4, %g1, %l4 <== NOT EXECUTED
40002bcc: 10 80 00 08 b 40002bec <vprintk+0x2b4>
40002bd0: a4 10 20 00 clr %l2
}
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
40002bd4: 40 00 40 f4 call 40012fa4 <.umul>
40002bd8: 92 10 00 15 mov %l5, %o1
40002bdc: 90 24 40 08 sub %l1, %o0, %o0
40002be0: a2 10 00 10 mov %l0, %l1
40002be4: d0 2f 00 12 stb %o0, [ %i4 + %l2 ]
40002be8: a4 10 00 13 mov %l3, %l2
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
40002bec: 90 10 00 11 mov %l1, %o0
40002bf0: 92 10 00 15 mov %l5, %o1
40002bf4: 40 00 41 26 call 4001308c <.udiv>
40002bf8: a6 04 a0 01 add %l2, 1, %l3
40002bfc: a0 92 20 00 orcc %o0, 0, %l0
40002c00: 32 bf ff f5 bne,a 40002bd4 <vprintk+0x29c>
40002c04: 90 10 00 10 mov %l0, %o0
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
40002c08: 82 07 40 12 add %i5, %l2, %g1
for (n=maxwidth ; n > count; n-- )
40002c0c: a0 10 00 14 mov %l4, %l0
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
40002c10: e2 28 7f e8 stb %l1, [ %g1 + -24 ]
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
40002c14: 10 80 00 05 b 40002c28 <vprintk+0x2f0>
40002c18: a2 10 00 17 mov %l7, %l1
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
40002c1c: a0 04 3f ff add %l0, -1, %l0
BSP_output_char(lead);
40002c20: 9f c0 40 00 call %g1
40002c24: 90 10 00 11 mov %l1, %o0
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
40002c28: 80 a4 00 13 cmp %l0, %l3
40002c2c: 38 bf ff fc bgu,a 40002c1c <vprintk+0x2e4>
40002c30: c2 05 80 00 ld [ %l6 ], %g1
40002c34: a0 10 20 00 clr %l0
BSP_output_char(lead);
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
40002c38: 10 80 00 07 b 40002c54 <vprintk+0x31c>
40002c3c: a2 07 40 13 add %i5, %l3, %l1
40002c40: c2 48 7f e7 ldsb [ %g1 + -25 ], %g1
40002c44: c4 05 80 00 ld [ %l6 ], %g2
40002c48: d0 4e c0 01 ldsb [ %i3 + %g1 ], %o0
40002c4c: 9f c0 80 00 call %g2
40002c50: a0 04 20 01 inc %l0
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
40002c54: 80 a4 00 13 cmp %l0, %l3
40002c58: 0a bf ff fa bcs 40002c40 <vprintk+0x308>
40002c5c: 82 24 40 10 sub %l1, %l0, %g1
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
40002c60: 10 80 00 04 b 40002c70 <vprintk+0x338>
40002c64: b0 06 20 01 inc %i0
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
40002c68: 9f c0 40 00 call %g1
40002c6c: b0 06 20 01 inc %i0
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
40002c70: d0 4e 00 00 ldsb [ %i0 ], %o0
40002c74: 80 a2 20 00 cmp %o0, 0
40002c78: 12 bf ff 38 bne 40002958 <vprintk+0x20>
40002c7c: 80 a2 20 25 cmp %o0, 0x25
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
}
}
}
40002c80: 81 c7 e0 08 ret
40002c84: 81 e8 00 00 restore
40015884 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
40015884: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40015888: 03 10 00 5c sethi %hi(0x40017000), %g1
4001588c: c2 00 61 58 ld [ %g1 + 0x158 ], %g1 ! 40017158 <rtems_libio_number_iops>
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
40015890: 92 10 00 19 mov %i1, %o1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
40015894: 80 a6 00 01 cmp %i0, %g1
40015898: 1a 80 00 0e bcc 400158d0 <write+0x4c> <== NEVER TAKEN
4001589c: 94 10 00 1a mov %i2, %o2
iop = rtems_libio_iop( fd );
400158a0: 03 10 00 5f sethi %hi(0x40017c00), %g1
400158a4: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 ! 40017cf0 <rtems_libio_iops>
400158a8: 85 2e 20 02 sll %i0, 2, %g2
400158ac: 83 2e 20 04 sll %i0, 4, %g1
400158b0: 82 20 40 02 sub %g1, %g2, %g1
400158b4: 82 00 40 18 add %g1, %i0, %g1
400158b8: 83 28 60 02 sll %g1, 2, %g1
400158bc: b0 00 c0 01 add %g3, %g1, %i0
rtems_libio_check_is_open( iop );
400158c0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400158c4: 80 88 61 00 btst 0x100, %g1
400158c8: 12 80 00 06 bne 400158e0 <write+0x5c> <== ALWAYS TAKEN
400158cc: 80 a6 60 00 cmp %i1, 0
400158d0: 7f ff da 1f call 4000c14c <__errno> <== NOT EXECUTED
400158d4: 01 00 00 00 nop <== NOT EXECUTED
400158d8: 10 80 00 15 b 4001592c <write+0xa8> <== NOT EXECUTED
400158dc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
400158e0: 02 80 00 08 be 40015900 <write+0x7c> <== NEVER TAKEN
400158e4: 01 00 00 00 nop
rtems_libio_check_count( count );
400158e8: 80 a6 a0 00 cmp %i2, 0
400158ec: 02 80 00 1b be 40015958 <write+0xd4> <== NEVER TAKEN
400158f0: 90 10 20 00 clr %o0
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
400158f4: 80 88 60 04 btst 4, %g1
400158f8: 32 80 00 06 bne,a 40015910 <write+0x8c> <== ALWAYS TAKEN
400158fc: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
40015900: 7f ff da 13 call 4000c14c <__errno> <== NOT EXECUTED
40015904: 01 00 00 00 nop <== NOT EXECUTED
40015908: 10 80 00 09 b 4001592c <write+0xa8> <== NOT EXECUTED
4001590c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
40015910: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40015914: 80 a0 60 00 cmp %g1, 0
40015918: 12 80 00 08 bne 40015938 <write+0xb4> <== ALWAYS TAKEN
4001591c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
40015920: 7f ff da 0b call 4000c14c <__errno> <== NOT EXECUTED
40015924: 01 00 00 00 nop <== NOT EXECUTED
40015928: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
4001592c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40015930: 10 80 00 0a b 40015958 <write+0xd4> <== NOT EXECUTED
40015934: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rc = (*iop->handlers->write_h)( iop, buffer, count );
40015938: 9f c0 40 00 call %g1
4001593c: 90 10 00 18 mov %i0, %o0
if ( rc > 0 )
40015940: 80 a2 20 00 cmp %o0, 0
40015944: 04 80 00 05 ble 40015958 <write+0xd4> <== NEVER TAKEN
40015948: 01 00 00 00 nop
iop->offset += rc;
4001594c: c2 06 20 08 ld [ %i0 + 8 ], %g1
40015950: 82 00 40 08 add %g1, %o0, %g1
40015954: c2 26 20 08 st %g1, [ %i0 + 8 ]
return rc;
}
40015958: 81 c7 e0 08 ret
4001595c: 91 e8 00 08 restore %g0, %o0, %o0