RTEMS 4.9.6Annotated Report
Sun Jul 24 16:50:12 2011
02009950 <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 ) {
2009950: 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;
2009954: c4 02 20 0c ld [ %o0 + 0xc ], %g2
switch( node->type ) {
2009958: c2 00 60 48 ld [ %g1 + 0x48 ], %g1
200995c: 80 a0 60 06 cmp %g1, 6
2009960: 18 80 00 0a bgu 2009988 <IMFS_Set_handlers+0x38> <== NEVER TAKEN
2009964: c8 00 a0 2c ld [ %g2 + 0x2c ], %g4
2009968: 83 28 60 02 sll %g1, 2, %g1
200996c: 05 00 80 26 sethi %hi(0x2009800), %g2
2009970: 84 10 a1 34 or %g2, 0x134, %g2 ! 2009934 <miniIMFS_initialize+0x24>
2009974: c6 00 80 01 ld [ %g2 + %g1 ], %g3
2009978: 81 c0 c0 00 jmp %g3
200997c: 01 00 00 00 nop
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
2009980: c2 01 20 08 ld [ %g4 + 8 ], %g1
2009984: c2 22 20 04 st %g1, [ %o0 + 4 ]
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
2009988: 81 c3 e0 08 retl
200998c: 90 10 20 00 clr %o0
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
2009990: c2 01 20 04 ld [ %g4 + 4 ], %g1 <== NOT EXECUTED
2009994: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
break;
}
return 0;
}
2009998: 81 c3 e0 08 retl <== NOT EXECUTED
200999c: 90 10 20 00 clr %o0 <== NOT EXECUTED
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
20099a0: 03 00 80 56 sethi %hi(0x2015800), %g1 <== NOT EXECUTED
20099a4: 82 10 63 d4 or %g1, 0x3d4, %g1 ! 2015bd4 <IMFS_link_handlers><== NOT EXECUTED
20099a8: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
20099ac: 81 c3 e0 08 retl <== NOT EXECUTED
20099b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
20099b4: 03 00 80 56 sethi %hi(0x2015800), %g1
20099b8: 82 10 63 9c or %g1, 0x39c, %g1 ! 2015b9c <IMFS_device_handlers>
20099bc: c2 22 20 04 st %g1, [ %o0 + 4 ]
loc->handlers = fs_info->memfile_handlers;
break;
}
return 0;
}
20099c0: 81 c3 e0 08 retl
20099c4: 90 10 20 00 clr %o0
0200c540 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
200c540: 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 )
200c544: a2 96 20 00 orcc %i0, 0, %l1
200c548: 02 80 00 03 be 200c554 <IMFS_create_node+0x14>
200c54c: a0 10 20 00 clr %l0
parent = parent_loc->node_access;
200c550: e0 04 40 00 ld [ %l1 ], %l0
/*
* Allocate an IMFS jnode
*/
node = calloc( 1, sizeof( IMFS_jnode_t ) );
200c554: 90 10 20 01 mov 1, %o0
200c558: 7f ff f8 a0 call 200a7d8 <calloc>
200c55c: 92 10 20 5c mov 0x5c, %o1
if ( !node )
200c560: b0 92 20 00 orcc %o0, 0, %i0
200c564: 02 80 00 2e be 200c61c <IMFS_create_node+0xdc> <== NEVER TAKEN
200c568: 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 );
200c56c: 92 10 00 1a mov %i2, %o1
200c570: 94 10 20 20 mov 0x20, %o2
/*
* Fill in the basic information
*/
node->st_nlink = 1;
200c574: c2 36 20 30 sth %g1, [ %i0 + 0x30 ]
node->type = type;
200c578: f2 26 20 48 st %i1, [ %i0 + 0x48 ]
strncpy( node->name, name, IMFS_NAME_MAX );
200c57c: 40 00 07 74 call 200e34c <strncpy>
200c580: 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;
200c584: 03 00 80 5a sethi %hi(0x2016800), %g1
200c588: c4 00 62 a4 ld [ %g1 + 0x2a4 ], %g2 ! 2016aa4 <rtems_current_user_env>
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
200c58c: 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;
200c590: c2 10 a0 24 lduh [ %g2 + 0x24 ], %g1
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
200c594: 92 10 20 00 clr %o1
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode & ~rtems_filesystem_umask;
200c598: 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;
200c59c: 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;
200c5a0: c2 36 20 2e sth %g1, [ %i0 + 0x2e ]
/*
* Now set all the times.
*/
gettimeofday( &tv, 0 );
200c5a4: 7f ff f9 45 call 200aab8 <gettimeofday>
200c5a8: c0 36 20 3a clrh [ %i0 + 0x3a ]
node->stat_atime = (time_t) tv.tv_sec;
200c5ac: c2 07 bf f0 ld [ %fp + -16 ], %g1
/*
* Set the type specific information
*/
switch (type) {
200c5b0: 80 a6 60 06 cmp %i1, 6
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;
200c5b4: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
* Now set all the times.
*/
gettimeofday( &tv, 0 );
node->stat_atime = (time_t) tv.tv_sec;
200c5b8: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
/*
* Set the type specific information
*/
switch (type) {
200c5bc: 08 80 00 1a bleu 200c624 <IMFS_create_node+0xe4> <== ALWAYS TAKEN
200c5c0: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
break;
default:
assert(0);
200c5c4: 11 00 80 57 sethi %hi(0x2015c00), %o0 <== NOT EXECUTED
200c5c8: 15 00 80 57 sethi %hi(0x2015c00), %o2 <== NOT EXECUTED
200c5cc: 17 00 80 56 sethi %hi(0x2015800), %o3 <== NOT EXECUTED
200c5d0: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
200c5d4: 94 12 a2 88 or %o2, 0x288, %o2 <== NOT EXECUTED
200c5d8: 96 12 e3 00 or %o3, 0x300, %o3 <== NOT EXECUTED
200c5dc: 7f ff d6 59 call 2001f40 <__assert_func> <== NOT EXECUTED
200c5e0: 92 10 20 74 mov 0x74, %o1 <== NOT EXECUTED
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;
200c5e4: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
200c5e8: c2 26 20 4c st %g1, [ %i0 + 0x4c ] <== NOT EXECUTED
/*
* If this node has a parent, then put it in that directory list.
*/
if ( parent ) {
200c5ec: 80 a4 20 00 cmp %l0, 0
200c5f0: 02 80 00 0b be 200c61c <IMFS_create_node+0xdc>
200c5f4: 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 );
200c5f8: 7f ff e7 4b call 2006324 <_Chain_Append>
200c5fc: 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;
200c600: 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;
200c604: e0 26 20 08 st %l0, [ %i0 + 8 ]
fs_info = parent_loc->mt_entry->fs_info;
200c608: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
node->st_ino = ++fs_info->ino_count;
200c60c: c4 00 c0 00 ld [ %g3 ], %g2
200c610: 84 00 a0 01 inc %g2
200c614: c4 20 c0 00 st %g2, [ %g3 ]
200c618: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
}
return node;
}
200c61c: 81 c7 e0 08 ret
200c620: 81 e8 00 00 restore
/*
* Set the type specific information
*/
switch (type) {
200c624: 83 2e 60 02 sll %i1, 2, %g1
200c628: 05 00 80 31 sethi %hi(0x200c400), %g2
200c62c: 84 10 a1 24 or %g2, 0x124, %g2 ! 200c524 <device_open+0x50>
200c630: c6 00 80 01 ld [ %g2 + %g1 ], %g3
200c634: 81 c0 c0 00 jmp %g3
200c638: 01 00 00 00 nop
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
200c63c: c0 26 20 4c clr [ %i0 + 0x4c ] <== NOT EXECUTED
node->info.linearfile.direct = 0;
200c640: c0 26 20 50 clr [ %i0 + 0x50 ] <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
200c644: c0 26 20 4c clr [ %i0 + 0x4c ] <== NOT EXECUTED
node->info.file.indirect = 0;
200c648: c0 26 20 50 clr [ %i0 + 0x50 ] <== NOT EXECUTED
node->info.file.doubly_indirect = 0;
200c64c: c0 26 20 54 clr [ %i0 + 0x54 ] <== NOT EXECUTED
node->info.file.triply_indirect = 0;
200c650: 10 bf ff e7 b 200c5ec <IMFS_create_node+0xac> <== NOT EXECUTED
200c654: c0 26 20 58 clr [ %i0 + 0x58 ] <== NOT EXECUTED
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
200c658: 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;
200c65c: c4 07 00 00 ld [ %i4 ], %g2
node->info.device.minor = info->device.minor;
200c660: 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;
200c664: 10 bf ff e2 b 200c5ec <IMFS_create_node+0xac>
200c668: c4 26 20 4c st %g2, [ %i0 + 0x4c ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
200c66c: 82 06 20 50 add %i0, 0x50, %g1
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
200c670: 84 06 20 4c add %i0, 0x4c, %g2
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
200c674: 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);
200c678: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
200c67c: 10 bf ff dc b 200c5ec <IMFS_create_node+0xac>
200c680: c4 26 20 54 st %g2, [ %i0 + 0x54 ]
02009b58 <IMFS_eval_path>:
int IMFS_eval_path(
const char *pathname, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
2009b58: 9d e3 bf 70 save %sp, -144, %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 ) ) {
2009b5c: 80 8e 7f f8 btst -8, %i1
2009b60: 12 80 00 9c bne 2009dd0 <IMFS_eval_path+0x278> <== NEVER TAKEN
2009b64: a6 10 00 18 mov %i0, %l3
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
2009b68: 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 )
2009b6c: 03 00 80 5a sethi %hi(0x2016800), %g1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
2009b70: a4 10 20 00 clr %l2
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
2009b74: ac 10 62 a4 or %g1, 0x2a4, %l6
2009b78: a8 07 bf d0 add %fp, -48, %l4
2009b7c: aa 07 bf f4 add %fp, -12, %l5
* 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 );
2009b80: 90 04 c0 12 add %l3, %l2, %o0
2009b84: 92 10 00 14 mov %l4, %o1
2009b88: 40 00 01 ba call 200a270 <IMFS_get_token>
2009b8c: 94 10 00 15 mov %l5, %o2
i += len;
if ( !pathloc->node_access )
2009b90: c6 06 80 00 ld [ %i2 ], %g3
* 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 );
2009b94: a2 10 00 08 mov %o0, %l1
i += len;
if ( !pathloc->node_access )
2009b98: 80 a0 e0 00 cmp %g3, 0
2009b9c: 02 80 00 57 be 2009cf8 <IMFS_eval_path+0x1a0> <== NEVER TAKEN
2009ba0: c2 07 bf f4 ld [ %fp + -12 ], %g1
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
2009ba4: 80 a2 20 00 cmp %o0, 0
2009ba8: 12 80 00 10 bne 2009be8 <IMFS_eval_path+0x90>
2009bac: a4 04 80 01 add %l2, %g1, %l2
* 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 ) {
2009bb0: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1
2009bb4: 80 a0 60 01 cmp %g1, 1
2009bb8: 12 80 00 6f bne 2009d74 <IMFS_eval_path+0x21c>
2009bbc: 01 00 00 00 nop
if ( node->info.directory.mt_fs != NULL ) {
2009bc0: c6 00 e0 58 ld [ %g3 + 0x58 ], %g3
2009bc4: 80 a0 e0 00 cmp %g3, 0
2009bc8: 02 80 00 6b be 2009d74 <IMFS_eval_path+0x21c> <== ALWAYS TAKEN
2009bcc: 01 00 00 00 nop
newloc = node->info.directory.mt_fs->mt_fs_root;
2009bd0: c8 00 e0 20 ld [ %g3 + 0x20 ], %g4 <== NOT EXECUTED
*pathloc = newloc;
2009bd4: c2 00 e0 24 ld [ %g3 + 0x24 ], %g1 <== NOT EXECUTED
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
2009bd8: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
2009bdc: da 01 00 00 ld [ %g4 ], %o5 <== NOT EXECUTED
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
2009be0: 10 80 00 59 b 2009d44 <IMFS_eval_path+0x1ec> <== NOT EXECUTED
2009be4: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3 <== NOT EXECUTED
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
2009be8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
2009bec: 80 a0 60 01 cmp %g1, 1
2009bf0: 02 80 00 3b be 2009cdc <IMFS_eval_path+0x184> <== ALWAYS TAKEN
2009bf4: 90 10 00 1a mov %i2, %o0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
2009bf8: 80 a4 60 03 cmp %l1, 3
2009bfc: 02 80 00 0b be 2009c28 <IMFS_eval_path+0xd0>
2009c00: a0 10 00 03 mov %g3, %l0
2009c04: 80 a4 60 04 cmp %l1, 4
2009c08: 02 80 00 2f be 2009cc4 <IMFS_eval_path+0x16c> <== NEVER TAKEN
2009c0c: 80 a4 60 02 cmp %l1, 2
2009c10: 02 80 00 1a be 2009c78 <IMFS_eval_path+0x120> <== NEVER TAKEN
2009c14: 80 a4 60 04 cmp %l1, 4
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
2009c18: 12 bf ff db bne 2009b84 <IMFS_eval_path+0x2c> <== ALWAYS TAKEN
2009c1c: 90 04 c0 12 add %l3, %l2, %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 ) {
2009c20: 10 bf ff e5 b 2009bb4 <IMFS_eval_path+0x5c> <== NOT EXECUTED
2009c24: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
2009c28: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1
2009c2c: 80 a0 60 03 cmp %g1, 3
2009c30: 02 80 00 38 be 2009d10 <IMFS_eval_path+0x1b8> <== NEVER TAKEN
2009c34: 80 a0 60 04 cmp %g1, 4
node = pathloc->node_access;
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
2009c38: 02 80 00 6e be 2009df0 <IMFS_eval_path+0x298> <== NEVER TAKEN
2009c3c: 90 10 00 1a mov %i2, %o0
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
2009c40: 80 a0 60 01 cmp %g1, 1
2009c44: 12 80 00 57 bne 2009da0 <IMFS_eval_path+0x248> <== NEVER TAKEN
2009c48: 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 ) {
2009c4c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3
2009c50: 80 a0 e0 00 cmp %g3, 0
2009c54: 12 bf ff df bne 2009bd0 <IMFS_eval_path+0x78> <== NEVER TAKEN
2009c58: 90 10 00 10 mov %l0, %o0
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
2009c5c: 40 00 01 57 call 200a1b8 <IMFS_find_match_in_dir>
2009c60: 92 10 00 14 mov %l4, %o1
if ( !node )
2009c64: a0 92 20 00 orcc %o0, 0, %l0
2009c68: 02 80 00 24 be 2009cf8 <IMFS_eval_path+0x1a0> <== NEVER TAKEN
2009c6c: 01 00 00 00 nop
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
2009c70: 10 bf ff c4 b 2009b80 <IMFS_eval_path+0x28>
2009c74: e0 26 80 00 st %l0, [ %i2 ]
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
2009c78: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
2009c7c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
2009c80: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
2009c84: 02 bf ff c0 be 2009b84 <IMFS_eval_path+0x2c> <== NOT EXECUTED
2009c88: 90 04 c0 12 add %l3, %l2, %o0 <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
2009c8c: d8 06 a0 0c ld [ %i2 + 0xc ], %o4 <== NOT EXECUTED
2009c90: c2 03 20 18 ld [ %o4 + 0x18 ], %g1 <== NOT EXECUTED
2009c94: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2009c98: 22 80 00 27 be,a 2009d34 <IMFS_eval_path+0x1dc> <== NOT EXECUTED
2009c9c: c8 03 20 10 ld [ %o4 + 0x10 ], %g4 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
}
} else {
if ( !node->Parent )
2009ca0: e0 00 e0 08 ld [ %g3 + 8 ], %l0 <== NOT EXECUTED
2009ca4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2009ca8: 32 bf ff b7 bne,a 2009b84 <IMFS_eval_path+0x2c> <== NOT EXECUTED
2009cac: e0 26 80 00 st %l0, [ %i2 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
2009cb0: 40 00 0c 65 call 200ce44 <__errno> <== NOT EXECUTED
2009cb4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009cb8: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
2009cbc: 81 c7 e0 08 ret <== NOT EXECUTED
2009cc0: 81 e8 00 00 restore <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
2009cc4: 40 00 0c 60 call 200ce44 <__errno> <== NOT EXECUTED
2009cc8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009ccc: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
2009cd0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009cd4: 81 c7 e0 08 ret <== NOT EXECUTED
2009cd8: 81 e8 00 00 restore <== NOT EXECUTED
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
2009cdc: 7f ff ff 3b call 20099c8 <IMFS_evaluate_permission>
2009ce0: 92 10 20 01 mov 1, %o1
2009ce4: 80 a2 20 00 cmp %o0, 0
2009ce8: 02 80 00 4b be 2009e14 <IMFS_eval_path+0x2bc> <== NEVER TAKEN
2009cec: 01 00 00 00 nop
2009cf0: 10 bf ff c2 b 2009bf8 <IMFS_eval_path+0xa0>
2009cf4: c6 06 80 00 ld [ %i2 ], %g3
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
2009cf8: 40 00 0c 53 call 200ce44 <__errno> <== NOT EXECUTED
2009cfc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009d00: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
2009d04: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009d08: 81 c7 e0 08 ret <== NOT EXECUTED
2009d0c: 81 e8 00 00 restore <== NOT EXECUTED
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
2009d10: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2009d14: 7f ff ff 3e call 2009a0c <IMFS_evaluate_hard_link> <== NOT EXECUTED
2009d18: 92 10 20 00 clr %o1 <== NOT EXECUTED
node = pathloc->node_access;
2009d1c: e0 06 80 00 ld [ %i2 ], %l0 <== NOT EXECUTED
if ( !node )
2009d20: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2009d24: 02 80 00 1f be 2009da0 <IMFS_eval_path+0x248> <== NOT EXECUTED
2009d28: 01 00 00 00 nop <== NOT EXECUTED
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
2009d2c: 10 bf ff c5 b 2009c40 <IMFS_eval_path+0xe8> <== NOT EXECUTED
2009d30: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== 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;
*pathloc = newloc;
2009d34: c2 03 20 14 ld [ %o4 + 0x14 ], %g1 <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc);
2009d38: da 01 00 00 ld [ %g4 ], %o5 <== 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;
2009d3c: c4 03 20 0c ld [ %o4 + 0xc ], %g2 <== NOT EXECUTED
2009d40: c6 03 20 08 ld [ %o4 + 8 ], %g3 <== NOT EXECUTED
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
2009d44: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
2009d48: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
2009d4c: 90 24 80 08 sub %l2, %o0, %o0 <== NOT EXECUTED
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
2009d50: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
2009d54: c6 26 80 00 st %g3, [ %i2 ] <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
2009d58: 90 04 c0 08 add %l3, %o0, %o0 <== NOT EXECUTED
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
2009d5c: c8 26 a0 08 st %g4, [ %i2 + 8 ] <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc );
2009d60: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2009d64: 9f c3 40 00 call %o5 <== NOT EXECUTED
2009d68: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2009d6c: 81 c7 e0 08 ret <== NOT EXECUTED
2009d70: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
2009d74: 7f ff fe f7 call 2009950 <IMFS_Set_handlers>
2009d78: 90 10 00 1a mov %i2, %o0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
2009d7c: 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 );
2009d80: b0 10 00 08 mov %o0, %i0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
2009d84: 7f ff ff 11 call 20099c8 <IMFS_evaluate_permission>
2009d88: 90 10 00 1a mov %i2, %o0
2009d8c: 80 a2 20 00 cmp %o0, 0
2009d90: 02 80 00 0a be 2009db8 <IMFS_eval_path+0x260> <== NEVER TAKEN
2009d94: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
2009d98: 81 c7 e0 08 ret
2009d9c: 81 e8 00 00 restore
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
2009da0: 40 00 0c 29 call 200ce44 <__errno> <== NOT EXECUTED
2009da4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009da8: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
2009dac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009db0: 81 c7 e0 08 ret <== NOT EXECUTED
2009db4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
2009db8: 40 00 0c 23 call 200ce44 <__errno> <== NOT EXECUTED
2009dbc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009dc0: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
2009dc4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
2009dc8: 81 c7 e0 08 ret <== NOT EXECUTED
2009dcc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_filesystem_location_info_t newloc;
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
assert( 0 );
2009dd0: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
2009dd4: 15 00 80 56 sethi %hi(0x2015800), %o2 <== NOT EXECUTED
2009dd8: 17 00 80 56 sethi %hi(0x2015800), %o3 <== NOT EXECUTED
2009ddc: 90 12 22 b0 or %o0, 0x2b0, %o0 <== NOT EXECUTED
2009de0: 94 12 a2 a0 or %o2, 0x2a0, %o2 <== NOT EXECUTED
2009de4: 96 12 e3 00 or %o3, 0x300, %o3 <== NOT EXECUTED
2009de8: 7f ff e0 56 call 2001f40 <__assert_func> <== NOT EXECUTED
2009dec: 92 10 21 ea mov 0x1ea, %o1 <== NOT EXECUTED
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
2009df0: 7f ff ff 22 call 2009a78 <IMFS_evaluate_sym_link> <== NOT EXECUTED
2009df4: 92 10 20 00 clr %o1 <== NOT EXECUTED
2009df8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
node = pathloc->node_access;
if ( result == -1 )
2009dfc: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2009e00: 02 bf ff af be 2009cbc <IMFS_eval_path+0x164> <== NOT EXECUTED
2009e04: 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;
2009e08: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2009e0c: 10 bf ff 8d b 2009c40 <IMFS_eval_path+0xe8> <== NOT EXECUTED
2009e10: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
2009e14: 40 00 0c 0c call 200ce44 <__errno> <== NOT EXECUTED
2009e18: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009e1c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
2009e20: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009e24: 81 c7 e0 08 ret <== NOT EXECUTED
2009e28: 81 e8 00 00 restore <== NOT EXECUTED
02009ef8 <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 */
)
{
2009ef8: 9d e3 bf 70 save %sp, -144, %sp
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
2009efc: e2 06 40 00 ld [ %i1 ], %l1
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
2009f00: a6 10 00 18 mov %i0, %l3
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
2009f04: 03 00 80 5a sethi %hi(0x2016800), %g1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
2009f08: b0 10 20 00 clr %i0
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
2009f0c: ac 10 62 a4 or %g1, 0x2a4, %l6
2009f10: a8 07 bf d0 add %fp, -48, %l4
2009f14: aa 07 bf f4 add %fp, -12, %l5
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
2009f18: 90 04 c0 18 add %l3, %i0, %o0
2009f1c: 92 10 00 14 mov %l4, %o1
2009f20: 40 00 00 d4 call 200a270 <IMFS_get_token>
2009f24: 94 10 00 15 mov %l5, %o2
i += len;
if ( !pathloc->node_access )
2009f28: c6 06 40 00 ld [ %i1 ], %g3
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
2009f2c: a0 10 00 08 mov %o0, %l0
i += len;
if ( !pathloc->node_access )
2009f30: 80 a0 e0 00 cmp %g3, 0
2009f34: 02 80 00 5f be 200a0b0 <IMFS_evaluate_for_make+0x1b8> <== NEVER TAKEN
2009f38: e4 07 bf f4 ld [ %fp + -12 ], %l2
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
2009f3c: 80 a2 20 00 cmp %o0, 0
2009f40: 32 80 00 08 bne,a 2009f60 <IMFS_evaluate_for_make+0x68> <== ALWAYS TAKEN
2009f44: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
pathloc->node_access = node;
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
2009f48: 40 00 0b bf call 200ce44 <__errno> <== NOT EXECUTED
2009f4c: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
2009f50: 82 10 20 11 mov 0x11, %g1 <== NOT EXECUTED
2009f54: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
2009f58: 81 c7 e0 08 ret
2009f5c: 91 e8 00 11 restore %g0, %l1, %o0
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
2009f60: 80 a0 60 01 cmp %g1, 1
2009f64: 02 80 00 59 be 200a0c8 <IMFS_evaluate_for_make+0x1d0> <== ALWAYS TAKEN
2009f68: 90 10 00 19 mov %i1, %o0
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
i += len;
2009f6c: b0 06 00 12 add %i0, %l2, %i0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
2009f70: 80 a4 20 02 cmp %l0, 2
2009f74: 02 80 00 2c be 200a024 <IMFS_evaluate_for_make+0x12c> <== NEVER TAKEN
2009f78: a2 10 00 03 mov %g3, %l1
2009f7c: 80 a4 20 02 cmp %l0, 2
2009f80: 08 80 00 0d bleu 2009fb4 <IMFS_evaluate_for_make+0xbc>
2009f84: 80 a4 20 00 cmp %l0, 0
2009f88: 80 a4 20 03 cmp %l0, 3
2009f8c: 02 80 00 0e be 2009fc4 <IMFS_evaluate_for_make+0xcc> <== ALWAYS TAKEN
2009f90: 80 a4 20 04 cmp %l0, 4
2009f94: 12 bf ff e2 bne 2009f1c <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
2009f98: 90 04 c0 18 add %l3, %i0, %o0 <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
2009f9c: 40 00 0b aa call 200ce44 <__errno> <== NOT EXECUTED
2009fa0: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
2009fa4: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED
2009fa8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
2009fac: 81 c7 e0 08 ret <== NOT EXECUTED
2009fb0: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
2009fb4: 02 bf ff e5 be 2009f48 <IMFS_evaluate_for_make+0x50> <== NEVER TAKEN
2009fb8: 90 04 c0 18 add %l3, %i0, %o0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], token, &len );
2009fbc: 10 bf ff d9 b 2009f20 <IMFS_evaluate_for_make+0x28>
2009fc0: 92 10 00 14 mov %l4, %o1
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
2009fc4: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1
2009fc8: 80 a0 60 03 cmp %g1, 3
2009fcc: 02 80 00 6e be 200a184 <IMFS_evaluate_for_make+0x28c> <== NEVER TAKEN
2009fd0: 80 a0 60 04 cmp %g1, 4
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
2009fd4: 02 80 00 6d be 200a188 <IMFS_evaluate_for_make+0x290> <== NEVER TAKEN
2009fd8: 90 10 00 19 mov %i1, %o0
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
2009fdc: 80 a4 60 00 cmp %l1, 0
2009fe0: 02 80 00 53 be 200a12c <IMFS_evaluate_for_make+0x234> <== NEVER TAKEN
2009fe4: 01 00 00 00 nop
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
2009fe8: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
2009fec: 80 a0 60 01 cmp %g1, 1
2009ff0: 12 80 00 4f bne 200a12c <IMFS_evaluate_for_make+0x234> <== NEVER TAKEN
2009ff4: 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 ) {
2009ff8: c6 04 60 58 ld [ %l1 + 0x58 ], %g3
2009ffc: 80 a0 e0 00 cmp %g3, 0
200a000: 12 80 00 50 bne 200a140 <IMFS_evaluate_for_make+0x248> <== NEVER TAKEN
200a004: 90 10 00 11 mov %l1, %o0
/*
* Otherwise find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
200a008: 40 00 00 6c call 200a1b8 <IMFS_find_match_in_dir>
200a00c: 92 10 00 14 mov %l4, %o1
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
200a010: a2 92 20 00 orcc %o0, 0, %l1
200a014: 02 80 00 16 be 200a06c <IMFS_evaluate_for_make+0x174>
200a018: c2 07 bf f4 ld [ %fp + -12 ], %g1
done = true;
else
pathloc->node_access = node;
200a01c: 10 bf ff bf b 2009f18 <IMFS_evaluate_for_make+0x20>
200a020: e2 26 40 00 st %l1, [ %i1 ]
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
200a024: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
200a028: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
200a02c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
200a030: 02 bf ff bb be 2009f1c <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
200a034: 90 04 c0 18 add %l3, %i0, %o0 <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
200a038: d8 06 60 0c ld [ %i1 + 0xc ], %o4 <== NOT EXECUTED
200a03c: c2 03 20 18 ld [ %o4 + 0x18 ], %g1 <== NOT EXECUTED
200a040: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
200a044: 22 80 00 58 be,a 200a1a4 <IMFS_evaluate_for_make+0x2ac> <== NOT EXECUTED
200a048: c8 03 20 10 ld [ %o4 + 0x10 ], %g4 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
200a04c: e2 00 e0 08 ld [ %g3 + 8 ], %l1 <== NOT EXECUTED
200a050: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
200a054: 32 bf ff b2 bne,a 2009f1c <IMFS_evaluate_for_make+0x24> <== NOT EXECUTED
200a058: e2 26 40 00 st %l1, [ %i1 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
200a05c: 40 00 0b 7a call 200ce44 <__errno> <== NOT EXECUTED
200a060: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
200a064: 10 bf ff bd b 2009f58 <IMFS_evaluate_for_make+0x60> <== NOT EXECUTED
200a068: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
200a06c: 82 26 00 01 sub %i0, %g1, %g1
200a070: 82 04 c0 01 add %l3, %g1, %g1
200a074: 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++) {
200a078: c2 4c c0 18 ldsb [ %l3 + %i0 ], %g1
200a07c: 80 a0 60 00 cmp %g1, 0
200a080: 12 80 00 07 bne 200a09c <IMFS_evaluate_for_make+0x1a4> <== NEVER TAKEN
200a084: 84 04 c0 18 add %l3, %i0, %g2
200a088: 30 80 00 17 b,a 200a0e4 <IMFS_evaluate_for_make+0x1ec>
200a08c: c2 48 a0 01 ldsb [ %g2 + 1 ], %g1 <== NOT EXECUTED
200a090: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200a094: 02 80 00 14 be 200a0e4 <IMFS_evaluate_for_make+0x1ec> <== NOT EXECUTED
200a098: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if ( !IMFS_is_separator( path[ i ] ) )
200a09c: 80 a0 60 2f cmp %g1, 0x2f <== NOT EXECUTED
200a0a0: 02 bf ff fb be 200a08c <IMFS_evaluate_for_make+0x194> <== NOT EXECUTED
200a0a4: 80 a0 60 5c cmp %g1, 0x5c <== NOT EXECUTED
200a0a8: 22 bf ff fa be,a 200a090 <IMFS_evaluate_for_make+0x198> <== NOT EXECUTED
200a0ac: c2 48 a0 01 ldsb [ %g2 + 1 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOENT );
200a0b0: 40 00 0b 65 call 200ce44 <__errno> <== NOT EXECUTED
200a0b4: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
200a0b8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
200a0bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
200a0c0: 81 c7 e0 08 ret <== NOT EXECUTED
200a0c4: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
200a0c8: 7f ff fe 40 call 20099c8 <IMFS_evaluate_permission>
200a0cc: 92 10 20 01 mov 1, %o1
200a0d0: 80 a2 20 00 cmp %o0, 0
200a0d4: 02 80 00 11 be 200a118 <IMFS_evaluate_for_make+0x220> <== NEVER TAKEN
200a0d8: 01 00 00 00 nop
200a0dc: 10 bf ff a4 b 2009f6c <IMFS_evaluate_for_make+0x74>
200a0e0: c6 06 40 00 ld [ %i1 ], %g3
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
200a0e4: 7f ff fe 1b call 2009950 <IMFS_Set_handlers>
200a0e8: 90 10 00 19 mov %i1, %o0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
200a0ec: c2 06 40 00 ld [ %i1 ], %g1
200a0f0: c4 00 60 48 ld [ %g1 + 0x48 ], %g2
200a0f4: 80 a0 a0 01 cmp %g2, 1
200a0f8: 12 80 00 0d bne 200a12c <IMFS_evaluate_for_make+0x234> <== NEVER TAKEN
200a0fc: a2 10 00 08 mov %o0, %l1
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
200a100: 90 10 00 19 mov %i1, %o0
200a104: 7f ff fe 31 call 20099c8 <IMFS_evaluate_permission>
200a108: 92 10 20 03 mov 3, %o1
200a10c: 80 a2 20 00 cmp %o0, 0
200a110: 12 bf ff 92 bne 2009f58 <IMFS_evaluate_for_make+0x60> <== ALWAYS TAKEN
200a114: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EACCES );
200a118: 40 00 0b 4b call 200ce44 <__errno> <== NOT EXECUTED
200a11c: a2 10 3f ff mov -1, %l1 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
200a120: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
200a124: 10 bf ff 8d b 2009f58 <IMFS_evaluate_for_make+0x60> <== NOT EXECUTED
200a128: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
200a12c: 40 00 0b 46 call 200ce44 <__errno> <== NOT EXECUTED
200a130: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
200a134: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
200a138: 10 bf ff 88 b 2009f58 <IMFS_evaluate_for_make+0x60> <== NOT EXECUTED
200a13c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
200a140: c8 00 e0 20 ld [ %g3 + 0x20 ], %g4 <== NOT EXECUTED
*pathloc = newloc;
200a144: c2 00 e0 24 ld [ %g3 + 0x24 ], %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 ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
200a148: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a14c: da 01 20 04 ld [ %g4 + 4 ], %o5 <== NOT EXECUTED
* If we are at a node that is a mount point. Set loc to the
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
200a150: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3 <== NOT EXECUTED
*pathloc = newloc;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a154: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
200a158: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a15c: 90 26 00 08 sub %i0, %o0, %o0 <== NOT EXECUTED
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
200a160: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
200a164: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a168: 90 04 c0 08 add %l3, %o0, %o0 <== NOT EXECUTED
* new fs root node and let them finish evaluating the path.
*/
if ( node->info.directory.mt_fs != NULL ) {
newloc = node->info.directory.mt_fs->mt_fs_root;
*pathloc = newloc;
200a16c: c8 26 60 08 st %g4, [ %i1 + 8 ] <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a170: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200a174: 9f c3 40 00 call %o5 <== NOT EXECUTED
200a178: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
200a17c: 10 bf ff 77 b 2009f58 <IMFS_evaluate_for_make+0x60> <== NOT EXECUTED
200a180: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
200a184: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200a188: 7f ff ff 29 call 2009e2c <IMFS_evaluate_link> <== NOT EXECUTED
200a18c: 92 10 20 00 clr %o1 <== NOT EXECUTED
if ( result == -1 )
200a190: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
200a194: 02 bf ff 71 be 2009f58 <IMFS_evaluate_for_make+0x60> <== NOT EXECUTED
200a198: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
200a19c: 10 bf ff 90 b 2009fdc <IMFS_evaluate_for_make+0xe4> <== NOT EXECUTED
200a1a0: e2 06 40 00 ld [ %i1 ], %l1 <== NOT EXECUTED
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
200a1a4: c2 03 20 14 ld [ %o4 + 0x14 ], %g1 <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
200a1a8: da 01 20 04 ld [ %g4 + 4 ], %o5 <== NOT EXECUTED
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
newloc = pathloc->mt_entry->mt_point_node;
200a1ac: c4 03 20 0c ld [ %o4 + 0xc ], %g2 <== NOT EXECUTED
200a1b0: 10 bf ff e9 b 200a154 <IMFS_evaluate_for_make+0x25c> <== NOT EXECUTED
200a1b4: c6 03 20 08 ld [ %o4 + 8 ], %g3 <== NOT EXECUTED
02009a0c <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
2009a0c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
2009a10: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
2009a14: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 <== NOT EXECUTED
2009a18: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
2009a1c: 12 80 00 14 bne 2009a6c <IMFS_evaluate_hard_link+0x60> <== NOT EXECUTED
2009a20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
2009a24: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1 <== NOT EXECUTED
IMFS_Set_handlers( node );
2009a28: 7f ff ff ca call 2009950 <IMFS_Set_handlers> <== NOT EXECUTED
2009a2c: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
2009a30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2009a34: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2009a38: 7f ff ff e4 call 20099c8 <IMFS_evaluate_permission> <== NOT EXECUTED
2009a3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2009a40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2009a44: 02 80 00 04 be 2009a54 <IMFS_evaluate_hard_link+0x48> <== NOT EXECUTED
2009a48: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
2009a4c: 81 c7 e0 08 ret <== NOT EXECUTED
2009a50: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
2009a54: 40 00 0c fc call 200ce44 <__errno> <== NOT EXECUTED
2009a58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2009a5c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
2009a60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return result;
}
2009a64: 81 c7 e0 08 ret <== NOT EXECUTED
2009a68: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
rtems_fatal_error_occurred (0xABCD0000);
2009a6c: 7f ff f1 3e call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2009a70: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
02009e2c <IMFS_evaluate_link>:
int IMFS_evaluate_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
2009e2c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
2009e30: 25 00 80 5a sethi %hi(0x2016800), %l2 <== NOT EXECUTED
2009e34: 10 80 00 07 b 2009e50 <IMFS_evaluate_link+0x24> <== NOT EXECUTED
2009e38: a2 14 a2 a4 or %l2, 0x2a4, %l1 ! 2016aa4 <rtems_current_user_env><== NOT EXECUTED
*/
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
2009e3c: 02 80 00 23 be 2009ec8 <IMFS_evaluate_link+0x9c> <== NOT EXECUTED
2009e40: 82 00 7f fd add %g1, -3, %g1 <== NOT EXECUTED
result = IMFS_evaluate_sym_link( node, flags );
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
2009e44: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
2009e48: 18 80 00 1c bgu 2009eb8 <IMFS_evaluate_link+0x8c> <== NOT EXECUTED
2009e4c: 90 10 20 00 clr %o0 <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
2009e50: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED
{
IMFS_jnode_t *jnode;
int result = 0;
do {
jnode = node->node_access;
2009e54: e0 06 00 00 ld [ %i0 ], %l0 <== NOT EXECUTED
/*
* Increment and check the link counter.
*/
rtems_filesystem_link_counts ++;
2009e58: c2 10 a0 26 lduh [ %g2 + 0x26 ], %g1 <== NOT EXECUTED
2009e5c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2009e60: c2 30 a0 26 sth %g1, [ %g2 + 0x26 ] <== NOT EXECUTED
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
2009e64: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
2009e68: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
2009e6c: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED
2009e70: 18 80 00 1b bgu 2009edc <IMFS_evaluate_link+0xb0> <== NOT EXECUTED
2009e74: 01 00 00 00 nop <== NOT EXECUTED
/*
* Follow the Link node.
*/
if ( jnode->type == IMFS_HARD_LINK )
2009e78: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
2009e7c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
2009e80: 12 bf ff ef bne 2009e3c <IMFS_evaluate_link+0x10> <== NOT EXECUTED
2009e84: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
result = IMFS_evaluate_hard_link( node, flags );
2009e88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2009e8c: 7f ff fe e0 call 2009a0c <IMFS_evaluate_hard_link> <== NOT EXECUTED
2009e90: 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 ) ) );
2009e94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2009e98: 12 80 00 09 bne 2009ebc <IMFS_evaluate_link+0x90> <== NOT EXECUTED
2009e9c: c2 04 a2 a4 ld [ %l2 + 0x2a4 ], %g1 <== NOT EXECUTED
2009ea0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
2009ea4: 82 00 7f fd add %g1, -3, %g1 <== NOT EXECUTED
2009ea8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
2009eac: 28 bf ff ea bleu,a 2009e54 <IMFS_evaluate_link+0x28> <== NOT EXECUTED
2009eb0: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED
2009eb4: 90 10 20 00 clr %o0 <== NOT EXECUTED
/*
* Clear link counter.
*/
rtems_filesystem_link_counts = 0;
2009eb8: c2 04 a2 a4 ld [ %l2 + 0x2a4 ], %g1 <== NOT EXECUTED
2009ebc: c0 30 60 26 clrh [ %g1 + 0x26 ] <== NOT EXECUTED
return result;
}
2009ec0: 81 c7 e0 08 ret <== NOT EXECUTED
2009ec4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if ( jnode->type == IMFS_HARD_LINK )
result = IMFS_evaluate_hard_link( node, flags );
else if (jnode->type == IMFS_SYM_LINK )
result = IMFS_evaluate_sym_link( node, flags );
2009ec8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2009ecc: 7f ff fe eb call 2009a78 <IMFS_evaluate_sym_link> <== NOT EXECUTED
2009ed0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
} while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) ||
( jnode->type == IMFS_HARD_LINK ) ) );
2009ed4: 10 bf ff f1 b 2009e98 <IMFS_evaluate_link+0x6c> <== NOT EXECUTED
2009ed8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
*/
rtems_filesystem_link_counts ++;
if ( rtems_filesystem_link_counts > MAXSYMLINK ) {
rtems_filesystem_link_counts = 0;
rtems_set_errno_and_return_minus_one( ELOOP );
2009edc: 40 00 0b da call 200ce44 <__errno> <== NOT EXECUTED
2009ee0: c0 30 a0 26 clrh [ %g2 + 0x26 ] <== NOT EXECUTED
2009ee4: 82 10 20 5c mov 0x5c, %g1 <== NOT EXECUTED
2009ee8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009eec: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
*/
rtems_filesystem_link_counts = 0;
return result;
}
2009ef0: 81 c7 e0 08 ret <== NOT EXECUTED
2009ef4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020099c8 <IMFS_evaluate_permission>:
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
20099c8: 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 ) )
20099cc: 80 8e 7f f8 btst -8, %i1
20099d0: 12 80 00 09 bne 20099f4 <IMFS_evaluate_permission+0x2c> <== NEVER TAKEN
20099d4: 87 2e 60 06 sll %i1, 6, %g3
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
flags_to_test <<= 6;
20099d8: c2 06 00 00 ld [ %i0 ], %g1
20099dc: c4 10 60 2e lduh [ %g1 + 0x2e ], %g2
20099e0: 84 28 c0 02 andn %g3, %g2, %g2
20099e4: 80 a0 00 02 cmp %g0, %g2
20099e8: b0 60 3f ff subx %g0, -1, %i0
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
return 1;
return 0;
}
20099ec: 81 c7 e0 08 ret
20099f0: 81 e8 00 00 restore
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
20099f4: 40 00 0d 14 call 200ce44 <__errno> <== NOT EXECUTED
20099f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20099fc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2009a00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2009a04: 81 c7 e0 08 ret <== NOT EXECUTED
2009a08: 81 e8 00 00 restore <== NOT EXECUTED
02009a78 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
2009a78: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
IMFS_jnode_t *jnode = node->node_access;
2009a7c: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
2009a80: c2 02 20 48 ld [ %o0 + 0x48 ], %g1 <== NOT EXECUTED
2009a84: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
2009a88: 12 80 00 2f bne 2009b44 <IMFS_evaluate_sym_link+0xcc> <== NOT EXECUTED
2009a8c: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
2009a90: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
2009a94: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2009a98: 02 80 00 2d be 2009b4c <IMFS_evaluate_sym_link+0xd4> <== NOT EXECUTED
2009a9c: 01 00 00 00 nop <== NOT EXECUTED
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
2009aa0: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
rtems_filesystem_get_sym_start_loc(
2009aa4: d0 02 20 4c ld [ %o0 + 0x4c ], %o0 <== NOT EXECUTED
2009aa8: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
2009aac: 80 a0 60 2f cmp %g1, 0x2f <== NOT EXECUTED
2009ab0: 02 80 00 06 be 2009ac8 <IMFS_evaluate_sym_link+0x50> <== NOT EXECUTED
2009ab4: 80 a0 60 5c cmp %g1, 0x5c <== NOT EXECUTED
2009ab8: 02 80 00 04 be 2009ac8 <IMFS_evaluate_sym_link+0x50> <== NOT EXECUTED
2009abc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2009ac0: 12 80 00 0d bne 2009af4 <IMFS_evaluate_sym_link+0x7c> <== NOT EXECUTED
2009ac4: 88 10 20 00 clr %g4 <== NOT EXECUTED
2009ac8: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
2009acc: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 ! 2016aa4 <rtems_current_user_env><== NOT EXECUTED
2009ad0: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED
2009ad4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED
2009ad8: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED
2009adc: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 <== NOT EXECUTED
2009ae0: c4 26 20 04 st %g2, [ %i0 + 4 ] <== NOT EXECUTED
2009ae4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
2009ae8: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
2009aec: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 <== NOT EXECUTED
2009af0: c4 26 20 0c st %g2, [ %i0 + 0xc ] <== NOT EXECUTED
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
2009af4: 90 02 00 04 add %o0, %g4, %o0 <== NOT EXECUTED
2009af8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2009afc: 40 00 00 17 call 2009b58 <IMFS_eval_path> <== NOT EXECUTED
2009b00: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2009b04: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
&jnode->info.sym_link.name[i],
flags,
node
);
IMFS_Set_handlers( node );
2009b08: 7f ff ff 92 call 2009950 <IMFS_Set_handlers> <== NOT EXECUTED
2009b0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
2009b10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2009b14: 7f ff ff ad call 20099c8 <IMFS_evaluate_permission> <== NOT EXECUTED
2009b18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2009b1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2009b20: 02 80 00 04 be 2009b30 <IMFS_evaluate_sym_link+0xb8> <== NOT EXECUTED
2009b24: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
2009b28: 81 c7 e0 08 ret <== NOT EXECUTED
2009b2c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
2009b30: 40 00 0c c5 call 200ce44 <__errno> <== NOT EXECUTED
2009b34: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
2009b38: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
2009b3c: 10 bf ff fb b 2009b28 <IMFS_evaluate_sym_link+0xb0> <== NOT EXECUTED
2009b40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
rtems_fatal_error_occurred (0xABCD0000);
2009b44: 7f ff f1 08 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2009b48: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
if ( !jnode->Parent )
rtems_fatal_error_occurred( 0xBAD00000 );
2009b4c: 7f ff f1 06 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2009b50: 11 2e b4 00 sethi %hi(0xbad00000), %o0 <== NOT EXECUTED
0200c684 <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
200c684: 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 ) ) )
200c688: 83 2e 60 10 sll %i1, 0x10, %g1 <== NOT EXECUTED
200c68c: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
200c690: 82 08 7e 00 and %g1, -512, %g1 <== NOT EXECUTED
200c694: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200c698: 12 80 00 0e bne 200c6d0 <IMFS_fchmod+0x4c> <== NOT EXECUTED
200c69c: f0 06 00 00 ld [ %i0 ], %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO);
jnode->st_mode |= mode;
200c6a0: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1 <== NOT EXECUTED
IMFS_update_ctime( jnode );
200c6a4: 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;
200c6a8: 82 08 7e 00 and %g1, -512, %g1 <== NOT EXECUTED
200c6ac: 82 16 40 01 or %i1, %g1, %g1 <== NOT EXECUTED
IMFS_update_ctime( jnode );
200c6b0: 92 10 20 00 clr %o1 <== NOT EXECUTED
200c6b4: 7f ff f9 01 call 200aab8 <gettimeofday> <== NOT EXECUTED
200c6b8: c2 36 20 2e sth %g1, [ %i0 + 0x2e ] <== NOT EXECUTED
200c6bc: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
200c6c0: 84 10 20 00 clr %g2 <== NOT EXECUTED
200c6c4: c2 26 20 44 st %g1, [ %i0 + 0x44 ] <== NOT EXECUTED
return 0;
}
200c6c8: 81 c7 e0 08 ret <== NOT EXECUTED
200c6cc: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED
/*
* Change only the RWX permissions on the jnode to mode.
*/
if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) )
rtems_set_errno_and_return_minus_one( EPERM );
200c6d0: 40 00 01 dd call 200ce44 <__errno> <== NOT EXECUTED
200c6d4: 01 00 00 00 nop <== NOT EXECUTED
200c6d8: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1> <== NOT EXECUTED
200c6dc: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED
200c6e0: 10 bf ff fa b 200c6c8 <IMFS_fchmod+0x44> <== NOT EXECUTED
200c6e4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
0200a1b8 <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
200a1b8: 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 );
200a1bc: 80 a6 20 00 cmp %i0, 0
200a1c0: 02 80 00 15 be 200a214 <IMFS_find_match_in_dir+0x5c> <== NEVER TAKEN
200a1c4: 80 a6 60 00 cmp %i1, 0
if ( !name )
200a1c8: 02 80 00 11 be 200a20c <IMFS_find_match_in_dir+0x54> <== NEVER TAKEN
200a1cc: 90 10 00 19 mov %i1, %o0
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
200a1d0: 13 00 80 56 sethi %hi(0x2015800), %o1
200a1d4: 40 00 0f ec call 200e184 <strcmp>
200a1d8: 92 12 63 70 or %o1, 0x370, %o1 ! 2015b70 <dotname>
200a1dc: 80 a2 20 00 cmp %o0, 0
200a1e0: 02 80 00 09 be 200a204 <IMFS_find_match_in_dir+0x4c> <== NEVER TAKEN
200a1e4: 90 10 00 19 mov %i1, %o0
return directory;
if ( !strcmp( name, dotdotname ) )
200a1e8: 13 00 80 56 sethi %hi(0x2015800), %o1
200a1ec: 40 00 0f e6 call 200e184 <strcmp>
200a1f0: 92 12 63 78 or %o1, 0x378, %o1 ! 2015b78 <dotdotname>
200a1f4: 80 a2 20 00 cmp %o0, 0
200a1f8: 32 80 00 0f bne,a 200a234 <IMFS_find_match_in_dir+0x7c> <== ALWAYS TAKEN
200a1fc: e0 06 20 4c ld [ %i0 + 0x4c ], %l0
return directory->Parent;
200a200: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED
200a204: 81 c7 e0 08 ret <== NOT EXECUTED
200a208: 81 e8 00 00 restore <== NOT EXECUTED
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
200a20c: 81 c7 e0 08 ret
200a210: 91 e8 20 00 restore %g0, 0, %o0
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
200a214: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
200a218: 15 00 80 56 sethi %hi(0x2015800), %o2 <== NOT EXECUTED
200a21c: 17 00 80 56 sethi %hi(0x2015800), %o3 <== NOT EXECUTED
200a220: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
200a224: 94 12 a3 80 or %o2, 0x380, %o2 <== NOT EXECUTED
200a228: 96 12 e3 60 or %o3, 0x360, %o3 <== NOT EXECUTED
200a22c: 7f ff df 45 call 2001f40 <__assert_func> <== NOT EXECUTED
200a230: 92 10 20 2a mov 0x2a, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
200a234: b0 06 20 50 add %i0, 0x50, %i0
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
200a238: 80 a4 00 18 cmp %l0, %i0
200a23c: 12 80 00 06 bne 200a254 <IMFS_find_match_in_dir+0x9c>
200a240: 90 10 00 19 mov %i1, %o0
200a244: 30 bf ff f2 b,a 200a20c <IMFS_find_match_in_dir+0x54>
200a248: 80 a4 00 18 cmp %l0, %i0
200a24c: 02 bf ff f0 be 200a20c <IMFS_find_match_in_dir+0x54>
200a250: 90 10 00 19 mov %i1, %o0
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
200a254: 40 00 0f cc call 200e184 <strcmp>
200a258: 92 04 20 0c add %l0, 0xc, %o1
200a25c: 80 a2 20 00 cmp %o0, 0
200a260: 32 bf ff fa bne,a 200a248 <IMFS_find_match_in_dir+0x90>
200a264: e0 04 00 00 ld [ %l0 ], %l0
200a268: 81 c7 e0 08 ret
200a26c: 91 e8 00 10 restore %g0, %l0, %o0
0200a270 <IMFS_get_token>:
IMFS_token_types IMFS_get_token(
const char *path,
char *token,
int *token_len
)
{
200a270: 9d e3 bf 98 save %sp, -104, %sp
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
200a274: c4 0e 00 00 ldub [ %i0 ], %g2
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
200a278: 87 28 a0 18 sll %g2, 0x18, %g3
200a27c: 83 38 e0 18 sra %g3, 0x18, %g1
200a280: 80 a0 60 2f cmp %g1, 0x2f
200a284: 02 80 00 28 be 200a324 <IMFS_get_token+0xb4>
200a288: 80 a0 60 5c cmp %g1, 0x5c
200a28c: 02 80 00 26 be 200a324 <IMFS_get_token+0xb4> <== NEVER TAKEN
200a290: 80 a0 60 00 cmp %g1, 0
200a294: 02 80 00 2c be 200a344 <IMFS_get_token+0xd4>
200a298: 86 10 20 00 clr %g3
token[i] = c;
200a29c: c4 2e 40 00 stb %g2, [ %i1 ]
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
200a2a0: 86 00 e0 01 inc %g3
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
200a2a4: c2 4e 00 03 ldsb [ %i0 + %g3 ], %g1
200a2a8: 80 a0 60 2f cmp %g1, 0x2f
200a2ac: 02 80 00 07 be 200a2c8 <IMFS_get_token+0x58>
200a2b0: c4 0e 00 03 ldub [ %i0 + %g3 ], %g2
200a2b4: 80 a0 60 5c cmp %g1, 0x5c
200a2b8: 02 80 00 04 be 200a2c8 <IMFS_get_token+0x58> <== NEVER TAKEN
200a2bc: 80 a0 60 00 cmp %g1, 0
200a2c0: 12 80 00 12 bne 200a308 <IMFS_get_token+0x98>
200a2c4: 80 a0 e0 20 cmp %g3, 0x20
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
200a2c8: 82 06 40 03 add %i1, %g3, %g1
200a2cc: c4 48 7f ff ldsb [ %g1 + -1 ], %g2
200a2d0: 80 a0 a0 00 cmp %g2, 0
200a2d4: 32 80 00 02 bne,a 200a2dc <IMFS_get_token+0x6c> <== ALWAYS TAKEN
200a2d8: c0 2e 40 03 clrb [ %i1 + %g3 ]
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
200a2dc: c6 26 80 00 st %g3, [ %i2 ]
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
200a2e0: 90 10 00 19 mov %i1, %o0
200a2e4: 13 00 80 56 sethi %hi(0x2015800), %o1
200a2e8: b0 10 20 02 mov 2, %i0
200a2ec: 40 00 0f a6 call 200e184 <strcmp>
200a2f0: 92 12 60 60 or %o1, 0x60, %o1
200a2f4: 80 a2 20 00 cmp %o0, 0
200a2f8: 12 80 00 18 bne 200a358 <IMFS_get_token+0xe8> <== ALWAYS TAKEN
200a2fc: 90 10 00 19 mov %i1, %o0
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
}
return type;
}
200a300: 81 c7 e0 08 ret <== NOT EXECUTED
200a304: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) {
200a308: 14 bf ff f1 bg 200a2cc <IMFS_get_token+0x5c> <== NEVER TAKEN
200a30c: 82 06 40 03 add %i1, %g3, %g1
token[i] = c;
if ( i == IMFS_NAME_MAX )
200a310: 80 a0 e0 20 cmp %g3, 0x20
200a314: 12 bf ff e3 bne 200a2a0 <IMFS_get_token+0x30> <== ALWAYS TAKEN
200a318: c4 2e 40 03 stb %g2, [ %i1 + %g3 ]
200a31c: 81 c7 e0 08 ret <== NOT EXECUTED
200a320: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
200a324: c4 2e 40 00 stb %g2, [ %i1 ]
if ( token[i] != '\0' ) {
200a328: 80 a0 e0 00 cmp %g3, 0
200a32c: 82 10 20 01 mov 1, %g1
200a330: 02 80 00 06 be 200a348 <IMFS_get_token+0xd8> <== NEVER TAKEN
200a334: b0 10 20 01 mov 1, %i0
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
200a338: c2 26 80 00 st %g1, [ %i2 ]
200a33c: 81 c7 e0 08 ret
200a340: 81 e8 00 00 restore
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
200a344: c4 2e 40 00 stb %g2, [ %i1 ]
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
token[i] = '\0';
200a348: 82 10 20 00 clr %g1
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
200a34c: c2 26 80 00 st %g1, [ %i2 ]
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
token[i] = '\0';
200a350: 81 c7 e0 08 ret
200a354: 91 e8 20 00 restore %g0, 0, %o0
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
200a358: 13 00 80 56 sethi %hi(0x2015800), %o1
200a35c: 40 00 0f 8a call 200e184 <strcmp>
200a360: 92 12 63 98 or %o1, 0x398, %o1 ! 2015b98 <__func__.5181+0x18>
200a364: 80 a0 00 08 cmp %g0, %o0
200a368: 82 60 20 00 subx %g0, 0, %g1
200a36c: b0 08 60 02 and %g1, 2, %i0
type = IMFS_CURRENT_DIR;
}
return type;
}
200a370: 81 c7 e0 08 ret
200a374: 91 ee 20 01 restore %i0, 1, %o0
0200a378 <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
)
{
200a378: 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,
200a37c: 03 00 80 59 sethi %hi(0x2016400), %g1
200a380: c6 00 61 8c ld [ %g1 + 0x18c ], %g3 ! 201658c <imfs_rq_memfile_bytes_per_block>
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
200a384: 84 10 20 20 mov 0x20, %g2
200a388: 80 a0 e0 10 cmp %g3, 0x10
200a38c: 02 80 00 09 be 200a3b0 <IMFS_initialize_support+0x38> <== NEVER TAKEN
200a390: 82 10 20 00 clr %g1
200a394: 80 a0 c0 02 cmp %g3, %g2
200a398: 02 80 00 06 be 200a3b0 <IMFS_initialize_support+0x38>
200a39c: 82 00 60 01 inc %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16;
!is_valid && (bit_mask <= 512);
200a3a0: 80 a0 60 05 cmp %g1, 5
200a3a4: 12 bf ff fc bne 200a394 <IMFS_initialize_support+0x1c> <== ALWAYS TAKEN
200a3a8: 85 28 a0 01 sll %g2, 1, %g2
200a3ac: 86 10 20 80 mov 0x80, %g3 <== NOT EXECUTED
bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
200a3b0: 03 00 80 5c sethi %hi(0x2017000), %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(
200a3b4: 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)
200a3b8: c6 20 60 bc st %g3, [ %g1 + 0xbc ]
* 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(
200a3bc: 92 10 20 01 mov 1, %o1
200a3c0: 90 10 20 00 clr %o0
200a3c4: 15 00 80 55 sethi %hi(0x2015400), %o2
200a3c8: 17 00 00 10 sethi %hi(0x4000), %o3
200a3cc: 94 12 a3 d0 or %o2, 0x3d0, %o2
200a3d0: 40 00 08 5c call 200c540 <IMFS_create_node>
200a3d4: 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;
200a3d8: 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(
200a3dc: 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;
200a3e0: f2 26 20 20 st %i1, [ %i0 + 0x20 ]
"",
( S_IFDIR | 0755 ),
NULL
);
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
200a3e4: 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;
200a3e8: 13 00 80 57 sethi %hi(0x2015c00), %o1
200a3ec: 90 06 20 30 add %i0, 0x30, %o0
200a3f0: 40 00 0c 87 call 200d60c <memcpy>
200a3f4: 92 12 62 08 or %o1, 0x208, %o1
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
200a3f8: 90 10 20 01 mov 1, %o0
200a3fc: 40 00 00 f7 call 200a7d8 <calloc>
200a400: 92 10 20 0c mov 0xc, %o1
if ( !fs_info ){
200a404: 80 a2 20 00 cmp %o0, 0
200a408: 02 80 00 0a be 200a430 <IMFS_initialize_support+0xb8> <== NEVER TAKEN
200a40c: 82 10 20 01 mov 1, %g1
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
200a410: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
/*
* Set st_ino for the root to 1.
*/
fs_info->ino_count = 1;
200a414: 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;
200a418: 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;
200a41c: f6 22 20 08 st %i3, [ %o0 + 8 ]
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
200a420: 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;
200a424: 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;
}
200a428: 81 c7 e0 08 ret
200a42c: 91 e8 20 00 restore %g0, 0, %o0
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ){
free(temp_mt_entry->mt_fs_root.node_access);
200a430: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 <== NOT EXECUTED
200a434: 40 00 01 2f call 200a8f0 <free> <== NOT EXECUTED
200a438: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
200a43c: 40 00 0a 82 call 200ce44 <__errno> <== NOT EXECUTED
200a440: 01 00 00 00 nop <== NOT EXECUTED
200a444: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200a448: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200a44c: 81 c7 e0 08 ret <== NOT EXECUTED
200a450: 81 e8 00 00 restore <== NOT EXECUTED
0200a454 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
200a454: 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 );
200a458: 90 10 00 18 mov %i0, %o0
200a45c: 94 07 bf f4 add %fp, -12, %o2
200a460: b0 07 bf c0 add %fp, -64, %i0
200a464: 7f ff ff 83 call 200a270 <IMFS_get_token>
200a468: 92 10 00 18 mov %i0, %o1
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
200a46c: b3 2e 60 10 sll %i1, 0x10, %i1
200a470: 03 00 00 3c sethi %hi(0xf000), %g1
200a474: 97 36 60 10 srl %i1, 0x10, %o3
200a478: 05 00 00 10 sethi %hi(0x4000), %g2
200a47c: 86 0a c0 01 and %o3, %g1, %g3
200a480: 80 a0 c0 02 cmp %g3, %g2
200a484: 02 80 00 1f be 200a500 <IMFS_mknod+0xac>
200a488: 90 10 00 1c mov %i4, %o0
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
200a48c: 03 00 00 20 sethi %hi(0x8000), %g1
200a490: 80 a0 c0 01 cmp %g3, %g1
200a494: 02 80 00 12 be 200a4dc <IMFS_mknod+0x88> <== NEVER TAKEN
200a498: 92 10 20 05 mov 5, %o1
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
200a49c: 03 00 00 18 sethi %hi(0x6000), %g1
200a4a0: 80 a0 c0 01 cmp %g3, %g1
200a4a4: 02 80 00 0b be 200a4d0 <IMFS_mknod+0x7c> <== NEVER TAKEN
200a4a8: 03 00 00 08 sethi %hi(0x2000), %g1
200a4ac: 80 a0 c0 01 cmp %g3, %g1
200a4b0: 22 80 00 09 be,a 200a4d4 <IMFS_mknod+0x80> <== ALWAYS TAKEN
200a4b4: f4 27 bf e4 st %i2, [ %fp + -28 ]
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
200a4b8: 40 00 0a 63 call 200ce44 <__errno> <== NOT EXECUTED
200a4bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200a4c0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200a4c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200a4c8: 81 c7 e0 08 ret <== NOT EXECUTED
200a4cc: 81 e8 00 00 restore <== NOT EXECUTED
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
200a4d0: f4 27 bf e4 st %i2, [ %fp + -28 ] <== NOT EXECUTED
200a4d4: f6 27 bf e8 st %i3, [ %fp + -24 ]
200a4d8: 92 10 20 02 mov 2, %o1
/*
* Allocate and fill in an IMFS jnode
*/
new_node = IMFS_create_node(
200a4dc: 94 10 00 18 mov %i0, %o2
200a4e0: 98 07 bf e4 add %fp, -28, %o4
200a4e4: 40 00 08 17 call 200c540 <IMFS_create_node>
200a4e8: b0 10 20 00 clr %i0
new_name,
mode,
&info
);
if ( !new_node )
200a4ec: 80 a2 20 00 cmp %o0, 0
200a4f0: 02 80 00 06 be 200a508 <IMFS_mknod+0xb4> <== NEVER TAKEN
200a4f4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
}
200a4f8: 81 c7 e0 08 ret
200a4fc: 81 e8 00 00 restore
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
} else {
rtems_set_errno_and_return_minus_one( EINVAL );
200a500: 10 bf ff f7 b 200a4dc <IMFS_mknod+0x88>
200a504: 92 10 20 01 mov 1, %o1
mode,
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
200a508: 40 00 0a 4f call 200ce44 <__errno> <== NOT EXECUTED
200a50c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200a510: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
200a514: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return 0;
}
200a518: 81 c7 e0 08 ret <== NOT EXECUTED
200a51c: 81 e8 00 00 restore <== NOT EXECUTED
0200a52c <IMFS_rmnod>:
*/
int IMFS_rmnod(
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
200a52c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
200a530: 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 ) {
200a534: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
200a538: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200a53c: 22 80 00 06 be,a 200a554 <IMFS_rmnod+0x28> <== NOT EXECUTED
200a540: 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 );
200a544: 40 00 04 a3 call 200b7d0 <_Chain_Extract> <== NOT EXECUTED
200a548: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_chain_extract( (rtems_chain_node *) the_jnode );
the_jnode->Parent = NULL;
200a54c: 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--;
200a550: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
200a554: 92 10 20 00 clr %o1 <== NOT EXECUTED
/*
* Decrement the link counter and see if we can free the space.
*/
the_jnode->st_nlink--;
200a558: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
IMFS_update_ctime( the_jnode );
200a55c: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
200a560: 40 00 01 56 call 200aab8 <gettimeofday> <== NOT EXECUTED
200a564: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] <== NOT EXECUTED
200a568: 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) ) {
200a56c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
200a570: 40 00 01 8c call 200aba0 <rtems_libio_is_file_open> <== NOT EXECUTED
200a574: c2 24 20 44 st %g1, [ %l0 + 0x44 ] <== NOT EXECUTED
200a578: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200a57c: 12 80 00 12 bne 200a5c4 <IMFS_rmnod+0x98> <== NOT EXECUTED
200a580: 01 00 00 00 nop <== NOT EXECUTED
200a584: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
200a588: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200a58c: 12 80 00 0e bne 200a5c4 <IMFS_rmnod+0x98> <== NOT EXECUTED
200a590: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
/*
* Is rtems_filesystem_current this node?
*/
if ( rtems_filesystem_current.node_access == pathloc->node_access )
200a594: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 ! 2016aa4 <rtems_current_user_env><== NOT EXECUTED
200a598: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED
200a59c: c2 00 e0 04 ld [ %g3 + 4 ], %g1 <== NOT EXECUTED
200a5a0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
200a5a4: 22 80 00 02 be,a 200a5ac <IMFS_rmnod+0x80> <== NOT EXECUTED
200a5a8: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
200a5ac: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED
200a5b0: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
200a5b4: 22 80 00 06 be,a 200a5cc <IMFS_rmnod+0xa0> <== NOT EXECUTED
200a5b8: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 <== NOT EXECUTED
if ( the_jnode->info.sym_link.name )
free( (void*) the_jnode->info.sym_link.name );
}
free( the_jnode );
200a5bc: 40 00 00 cd call 200a8f0 <free> <== NOT EXECUTED
200a5c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
}
return 0;
}
200a5c4: 81 c7 e0 08 ret <== NOT EXECUTED
200a5c8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
/*
* Free memory associated with a memory file.
*/
if ( the_jnode->type == IMFS_SYM_LINK ) {
if ( the_jnode->info.sym_link.name )
200a5cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200a5d0: 02 bf ff fb be 200a5bc <IMFS_rmnod+0x90> <== NOT EXECUTED
200a5d4: 01 00 00 00 nop <== NOT EXECUTED
free( (void*) the_jnode->info.sym_link.name );
200a5d8: 40 00 00 c6 call 200a8f0 <free> <== NOT EXECUTED
200a5dc: 01 00 00 00 nop <== NOT EXECUTED
200a5e0: 30 bf ff f7 b,a 200a5bc <IMFS_rmnod+0x90> <== NOT EXECUTED
0200a5e4 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
200a5e4: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
200a5e8: f0 06 00 00 ld [ %i0 ], %i0
switch ( the_jnode->type ) {
200a5ec: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a5f0: 80 a0 60 04 cmp %g1, 4
200a5f4: 22 80 00 11 be,a 200a638 <IMFS_stat+0x54> <== NEVER TAKEN
200a5f8: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
200a5fc: 14 80 00 0b bg 200a628 <IMFS_stat+0x44> <== NEVER TAKEN
200a600: 80 a0 60 06 cmp %g1, 6
200a604: 80 a0 60 02 cmp %g1, 2
200a608: 22 80 00 21 be,a 200a68c <IMFS_stat+0xa8> <== ALWAYS TAKEN
200a60c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
200a610: 40 00 0a 0d call 200ce44 <__errno> <== NOT EXECUTED
200a614: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200a618: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
200a61c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200a620: 81 c7 e0 08 ret <== NOT EXECUTED
200a624: 81 e8 00 00 restore <== NOT EXECUTED
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
200a628: 14 bf ff fa bg 200a610 <IMFS_stat+0x2c> <== NOT EXECUTED
200a62c: 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;
200a630: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== NOT EXECUTED
200a634: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
break;
}
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
200a638: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
200a63c: c4 16 20 2e lduh [ %i0 + 0x2e ], %g2
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
200a640: c2 26 60 08 st %g1, [ %i1 + 8 ]
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
200a644: c4 36 60 0c sth %g2, [ %i1 + 0xc ]
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
200a648: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
200a64c: c4 16 20 30 lduh [ %i0 + 0x30 ], %g2
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;
200a650: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
rtems_set_errno_and_return_minus_one( ENOTSUP );
break;
}
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
200a654: c4 36 60 0e sth %g2, [ %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;
buf->st_mtime = the_jnode->stat_mtime;
200a658: c2 06 20 40 ld [ %i0 + 0x40 ], %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;
200a65c: c4 16 20 38 lduh [ %i0 + 0x38 ], %g2
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
200a660: c2 26 60 2c st %g1, [ %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;
200a664: c4 36 60 10 sth %g2, [ %i1 + 0x10 ]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
200a668: c8 06 20 44 ld [ %i0 + 0x44 ], %g4
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;
200a66c: c6 16 20 3a lduh [ %i0 + 0x3a ], %g3
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
200a670: 03 00 80 59 sethi %hi(0x2016400), %g1
200a674: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 201658c <imfs_rq_memfile_bytes_per_block>
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;
200a678: c6 36 60 12 sth %g3, [ %i1 + 0x12 ]
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
200a67c: c4 26 60 3c st %g2, [ %i1 + 0x3c ]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
200a680: c8 26 60 34 st %g4, [ %i1 + 0x34 ]
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
return 0;
}
200a684: 81 c7 e0 08 ret
200a688: 91 e8 20 00 restore %g0, 0, %o0
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
200a68c: 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 );
200a690: c2 26 60 04 st %g1, [ %i1 + 4 ]
200a694: 10 bf ff e9 b 200a638 <IMFS_stat+0x54>
200a698: c4 26 40 00 st %g2, [ %i1 ]
020022a4 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
void *start,
size_t length,
size_t sbrk_amount
)
{
20022a4: 9d e3 bf 98 save %sp, -104, %sp
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers )
20022a8: 03 00 80 5b sethi %hi(0x2016c00), %g1
20022ac: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 2016fa4 <rtems_malloc_statistics_helpers>
20022b0: 80 a0 60 00 cmp %g1, 0
20022b4: 02 80 00 05 be 20022c8 <RTEMS_Malloc_Initialize+0x24> <== ALWAYS TAKEN
20022b8: 01 00 00 00 nop
(*rtems_malloc_statistics_helpers->initialize)();
20022bc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
20022c0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20022c4: 01 00 00 00 nop <== NOT EXECUTED
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
20022c8: 40 00 22 e6 call 200ae60 <malloc_deferred_frees_initialize>
20022cc: a0 10 00 18 mov %i0, %l0
starting_address = start;
/*
* Initialize the optional sbrk support for extending the heap
*/
if (rtems_malloc_sbrk_helpers) {
20022d0: 03 00 80 5b sethi %hi(0x2016c00), %g1
20022d4: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 2016fa8 <rtems_malloc_sbrk_helpers>
20022d8: 80 a0 60 00 cmp %g1, 0
20022dc: 02 80 00 06 be 20022f4 <RTEMS_Malloc_Initialize+0x50> <== ALWAYS TAKEN
20022e0: 90 10 00 18 mov %i0, %o0
starting_address = (*rtems_malloc_sbrk_helpers->initialize)(
20022e4: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
20022e8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20022ec: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20022f0: 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() )
20022f4: 03 00 80 5d sethi %hi(0x2017400), %g1
20022f8: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201747c <_Configuration_Table>
20022fc: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
2002300: 80 a0 e0 00 cmp %g3, 0
2002304: 12 80 00 10 bne 2002344 <RTEMS_Malloc_Initialize+0xa0> <== NEVER TAKEN
2002308: 90 10 00 10 mov %l0, %o0
void *starting_address,
size_t size,
uint32_t page_size
)
{
return _Heap_Initialize( the_heap, starting_address, size, page_size );
200230c: 92 10 00 10 mov %l0, %o1
2002310: 11 00 80 5c sethi %hi(0x2017000), %o0
2002314: 94 10 00 19 mov %i1, %o2
2002318: 90 12 22 18 or %o0, 0x218, %o0
200231c: 40 00 11 6f call 20068d8 <_Heap_Initialize>
2002320: 96 10 20 08 mov 8, %o3
&RTEMS_Malloc_Heap,
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
2002324: 80 a2 20 00 cmp %o0, 0
2002328: 02 80 00 0c be 2002358 <RTEMS_Malloc_Initialize+0xb4> <== NEVER TAKEN
200232c: 05 00 80 5c sethi %hi(0x2017000), %g2
rtems_print_buffer( (start + length) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
MSBUMP(space_available, length);
2002330: c2 00 a2 70 ld [ %g2 + 0x270 ], %g1 ! 2017270 <rtems_malloc_statistics>
2002334: 82 06 40 01 add %i1, %g1, %g1
2002338: c2 20 a2 70 st %g1, [ %g2 + 0x270 ]
}
200233c: 81 c7 e0 08 ret
2002340: 81 e8 00 00 restore
* 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() )
memset( starting_address, 0, length );
2002344: 92 10 20 00 clr %o1 <== NOT EXECUTED
2002348: 40 00 2c ea call 200d6f0 <memset> <== NOT EXECUTED
200234c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2002350: 10 bf ff f0 b 2002310 <RTEMS_Malloc_Initialize+0x6c> <== NOT EXECUTED
2002354: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
starting_address,
length,
CPU_HEAP_ALIGNMENT
);
if ( !status )
rtems_fatal_error_occurred( status );
2002358: 40 00 0f 03 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
02002768 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
2002768: 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 )
200276c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2002770: 02 80 00 39 be 2002854 <Stack_check_Dump_threads_usage+0xec><== NOT EXECUTED
2002774: 2b 00 80 6b sethi %hi(0x201ac00), %l5 <== NOT EXECUTED
return;
if ( !print_handler )
2002778: e8 05 63 0c ld [ %l5 + 0x30c ], %l4 ! 201af0c <print_handler><== NOT EXECUTED
200277c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
2002780: 02 80 00 35 be 2002854 <Stack_check_Dump_threads_usage+0xec><== NOT EXECUTED
2002784: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
2002788: 02 80 00 3b be 2002874 <Stack_check_Dump_threads_usage+0x10c><== NOT EXECUTED
200278c: a4 06 20 c4 add %i0, 0xc4, %l2 <== NOT EXECUTED
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
2002790: ec 06 21 50 ld [ %i0 + 0x150 ], %l6 <== NOT EXECUTED
}
low = Stack_check_usable_stack_start(stack);
2002794: e0 04 a0 04 ld [ %l2 + 4 ], %l0 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
2002798: 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);
200279c: a0 04 20 10 add %l0, 0x10, %l0 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
20027a0: a6 00 7f f0 add %g1, -16, %l3 <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
20027a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20027a8: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
20027ac: 7f ff ff d6 call 2002704 <Stack_check_find_high_water_mark><== NOT EXECUTED
20027b0: a0 04 00 13 add %l0, %l3, %l0 <== NOT EXECUTED
if ( high_water_mark )
20027b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20027b8: 02 80 00 40 be 20028b8 <Stack_check_Dump_threads_usage+0x150><== NOT EXECUTED
20027bc: ae 24 00 08 sub %l0, %o0, %l7 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
if ( the_thread ) {
20027c0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
20027c4: 02 80 00 35 be 2002898 <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
20027c8: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED
(*print_handler)(
20027cc: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
20027d0: e2 00 63 08 ld [ %g1 + 0x308 ], %l1 <== NOT EXECUTED
20027d4: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
20027d8: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
20027dc: b0 10 63 08 or %g1, 0x308, %i0 <== NOT EXECUTED
20027e0: 40 00 10 2b call 200688c <rtems_object_get_name> <== NOT EXECUTED
20027e4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20027e8: 13 00 80 61 sethi %hi(0x2018400), %o1 <== NOT EXECUTED
20027ec: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20027f0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
20027f4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20027f8: 9f c5 00 00 call %l4 <== NOT EXECUTED
20027fc: 92 12 63 e8 or %o1, 0x3e8, %o1 <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
2002800: d6 04 80 00 ld [ %l2 ], %o3 <== NOT EXECUTED
2002804: d4 04 a0 04 ld [ %l2 + 4 ], %o2 <== NOT EXECUTED
2002808: c4 05 63 0c ld [ %l5 + 0x30c ], %g2 <== NOT EXECUTED
200280c: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
2002810: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
2002814: 98 10 00 16 mov %l6, %o4 <== NOT EXECUTED
2002818: 96 02 80 0b add %o2, %o3, %o3 <== NOT EXECUTED
200281c: 9a 10 00 13 mov %l3, %o5 <== NOT EXECUTED
2002820: 13 00 80 62 sethi %hi(0x2018800), %o1 <== NOT EXECUTED
2002824: 9f c0 80 00 call %g2 <== NOT EXECUTED
2002828: 92 12 60 08 or %o1, 8, %o1 ! 2018808 <pollCallbacks.4767+0x330><== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
200282c: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED
2002830: c4 00 63 04 ld [ %g1 + 0x304 ], %g2 ! 201af04 <Stack_check_Initialized><== NOT EXECUTED
2002834: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2002838: 02 80 00 09 be 200285c <Stack_check_Dump_threads_usage+0xf4><== NOT EXECUTED
200283c: c2 05 63 0c ld [ %l5 + 0x30c ], %g1 <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
2002840: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
2002844: 13 00 80 62 sethi %hi(0x2018800), %o1 <== NOT EXECUTED
2002848: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
200284c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002850: 92 12 60 38 or %o1, 0x38, %o1 <== NOT EXECUTED
2002854: 81 c7 e0 08 ret <== NOT EXECUTED
2002858: 81 e8 00 00 restore <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
200285c: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
2002860: 13 00 80 62 sethi %hi(0x2018800), %o1 <== NOT EXECUTED
2002864: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002868: 92 12 60 28 or %o1, 0x28, %o1 ! 2018828 <pollCallbacks.4767+0x350><== NOT EXECUTED
200286c: 81 c7 e0 08 ret <== NOT EXECUTED
2002870: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
if (Stack_check_Interrupt_stack.area) {
2002874: 03 00 80 6c sethi %hi(0x201b000), %g1 <== NOT EXECUTED
2002878: 82 10 61 98 or %g1, 0x198, %g1 ! 201b198 <Stack_check_Interrupt_stack><== NOT EXECUTED
200287c: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
2002880: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2002884: 02 bf ff f4 be 2002854 <Stack_check_Dump_threads_usage+0xec><== NOT EXECUTED
2002888: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
current = 0;
}
else
return;
200288c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2002890: 10 bf ff c1 b 2002794 <Stack_check_Dump_threads_usage+0x2c><== NOT EXECUTED
2002894: ac 10 20 00 clr %l6 <== 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 );
2002898: d0 00 63 08 ld [ %g1 + 0x308 ], %o0 <== NOT EXECUTED
200289c: 13 00 80 61 sethi %hi(0x2018400), %o1 <== NOT EXECUTED
20028a0: b0 10 63 08 or %g1, 0x308, %i0 <== NOT EXECUTED
20028a4: 92 12 63 f8 or %o1, 0x3f8, %o1 <== NOT EXECUTED
20028a8: 9f c5 00 00 call %l4 <== NOT EXECUTED
20028ac: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
}
(*print_handler)(
20028b0: 10 bf ff d5 b 2002804 <Stack_check_Dump_threads_usage+0x9c><== NOT EXECUTED
20028b4: d6 04 80 00 ld [ %l2 ], %o3 <== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
20028b8: 10 bf ff c2 b 20027c0 <Stack_check_Dump_threads_usage+0x58><== NOT EXECUTED
20028bc: ae 10 20 00 clr %l7 <== NOT EXECUTED
02002a94 <Stack_check_Initialize>:
/*
* Stack_check_Initialize
*/
void Stack_check_Initialize( void )
{
2002a94: 9d e3 bf 98 save %sp, -104, %sp
uint32_t *p;
if (Stack_check_Initialized)
2002a98: 21 00 80 6b sethi %hi(0x201ac00), %l0
2002a9c: c2 04 23 04 ld [ %l0 + 0x304 ], %g1 ! 201af04 <Stack_check_Initialized>
2002aa0: 80 a0 60 00 cmp %g1, 0
2002aa4: 12 80 00 22 bne 2002b2c <Stack_check_Initialize+0x98>
2002aa8: 03 00 80 6c sethi %hi(0x201b000), %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) {
2002aac: c8 00 63 90 ld [ %g1 + 0x390 ], %g4 ! 201b390 <_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 */
2002ab0: 03 3f bb 7c sethi %hi(0xfeedf000), %g1
2002ab4: 82 10 60 0d or %g1, 0xd, %g1 ! feedf00d <RAM_END+0xfcadf00d>
2002ab8: 07 00 80 6c sethi %hi(0x201b000), %g3
2002abc: c2 20 e1 88 st %g1, [ %g3 + 0x188 ] ! 201b188 <Stack_check_Pattern>
p[1] = 0x0BAD0D06;
2002ac0: 03 02 eb 43 sethi %hi(0xbad0c00), %g1
2002ac4: 82 10 61 06 or %g1, 0x106, %g1 ! bad0d06 <RAM_END+0x96d0d06>
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
2002ac8: 86 10 e1 88 or %g3, 0x188, %g3
p[1] = 0x0BAD0D06;
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
2002acc: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
for ( p = Stack_check_Pattern.pattern;
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
p[1] = 0x0BAD0D06;
2002ad0: c2 20 e0 04 st %g1, [ %g3 + 4 ]
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
2002ad4: 84 10 a0 0d or %g2, 0xd, %g2
p[3] = 0x600D0D06;
2002ad8: 03 18 03 43 sethi %hi(0x600d0c00), %g1
p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS];
p += 4
) {
p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */
p[1] = 0x0BAD0D06;
p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */
2002adc: c4 20 e0 08 st %g2, [ %g3 + 8 ]
p[3] = 0x600D0D06;
2002ae0: 82 10 61 06 or %g1, 0x106, %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) {
2002ae4: 80 a1 20 00 cmp %g4, 0
2002ae8: 02 80 00 0f be 2002b24 <Stack_check_Initialize+0x90> <== NEVER TAKEN
2002aec: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
2002af0: 03 00 80 6c sethi %hi(0x201b000), %g1
2002af4: c4 00 62 dc ld [ %g1 + 0x2dc ], %g2 ! 201b2dc <_CPU_Interrupt_stack_high>
2002af8: 80 a0 a0 00 cmp %g2, 0
2002afc: 02 80 00 0a be 2002b24 <Stack_check_Initialize+0x90> <== NEVER TAKEN
2002b00: 84 20 80 04 sub %g2, %g4, %g2
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2002b04: 03 00 80 6c sethi %hi(0x201b000), %g1
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2002b08: c4 20 61 98 st %g2, [ %g1 + 0x198 ] ! 201b198 <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;
2002b0c: 82 10 61 98 or %g1, 0x198, %g1
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
2002b10: 90 10 00 04 mov %g4, %o0
2002b14: 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;
2002b18: c8 20 60 04 st %g4, [ %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);
2002b1c: 40 00 30 fb call 200ef08 <memset>
2002b20: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
2002b24: 82 10 20 01 mov 1, %g1
2002b28: c2 24 23 04 st %g1, [ %l0 + 0x304 ]
2002b2c: 81 c7 e0 08 ret
2002b30: 81 e8 00 00 restore
02002704 <Stack_check_find_high_water_mark>:
*/
void *Stack_check_find_high_water_mark(
const void *s,
size_t n
)
{
2002704: 82 10 00 08 mov %o0, %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++)
2002708: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
200270c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
2002710: 86 02 00 09 add %o0, %o1, %g3 <== NOT EXECUTED
2002714: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED
2002718: 3a 80 00 12 bcc,a 2002760 <Stack_check_find_high_water_mark+0x5c><== NOT EXECUTED
200271c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (*base != U32_PATTERN)
2002720: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED
2002724: 03 29 69 69 sethi %hi(0xa5a5a400), %g1 <== NOT EXECUTED
2002728: 82 10 61 a5 or %g1, 0x1a5, %g1 ! a5a5a5a5 <RAM_END+0xa365a5a5><== NOT EXECUTED
200272c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2002730: 22 80 00 07 be,a 200274c <Stack_check_find_high_water_mark+0x48><== NOT EXECUTED
2002734: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED
2002738: 30 80 00 0a b,a 2002760 <Stack_check_find_high_water_mark+0x5c><== NOT EXECUTED
200273c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2002740: 12 80 00 08 bne 2002760 <Stack_check_find_high_water_mark+0x5c><== NOT EXECUTED
2002744: 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++)
2002748: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED
200274c: 80 a0 c0 08 cmp %g3, %o0 <== NOT EXECUTED
2002750: 38 bf ff fb bgu,a 200273c <Stack_check_find_high_water_mark+0x38><== NOT EXECUTED
2002754: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
2002758: 81 c3 e0 08 retl <== NOT EXECUTED
200275c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2002760: 81 c3 e0 08 retl <== NOT EXECUTED
02002934 <Stack_check_report_blown_task>:
*/
void Stack_check_report_blown_task(
Thread_Control *running,
bool pattern_ok
)
{
2002934: 9d e3 bf 98 save %sp, -104, %sp
Stack_Control *stack = &running->Start.Initial_stack;
printk(
2002938: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
200293c: 92 10 00 18 mov %i0, %o1
2002940: 11 00 80 62 sethi %hi(0x2018800), %o0
2002944: 40 00 05 ba call 200402c <printk>
2002948: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20188a8 <pollCallbacks.4767+0x3d0>
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
printk(
200294c: d4 06 20 c4 ld [ %i0 + 0xc4 ], %o2
2002950: d2 06 20 c8 ld [ %i0 + 0xc8 ], %o1
2002954: 96 10 00 0a mov %o2, %o3
2002958: 11 00 80 62 sethi %hi(0x2018800), %o0
200295c: 94 02 bf ff add %o2, -1, %o2
2002960: 90 12 20 e8 or %o0, 0xe8, %o0
2002964: 40 00 05 b2 call 200402c <printk>
2002968: 94 02 40 0a add %o1, %o2, %o2
stack->area,
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
200296c: 80 8e 60 ff btst 0xff, %i1
2002970: 22 80 00 04 be,a 2002980 <Stack_check_report_blown_task+0x4c><== ALWAYS TAKEN
2002974: d2 06 20 c8 ld [ %i0 + 0xc8 ], %o1
" 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 );
2002978: 40 00 12 3e call 2007270 <rtems_fatal_error_occurred>
200297c: 90 10 20 81 mov 0x81, %o0
stack->area + stack->size - 1,
stack->size
);
if ( !pattern_ok ) {
printk(
2002980: 11 00 80 62 sethi %hi(0x2018800), %o0
2002984: 92 02 60 08 add %o1, 8, %o1
2002988: 90 12 21 18 or %o0, 0x118, %o0
200298c: 40 00 05 a8 call 200402c <printk>
2002990: 94 10 20 10 mov 0x10, %o2
2002994: 30 bf ff f9 b,a 2002978 <Stack_check_report_blown_task+0x44>
02006170 <_API_extensions_Run_postdriver>:
*
* _API_extensions_Run_postdriver
*/
void _API_extensions_Run_postdriver( void )
{
2006170: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
2006174: 03 00 80 5d sethi %hi(0x2017400), %g1
2006178: e0 00 62 24 ld [ %g1 + 0x224 ], %l0 ! 2017624 <_API_extensions_List>
200617c: 82 10 62 24 or %g1, 0x224, %g1
2006180: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
2006184: 80 a4 00 11 cmp %l0, %l1
2006188: 02 80 00 0c be 20061b8 <_API_extensions_Run_postdriver+0x48><== NEVER TAKEN
200618c: 01 00 00 00 nop
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postdriver_hook )
2006190: c2 04 20 0c ld [ %l0 + 0xc ], %g1
2006194: 80 a0 60 00 cmp %g1, 0
2006198: 22 80 00 05 be,a 20061ac <_API_extensions_Run_postdriver+0x3c><== NEVER TAKEN
200619c: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
(*the_extension->postdriver_hook)();
20061a0: 9f c0 40 00 call %g1
20061a4: 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 ) {
20061a8: 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 ) ;
20061ac: 80 a4 00 11 cmp %l0, %l1
20061b0: 32 bf ff f9 bne,a 2006194 <_API_extensions_Run_postdriver+0x24><== NEVER TAKEN
20061b4: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED
20061b8: 81 c7 e0 08 ret
20061bc: 81 e8 00 00 restore
020061c0 <_API_extensions_Run_postswitch>:
*
* _API_extensions_Run_postswitch
*/
void _API_extensions_Run_postswitch( void )
{
20061c0: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
20061c4: 03 00 80 5d sethi %hi(0x2017400), %g1
20061c8: e0 00 62 24 ld [ %g1 + 0x224 ], %l0 ! 2017624 <_API_extensions_List>
20061cc: 82 10 62 24 or %g1, 0x224, %g1
20061d0: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
20061d4: 80 a4 00 11 cmp %l0, %l1
20061d8: 02 80 00 0d be 200620c <_API_extensions_Run_postswitch+0x4c><== NEVER TAKEN
20061dc: 03 00 80 5d sethi %hi(0x2017400), %g1
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->postswitch_hook )
(*the_extension->postswitch_hook)( _Thread_Executing );
20061e0: a4 10 60 a4 or %g1, 0xa4, %l2 ! 20174a4 <_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 )
20061e4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
20061e8: 80 a0 60 00 cmp %g1, 0
20061ec: 22 80 00 05 be,a 2006200 <_API_extensions_Run_postswitch+0x40><== NEVER TAKEN
20061f0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
(*the_extension->postswitch_hook)( _Thread_Executing );
20061f4: 9f c0 40 00 call %g1
20061f8: d0 04 80 00 ld [ %l2 ], %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 ) {
20061fc: 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 ) ;
2006200: 80 a4 00 11 cmp %l0, %l1
2006204: 32 bf ff f9 bne,a 20061e8 <_API_extensions_Run_postswitch+0x28><== NEVER TAKEN
2006208: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED
200620c: 81 c7 e0 08 ret
2006210: 81 e8 00 00 restore
02006120 <_API_extensions_Run_predriver>:
*
* _API_extensions_Run_predriver
*/
void _API_extensions_Run_predriver( void )
{
2006120: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
API_extensions_Control *the_extension;
for ( the_node = _API_extensions_List.first ;
2006124: 03 00 80 5d sethi %hi(0x2017400), %g1
2006128: e0 00 62 24 ld [ %g1 + 0x224 ], %l0 ! 2017624 <_API_extensions_List>
200612c: 82 10 62 24 or %g1, 0x224, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
2006130: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_API_extensions_List, the_node ) ;
2006134: 80 a4 00 11 cmp %l0, %l1
2006138: 02 80 00 0c be 2006168 <_API_extensions_Run_predriver+0x48><== NEVER TAKEN
200613c: 01 00 00 00 nop
the_node = the_node->next ) {
the_extension = (API_extensions_Control *) the_node;
if ( the_extension->predriver_hook )
2006140: c2 04 20 08 ld [ %l0 + 8 ], %g1
2006144: 80 a0 60 00 cmp %g1, 0
2006148: 22 80 00 05 be,a 200615c <_API_extensions_Run_predriver+0x3c><== ALWAYS TAKEN
200614c: e0 04 00 00 ld [ %l0 ], %l0
(*the_extension->predriver_hook)();
2006150: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006154: 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 ) {
2006158: 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 ) ;
200615c: 80 a4 00 11 cmp %l0, %l1
2006160: 32 bf ff f9 bne,a 2006144 <_API_extensions_Run_predriver+0x24><== NEVER TAKEN
2006164: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
2006168: 81 c7 e0 08 ret
200616c: 81 e8 00 00 restore
02007414 <_CORE_barrier_Wait>:
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
2007414: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
2007418: 03 00 80 6c sethi %hi(0x201b000), %g1
200741c: e2 00 61 74 ld [ %g1 + 0x174 ], %l1 ! 201b174 <_Thread_Executing>
Objects_Id id,
bool wait,
Watchdog_Interval timeout,
CORE_barrier_API_mp_support_callout api_barrier_mp_support
)
{
2007420: b4 10 00 1c mov %i4, %i2
Thread_Control *executing;
ISR_Level level;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
2007424: c0 24 60 34 clr [ %l1 + 0x34 ]
_ISR_Disable( level );
2007428: 7f ff ed 43 call 2002934 <sparc_disable_interrupts>
200742c: 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
)
{
2007430: 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 );
2007434: 86 10 00 08 mov %o0, %g3
the_barrier->number_of_waiting_threads++;
2007438: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
if ( the_barrier->number_of_waiting_threads ==
200743c: 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++;
2007440: 82 00 60 01 inc %g1
if ( the_barrier->number_of_waiting_threads ==
2007444: 80 a0 40 02 cmp %g1, %g2
2007448: 12 80 00 06 bne 2007460 <_CORE_barrier_Wait+0x4c>
200744c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
2007450: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
2007454: 80 a0 60 00 cmp %g1, 0
2007458: 02 80 00 0d be 200748c <_CORE_barrier_Wait+0x78> <== ALWAYS TAKEN
200745c: 82 10 20 01 mov 1, %g1
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;
2007460: 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;
2007464: 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;
2007468: e0 24 60 44 st %l0, [ %l1 + 0x44 ]
200746c: c2 24 20 30 st %g1, [ %l0 + 0x30 ]
executing->Wait.id = id;
_ISR_Enable( level );
2007470: 90 10 00 03 mov %g3, %o0
2007474: 7f ff ed 34 call 2002944 <sparc_enable_interrupts>
2007478: 35 00 80 25 sethi %hi(0x2009400), %i2
_Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
200747c: b0 10 00 10 mov %l0, %i0
2007480: b2 10 00 1b mov %i3, %i1
2007484: 40 00 07 6f call 2009240 <_Thread_queue_Enqueue_with_handler>
2007488: 95 ee a2 98 restore %i2, 0x298, %o2
_ISR_Disable( level );
the_barrier->number_of_waiting_threads++;
if ( the_barrier->number_of_waiting_threads ==
the_barrier->Attributes.maximum_count) {
if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
200748c: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
_ISR_Enable( level );
2007490: 7f ff ed 2d call 2002944 <sparc_enable_interrupts>
2007494: 01 00 00 00 nop
_CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
2007498: 7f ff ff d4 call 20073e8 <_CORE_barrier_Release>
200749c: 81 e8 00 00 restore
0201270c <_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
)
{
201270c: 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 ) {
2012710: 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
)
{
2012714: 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 ) {
2012718: 80 a0 40 1a cmp %g1, %i2
201271c: 0a 80 00 17 bcs 2012778 <_CORE_message_queue_Broadcast+0x6c><== NEVER TAKEN
2012720: 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 ) {
2012724: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1
2012728: 80 a0 60 00 cmp %g1, 0
201272c: 02 80 00 0a be 2012754 <_CORE_message_queue_Broadcast+0x48><== ALWAYS TAKEN
2012730: a2 10 20 00 clr %l1
*count = 0;
2012734: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
2012738: 81 c7 e0 08 ret <== NOT EXECUTED
201273c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
2012740: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
2012744: 40 00 20 e4 call 201aad4 <memcpy>
2012748: a2 04 60 01 inc %l1
buffer,
waitp->return_argument_second.mutable_object,
size
);
*(size_t *) the_thread->Wait.return_argument = size;
201274c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
2012750: 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))) {
2012754: 40 00 0a 40 call 2015054 <_Thread_queue_Dequeue>
2012758: 90 10 00 12 mov %l2, %o0
201275c: 92 10 00 19 mov %i1, %o1
2012760: a0 10 00 08 mov %o0, %l0
2012764: 80 a2 20 00 cmp %o0, 0
2012768: 12 bf ff f6 bne 2012740 <_CORE_message_queue_Broadcast+0x34>
201276c: 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;
2012770: e2 27 40 00 st %l1, [ %i5 ]
2012774: b0 10 20 00 clr %i0
return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
2012778: 81 c7 e0 08 ret
201277c: 81 e8 00 00 restore
0201283c <_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
)
{
201283c: 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;
2012840: 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;
2012844: 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;
2012848: 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;
201284c: c0 26 20 60 clr [ %i0 + 0x60 ]
the_message_queue->notify_argument = the_argument;
2012850: 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)) {
2012854: 80 8e e0 03 btst 3, %i3
2012858: 02 80 00 09 be 201287c <_CORE_message_queue_Initialize+0x40>
201285c: a0 10 00 1b mov %i3, %l0
allocated_message_size += sizeof(uint32_t);
2012860: 82 06 e0 04 add %i3, 4, %g1
allocated_message_size &= ~(sizeof(uint32_t) - 1);
2012864: a0 08 7f fc and %g1, -4, %l0
}
if (allocated_message_size < maximum_message_size)
2012868: 80 a6 c0 10 cmp %i3, %l0
201286c: 08 80 00 05 bleu 2012880 <_CORE_message_queue_Initialize+0x44><== ALWAYS TAKEN
2012870: b6 04 20 14 add %l0, 0x14, %i3
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
2012874: 81 c7 e0 08 ret
2012878: 91 e8 20 00 restore %g0, 0, %o0
/*
* 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 *
201287c: b6 04 20 14 add %l0, 0x14, %i3
2012880: 92 10 00 1a mov %i2, %o1
2012884: 40 00 3f fe call 202287c <.umul>
2012888: 90 10 00 1b mov %i3, %o0
(allocated_message_size + sizeof(CORE_message_queue_Buffer_control));
if (message_buffering_required < allocated_message_size)
201288c: 80 a2 00 10 cmp %o0, %l0
2012890: 0a bf ff f9 bcs 2012874 <_CORE_message_queue_Initialize+0x38><== NEVER TAKEN
2012894: 01 00 00 00 nop
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
2012898: 40 00 0f e7 call 2016834 <_Workspace_Allocate>
201289c: 01 00 00 00 nop
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
20128a0: 80 a2 20 00 cmp %o0, 0
20128a4: 02 bf ff f4 be 2012874 <_CORE_message_queue_Initialize+0x38>
20128a8: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
20128ac: 92 10 00 08 mov %o0, %o1
20128b0: 94 10 00 1a mov %i2, %o2
20128b4: 90 06 20 68 add %i0, 0x68, %o0
20128b8: 7f ff ff 7d call 20126ac <_Chain_Initialize>
20128bc: 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(
20128c0: c2 06 40 00 ld [ %i1 ], %g1
20128c4: 84 06 20 50 add %i0, 0x50, %g2
20128c8: 82 18 60 01 xor %g1, 1, %g1
20128cc: 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);
20128d0: 82 06 20 54 add %i0, 0x54, %g1
the_chain->permanent_null = NULL;
20128d4: c0 26 20 54 clr [ %i0 + 0x54 ]
20128d8: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
20128dc: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
20128e0: c4 26 20 58 st %g2, [ %i0 + 0x58 ]
20128e4: 92 60 3f ff subx %g0, -1, %o1
20128e8: 94 10 20 80 mov 0x80, %o2
20128ec: 96 10 20 06 mov 6, %o3
20128f0: 40 00 0b 14 call 2015540 <_Thread_queue_Initialize>
20128f4: b0 10 20 01 mov 1, %i0
20128f8: 81 c7 e0 08 ret
20128fc: 81 e8 00 00 restore
02018f54 <_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
)
{
2018f54: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
bool notify = false;
the_message->priority = submit_type;
switch ( submit_type ) {
2018f58: 03 20 00 00 sethi %hi(0x80000000), %g1
2018f5c: 80 a6 80 01 cmp %i2, %g1
2018f60: 02 80 00 41 be 2019064 <_CORE_message_queue_Insert_message+0x110>
2018f64: f4 26 60 08 st %i2, [ %i1 + 8 ]
2018f68: 82 00 7c 00 add %g1, -1024, %g1
2018f6c: 82 10 63 ff or %g1, 0x3ff, %g1
2018f70: 80 a6 80 01 cmp %i2, %g1
2018f74: 02 80 00 2a be 201901c <_CORE_message_queue_Insert_message+0xc8><== ALWAYS TAKEN
2018f78: 84 06 20 54 add %i0, 0x54, %g2
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;
2018f7c: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 <== NOT EXECUTED
while ( !_Chain_Is_tail( the_header, the_node ) ) {
2018f80: 80 a0 80 10 cmp %g2, %l0 <== NOT EXECUTED
2018f84: 32 80 00 22 bne,a 201900c <_CORE_message_queue_Insert_message+0xb8><== NOT EXECUTED
2018f88: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
2018f8c: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED
continue;
}
break;
}
_ISR_Disable( level );
2018f90: 7f ff c8 b9 call 200b274 <sparc_disable_interrupts> <== NOT EXECUTED
2018f94: 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 );
2018f98: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
}
break;
}
_ISR_Disable( level );
if ( the_message_queue->number_of_pending_messages++ == 0 )
2018f9c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 <== NOT EXECUTED
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2018fa0: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2018fa4: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
after_node->next = the_node;
2018fa8: f2 20 40 00 st %i1, [ %g1 ] <== NOT EXECUTED
2018fac: 80 a0 00 02 cmp %g0, %g2 <== NOT EXECUTED
the_node->next = before_node;
before_node->previous = the_node;
2018fb0: f2 20 e0 04 st %i1, [ %g3 + 4 ] <== NOT EXECUTED
2018fb4: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
2018fb8: 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;
2018fbc: c6 26 40 00 st %g3, [ %i1 ] <== NOT EXECUTED
2018fc0: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
2018fc4: c4 26 20 48 st %g2, [ %i0 + 0x48 ] <== NOT EXECUTED
notify = true;
_Chain_Insert_unprotected( the_node->previous, &the_message->Node );
_ISR_Enable( level );
2018fc8: 7f ff c8 af call 200b284 <sparc_enable_interrupts> <== NOT EXECUTED
2018fcc: 01 00 00 00 nop <== NOT EXECUTED
* 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 )
2018fd0: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
2018fd4: 02 80 00 08 be 2018ff4 <_CORE_message_queue_Insert_message+0xa0>
2018fd8: 01 00 00 00 nop
2018fdc: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
2018fe0: 80 a0 60 00 cmp %g1, 0
2018fe4: 02 80 00 04 be 2018ff4 <_CORE_message_queue_Insert_message+0xa0><== ALWAYS TAKEN
2018fe8: 01 00 00 00 nop
(*the_message_queue->notify_handler)( the_message_queue->notify_argument );
2018fec: 9f c0 40 00 call %g1 <== NOT EXECUTED
2018ff0: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED
2018ff4: 81 c7 e0 08 ret
2018ff8: 81 e8 00 00 restore
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 ) ) {
2018ffc: 80 a0 80 10 cmp %g2, %l0 <== NOT EXECUTED
2019000: 22 bf ff e4 be,a 2018f90 <_CORE_message_queue_Insert_message+0x3c><== NOT EXECUTED
2019004: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED
this_message = (CORE_message_queue_Buffer_control *) the_node;
if ( this_message->priority <= the_message->priority ) {
2019008: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
201900c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2019010: 36 bf ff fb bge,a 2018ffc <_CORE_message_queue_Insert_message+0xa8><== NOT EXECUTED
2019014: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
2019018: 30 bf ff de b,a 2018f90 <_CORE_message_queue_Insert_message+0x3c><== NOT EXECUTED
the_message->priority = submit_type;
switch ( submit_type ) {
case CORE_MESSAGE_QUEUE_SEND_REQUEST:
_ISR_Disable( level );
201901c: 7f ff c8 96 call 200b274 <sparc_disable_interrupts>
2019020: 01 00 00 00 nop
if ( the_message_queue->number_of_pending_messages++ == 0 )
2019024: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
2019028: 82 06 20 54 add %i0, 0x54, %g1
201902c: c2 26 40 00 st %g1, [ %i1 ]
old_last_node = the_chain->last;
2019030: c6 06 20 58 ld [ %i0 + 0x58 ], %g3
the_chain->last = the_node;
2019034: f2 26 20 58 st %i1, [ %i0 + 0x58 ]
2019038: 80 a0 00 02 cmp %g0, %g2
old_last_node->next = the_node;
the_node->previous = old_last_node;
201903c: c6 26 60 04 st %g3, [ %i1 + 4 ]
2019040: 82 60 3f ff subx %g0, -1, %g1
2019044: 84 00 a0 01 inc %g2
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;
2019048: f2 20 c0 00 st %i1, [ %g3 ]
201904c: a0 10 00 01 mov %g1, %l0
2019050: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
notify = true;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
2019054: 7f ff c8 8c call 200b284 <sparc_enable_interrupts>
2019058: 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 )
201905c: 10 bf ff de b 2018fd4 <_CORE_message_queue_Insert_message+0x80>
2019060: 80 8c 20 ff btst 0xff, %l0
notify = true;
_CORE_message_queue_Append_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
break;
case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
_ISR_Disable( level );
2019064: 7f ff c8 84 call 200b274 <sparc_disable_interrupts>
2019068: 01 00 00 00 nop
if ( the_message_queue->number_of_pending_messages++ == 0 )
201906c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2019070: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
2019074: 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;
2019078: f2 26 20 50 st %i1, [ %i0 + 0x50 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
201907c: c2 26 60 04 st %g1, [ %i1 + 4 ]
2019080: 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;
2019084: f2 20 e0 04 st %i1, [ %g3 + 4 ]
2019088: 82 60 3f ff subx %g0, -1, %g1
201908c: 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;
2019090: c6 26 40 00 st %g3, [ %i1 ]
2019094: a0 10 00 01 mov %g1, %l0
2019098: c4 26 20 48 st %g2, [ %i0 + 0x48 ]
notify = true;
_CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
_ISR_Enable( level );
201909c: 7f ff c8 7a call 200b284 <sparc_enable_interrupts>
20190a0: 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 )
20190a4: 10 bf ff cc b 2018fd4 <_CORE_message_queue_Insert_message+0x80>
20190a8: 80 8c 20 ff btst 0xff, %l0
02012900 <_CORE_message_queue_Seize>:
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
2012900: 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;
2012904: 27 00 80 c3 sethi %hi(0x2030c00), %l3
2012908: e2 04 e2 44 ld [ %l3 + 0x244 ], %l1 ! 2030e44 <_Thread_Executing>
void *buffer,
size_t *size_p,
bool wait,
Watchdog_Interval timeout
)
{
201290c: a4 10 00 19 mov %i1, %l2
Thread_Control *executing;
Thread_Control *the_thread;
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
_ISR_Disable( level );
2012910: 7f ff e2 59 call 200b274 <sparc_disable_interrupts>
2012914: c0 24 60 34 clr [ %l1 + 0x34 ]
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
2012918: 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))
201291c: 82 06 20 54 add %i0, 0x54, %g1
2012920: 80 a6 40 01 cmp %i1, %g1
2012924: 02 80 00 21 be 20129a8 <_CORE_message_queue_Seize+0xa8>
2012928: 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;
201292c: c6 06 40 00 ld [ %i1 ], %g3
the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
if ( the_message != NULL ) {
the_message_queue->number_of_pending_messages -= 1;
2012930: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_chain->first = new_first;
2012934: c6 26 20 50 st %g3, [ %i0 + 0x50 ]
2012938: 82 00 7f ff add %g1, -1, %g1
201293c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
new_first->previous = _Chain_Head(the_chain);
2012940: c4 20 e0 04 st %g2, [ %g3 + 4 ]
_ISR_Enable( level );
2012944: 7f ff e2 50 call 200b284 <sparc_enable_interrupts>
2012948: a2 06 60 10 add %i1, 0x10, %l1
*size_p = the_message->Contents.size;
201294c: d4 06 60 0c ld [ %i1 + 0xc ], %o2
_Thread_Executing->Wait.count = the_message->priority;
2012950: c4 04 e2 44 ld [ %l3 + 0x244 ], %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;
2012954: d4 26 c0 00 st %o2, [ %i3 ]
_Thread_Executing->Wait.count = the_message->priority;
2012958: c2 06 60 08 ld [ %i1 + 8 ], %g1
201295c: c2 20 a0 24 st %g1, [ %g2 + 0x24 ]
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
2012960: 92 10 00 11 mov %l1, %o1
2012964: 40 00 20 5c call 201aad4 <memcpy>
2012968: 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 );
201296c: 40 00 09 ba call 2015054 <_Thread_queue_Dequeue>
2012970: 90 10 00 18 mov %i0, %o0
if ( !the_thread ) {
2012974: 80 a2 20 00 cmp %o0, 0
2012978: 02 80 00 1f be 20129f4 <_CORE_message_queue_Seize+0xf4> <== ALWAYS TAKEN
201297c: 01 00 00 00 nop
* puts the messages in the message queue on behalf of the
* waiting task.
*/
the_message->priority = the_thread->Wait.count;
the_message->Contents.size = (size_t) the_thread->Wait.option;
2012980: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== 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;
2012984: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
the_message->Contents.size = (size_t) the_thread->Wait.option;
2012988: 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;
201298c: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED
2012990: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
2012994: 40 00 20 50 call 201aad4 <memcpy> <== NOT EXECUTED
2012998: 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(
201299c: f4 06 60 08 ld [ %i1 + 8 ], %i2 <== NOT EXECUTED
20129a0: 40 00 19 6d call 2018f54 <_CORE_message_queue_Insert_message><== NOT EXECUTED
20129a4: 81 e8 00 00 restore <== NOT EXECUTED
the_message->priority
);
return;
}
if ( !wait ) {
20129a8: 80 8f 20 ff btst 0xff, %i4
20129ac: 02 80 00 0c be 20129dc <_CORE_message_queue_Seize+0xdc>
20129b0: 82 10 20 01 mov 1, %g1
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;
20129b4: c2 26 20 30 st %g1, [ %i0 + 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;
20129b8: f6 24 60 28 st %i3, [ %l1 + 0x28 ]
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;
20129bc: f0 24 60 44 st %i0, [ %l1 + 0x44 ]
executing->Wait.id = id;
20129c0: e4 24 60 20 st %l2, [ %l1 + 0x20 ]
executing->Wait.return_argument_second.mutable_object = buffer;
20129c4: f4 24 60 2c st %i2, [ %l1 + 0x2c ]
executing->Wait.return_argument = size_p;
/* Wait.count will be filled in with the message priority */
_ISR_Enable( level );
20129c8: 7f ff e2 2f call 200b284 <sparc_enable_interrupts>
20129cc: 35 00 80 55 sethi %hi(0x2015400), %i2
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
20129d0: b2 10 00 1d mov %i5, %i1
20129d4: 40 00 0a 04 call 20151e4 <_Thread_queue_Enqueue_with_handler>
20129d8: 95 ee a2 3c restore %i2, 0x23c, %o2
);
return;
}
if ( !wait ) {
_ISR_Enable( level );
20129dc: 7f ff e2 2a call 200b284 <sparc_enable_interrupts>
20129e0: 01 00 00 00 nop
executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
20129e4: 82 10 20 04 mov 4, %g1 ! 4 <PROM_START+0x4>
20129e8: 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 );
}
20129ec: 81 c7 e0 08 ret
20129f0: 81 e8 00 00 restore
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 );
20129f4: 7f ff ff 0f call 2012630 <_Chain_Append>
20129f8: 91 ee 20 68 restore %i0, 0x68, %o0
02012a00 <_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
)
{
2012a00: 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 ) {
2012a04: 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
)
{
2012a08: 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 ) {
2012a0c: 80 a0 40 1a cmp %g1, %i2
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
CORE_message_queue_Submit_types submit_type,
bool wait,
Watchdog_Interval timeout
)
{
2012a10: 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 ) {
2012a14: 0a 80 00 22 bcs 2012a9c <_CORE_message_queue_Submit+0x9c>
2012a18: 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 ) {
2012a1c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2
2012a20: 80 a0 a0 00 cmp %g2, 0
2012a24: 02 80 00 22 be 2012aac <_CORE_message_queue_Submit+0xac>
2012a28: 01 00 00 00 nop
/*
* 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 <
2012a2c: c2 04 60 44 ld [ %l1 + 0x44 ], %g1
2012a30: 80 a0 40 02 cmp %g1, %g2
2012a34: 18 80 00 2b bgu 2012ae0 <_CORE_message_queue_Submit+0xe0>
2012a38: 80 a4 a0 00 cmp %l2, 0
* 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 ) {
2012a3c: 02 80 00 18 be 2012a9c <_CORE_message_queue_Submit+0x9c> <== ALWAYS TAKEN
2012a40: 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() ) {
2012a44: 03 00 80 c3 sethi %hi(0x2030c00), %g1 <== NOT EXECUTED
2012a48: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2030e20 <_ISR_Nest_level><== NOT EXECUTED
2012a4c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2012a50: 32 80 00 13 bne,a 2012a9c <_CORE_message_queue_Submit+0x9c><== NOT EXECUTED
2012a54: 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;
2012a58: 03 00 80 c3 sethi %hi(0x2030c00), %g1 <== NOT EXECUTED
_ISR_Disable( level );
2012a5c: 7f ff e2 06 call 200b274 <sparc_disable_interrupts> <== NOT EXECUTED
2012a60: e0 00 62 44 ld [ %g1 + 0x244 ], %l0 ! 2030e44 <_Thread_Executing><== NOT EXECUTED
2012a64: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2012a68: 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;
2012a6c: 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;
2012a70: f6 24 20 20 st %i3, [ %l0 + 0x20 ] <== NOT EXECUTED
executing->Wait.return_argument_second.immutable_object = buffer;
2012a74: f2 24 20 2c st %i1, [ %l0 + 0x2c ] <== NOT EXECUTED
executing->Wait.option = (uint32_t) size;
2012a78: 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;
2012a7c: 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 );
2012a80: 7f ff e2 01 call 200b284 <sparc_enable_interrupts> <== NOT EXECUTED
2012a84: b0 10 20 07 mov 7, %i0 <== NOT EXECUTED
_Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
2012a88: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 <== NOT EXECUTED
2012a8c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2012a90: 15 00 80 55 sethi %hi(0x2015400), %o2 <== NOT EXECUTED
2012a94: 40 00 09 d4 call 20151e4 <_Thread_queue_Enqueue_with_handler><== NOT EXECUTED
2012a98: 94 12 a2 3c or %o2, 0x23c, %o2 ! 201563c <_Thread_queue_Timeout><== NOT EXECUTED
2012a9c: 81 c7 e0 08 ret
2012aa0: 81 e8 00 00 restore
}
return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
}
2012aa4: 81 c7 e0 08 ret <== NOT EXECUTED
2012aa8: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED
/*
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
2012aac: 40 00 09 6a call 2015054 <_Thread_queue_Dequeue>
2012ab0: 90 10 00 11 mov %l1, %o0
if ( the_thread ) {
2012ab4: a0 92 20 00 orcc %o0, 0, %l0
2012ab8: 02 80 00 1b be 2012b24 <_CORE_message_queue_Submit+0x124>
2012abc: 92 10 00 19 mov %i1, %o1
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
2012ac0: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
2012ac4: 40 00 20 04 call 201aad4 <memcpy>
2012ac8: 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;
2012acc: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
the_thread->Wait.count = submit_type;
2012ad0: 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;
2012ad4: f4 20 40 00 st %i2, [ %g1 ]
the_thread->Wait.count = submit_type;
2012ad8: 81 c7 e0 08 ret
2012adc: 91 e8 20 00 restore %g0, 0, %o0
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 *)
2012ae0: 7f ff fe e0 call 2012660 <_Chain_Get>
2012ae4: 90 04 60 68 add %l1, 0x68, %o0
/*
* NOTE: If the system is consistent, this error should never occur.
*/
if ( !the_message ) {
2012ae8: a0 92 20 00 orcc %o0, 0, %l0
2012aec: 02 bf ff ee be 2012aa4 <_CORE_message_queue_Submit+0xa4> <== NEVER TAKEN
2012af0: 92 10 00 19 mov %i1, %o1
const void *source,
void *destination,
size_t size
)
{
memcpy(destination, source, size);
2012af4: 94 10 00 1a mov %i2, %o2
2012af8: 40 00 1f f7 call 201aad4 <memcpy>
2012afc: 90 04 20 10 add %l0, 0x10, %o0
size
);
the_message->Contents.size = size;
the_message->priority = submit_type;
_CORE_message_queue_Insert_message(
2012b00: 90 10 00 11 mov %l1, %o0
_CORE_message_queue_Copy_buffer(
buffer,
the_message->Contents.buffer,
size
);
the_message->Contents.size = size;
2012b04: f4 24 20 0c st %i2, [ %l0 + 0xc ]
the_message->priority = submit_type;
2012b08: fa 24 20 08 st %i5, [ %l0 + 8 ]
_CORE_message_queue_Insert_message(
2012b0c: 92 10 00 10 mov %l0, %o1
2012b10: 94 10 00 1d mov %i5, %o2
2012b14: 40 00 19 10 call 2018f54 <_CORE_message_queue_Insert_message>
2012b18: b0 10 20 00 clr %i0
2012b1c: 81 c7 e0 08 ret
2012b20: 81 e8 00 00 restore
* Is there a thread currently waiting on this message queue?
*/
if ( the_message_queue->number_of_pending_messages == 0 ) {
the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
if ( the_thread ) {
2012b24: 10 bf ff c2 b 2012a2c <_CORE_message_queue_Submit+0x2c>
2012b28: c4 04 60 48 ld [ %l1 + 0x48 ], %g2
02006364 <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
2006364: 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;
2006368: c2 06 40 00 ld [ %i1 ], %g1
CORE_mutex_Status _CORE_mutex_Initialize(
CORE_mutex_Control *the_mutex,
CORE_mutex_Attributes *the_mutex_attributes,
uint32_t initial_lock
)
{
200636c: 90 10 00 18 mov %i0, %o0
/* 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;
2006370: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
2006374: c4 06 60 04 ld [ %i1 + 4 ], %g2
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
2006378: 80 a6 a0 00 cmp %i2, 0
/* 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;
200637c: c4 26 20 44 st %g2, [ %i0 + 0x44 ]
2006380: c6 06 60 08 ld [ %i1 + 8 ], %g3
2006384: c6 26 20 48 st %g3, [ %i0 + 0x48 ]
2006388: c2 06 60 0c ld [ %i1 + 0xc ], %g1
the_mutex->lock = initial_lock;
200638c: f4 26 20 50 st %i2, [ %i0 + 0x50 ]
/* 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;
2006390: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
2006394: 12 80 00 1f bne 2006410 <_CORE_mutex_Initialize+0xac>
2006398: c0 26 20 58 clr [ %i0 + 0x58 ]
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
200639c: 03 00 80 5d sethi %hi(0x2017400), %g1
20063a0: c8 00 60 a4 ld [ %g1 + 0xa4 ], %g4 ! 20174a4 <_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;
20063a4: 84 10 20 01 mov 1, %g2
20063a8: c4 26 20 54 st %g2, [ %i0 + 0x54 ]
the_mutex->holder = _Thread_Executing;
the_mutex->holder_id = _Thread_Executing->Object.id;
20063ac: c2 01 20 08 ld [ %g4 + 8 ], %g1
the_mutex->lock = initial_lock;
the_mutex->blocked_count = 0;
if ( initial_lock == CORE_MUTEX_LOCKED ) {
the_mutex->nest_count = 1;
the_mutex->holder = _Thread_Executing;
20063b0: c8 26 20 5c st %g4, [ %i0 + 0x5c ]
the_mutex->holder_id = _Thread_Executing->Object.id;
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
20063b4: 80 a0 e0 02 cmp %g3, 2
20063b8: 02 80 00 05 be 20063cc <_CORE_mutex_Initialize+0x68>
20063bc: c2 26 20 60 st %g1, [ %i0 + 0x60 ]
20063c0: 80 a0 e0 03 cmp %g3, 3
20063c4: 32 80 00 17 bne,a 2006420 <_CORE_mutex_Initialize+0xbc> <== ALWAYS TAKEN
20063c8: c2 06 60 08 ld [ %i1 + 8 ], %g1
_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
if ( _Thread_Executing->current_priority <
20063cc: c4 01 20 14 ld [ %g4 + 0x14 ], %g2
20063d0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
20063d4: 80 a0 80 01 cmp %g2, %g1
20063d8: 0a 80 00 0c bcs 2006408 <_CORE_mutex_Initialize+0xa4> <== NEVER TAKEN
20063dc: 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++;
20063e0: c2 01 20 1c ld [ %g4 + 0x1c ], %g1
the_mutex->nest_count = 0;
the_mutex->holder = NULL;
the_mutex->holder_id = 0;
}
_Thread_queue_Initialize(
20063e4: 94 10 24 00 mov 0x400, %o2
_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++;
20063e8: 82 00 60 01 inc %g1
20063ec: c2 21 20 1c st %g1, [ %g4 + 0x1c ]
the_mutex->nest_count = 0;
the_mutex->holder = NULL;
the_mutex->holder_id = 0;
}
_Thread_queue_Initialize(
20063f0: c2 06 60 08 ld [ %i1 + 8 ], %g1
20063f4: 96 10 20 05 mov 5, %o3
20063f8: 80 a0 00 01 cmp %g0, %g1
20063fc: b0 10 20 00 clr %i0
2006400: 40 00 08 13 call 200844c <_Thread_queue_Initialize>
2006404: 92 40 20 00 addx %g0, 0, %o1
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
2006408: 81 c7 e0 08 ret
200640c: 81 e8 00 00 restore
#endif
_Thread_Executing->resource_count++;
}
} else {
the_mutex->nest_count = 0;
2006410: c0 26 20 54 clr [ %i0 + 0x54 ]
the_mutex->holder = NULL;
2006414: c0 26 20 5c clr [ %i0 + 0x5c ]
the_mutex->holder_id = 0;
2006418: c0 26 20 60 clr [ %i0 + 0x60 ]
}
_Thread_queue_Initialize(
200641c: c2 06 60 08 ld [ %i1 + 8 ], %g1
2006420: 94 10 24 00 mov 0x400, %o2
2006424: 80 a0 00 01 cmp %g0, %g1
2006428: 96 10 20 05 mov 5, %o3
200642c: 92 40 20 00 addx %g0, 0, %o1
2006430: 40 00 08 07 call 200844c <_Thread_queue_Initialize>
2006434: b0 10 20 00 clr %i0
STATES_WAITING_FOR_MUTEX,
CORE_MUTEX_TIMEOUT
);
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
2006438: 81 c7 e0 08 ret
200643c: 81 e8 00 00 restore
020064cc <_CORE_mutex_Seize>:
Objects_Id _id,
bool _wait,
Watchdog_Interval _timeout,
ISR_Level _level
)
{
20064cc: 9d e3 bf 98 save %sp, -104, %sp
_CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
20064d0: 21 00 80 5c sethi %hi(0x2017000), %l0
20064d4: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level>
20064d8: 80 a0 60 00 cmp %g1, 0
20064dc: 02 80 00 05 be 20064f0 <_CORE_mutex_Seize+0x24>
20064e0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20064e4: 80 8e a0 ff btst 0xff, %i2
20064e8: 12 80 00 1a bne 2006550 <_CORE_mutex_Seize+0x84> <== ALWAYS TAKEN
20064ec: 03 00 80 5d sethi %hi(0x2017400), %g1
20064f0: 90 10 00 18 mov %i0, %o0
20064f4: 40 00 14 ec call 200b8a4 <_CORE_mutex_Seize_interrupt_trylock>
20064f8: 92 07 a0 54 add %fp, 0x54, %o1
20064fc: 80 a2 20 00 cmp %o0, 0
2006500: 02 80 00 12 be 2006548 <_CORE_mutex_Seize+0x7c>
2006504: 80 8e a0 ff btst 0xff, %i2
2006508: 02 80 00 1a be 2006570 <_CORE_mutex_Seize+0xa4>
200650c: 01 00 00 00 nop
2006510: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1
2006514: 05 00 80 5d sethi %hi(0x2017400), %g2
2006518: c6 00 a0 a4 ld [ %g2 + 0xa4 ], %g3 ! 20174a4 <_Thread_Executing>
200651c: 82 00 60 01 inc %g1
2006520: f2 20 e0 20 st %i1, [ %g3 + 0x20 ]
2006524: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ]
2006528: f0 20 e0 44 st %i0, [ %g3 + 0x44 ]
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;
200652c: 82 10 20 01 mov 1, %g1
2006530: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
2006534: 7f ff ee 30 call 2001df4 <sparc_enable_interrupts>
2006538: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
200653c: 90 10 00 18 mov %i0, %o0
2006540: 7f ff ff c0 call 2006440 <_CORE_mutex_Seize_interrupt_blocking>
2006544: 92 10 00 1b mov %i3, %o1
2006548: 81 c7 e0 08 ret
200654c: 81 e8 00 00 restore
2006550: c4 00 61 84 ld [ %g1 + 0x184 ], %g2
2006554: 80 a0 a0 01 cmp %g2, 1
2006558: 28 bf ff e7 bleu,a 20064f4 <_CORE_mutex_Seize+0x28>
200655c: 90 10 00 18 mov %i0, %o0
2006560: 90 10 20 00 clr %o0
2006564: 92 10 20 00 clr %o1
2006568: 40 00 01 69 call 2006b0c <_Internal_error_Occurred>
200656c: 94 10 20 13 mov 0x13, %o2
2006570: 7f ff ee 21 call 2001df4 <sparc_enable_interrupts>
2006574: d0 07 a0 54 ld [ %fp + 0x54 ], %o0
2006578: 03 00 80 5d sethi %hi(0x2017400), %g1
200657c: c6 00 60 a4 ld [ %g1 + 0xa4 ], %g3 ! 20174a4 <_Thread_Executing>
2006580: 84 10 20 01 mov 1, %g2
2006584: c4 20 e0 34 st %g2, [ %g3 + 0x34 ]
2006588: 81 c7 e0 08 ret
200658c: 81 e8 00 00 restore
0200b8a4 <_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
)
{
200b8a4: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
ISR_Level level = *level_p;
/* disabled when you get here */
executing = _Thread_Executing;
200b8a8: 03 00 80 5d sethi %hi(0x2017400), %g1
200b8ac: c6 00 60 a4 ld [ %g1 + 0xa4 ], %g3 ! 20174a4 <_Thread_Executing>
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
Thread_Control *executing;
ISR_Level level = *level_p;
200b8b0: d0 06 40 00 ld [ %i1 ], %o0
/* disabled when you get here */
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
200b8b4: c0 20 e0 34 clr [ %g3 + 0x34 ]
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
200b8b8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200b8bc: 80 a0 60 00 cmp %g1, 0
200b8c0: 22 80 00 12 be,a 200b908 <_CORE_mutex_Seize_interrupt_trylock+0x64>
200b8c4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
the_mutex->lock = CORE_MUTEX_LOCKED;
200b8c8: c0 26 20 50 clr [ %i0 + 0x50 ]
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
200b8cc: 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;
200b8d0: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
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;
200b8d4: 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;
200b8d8: c6 26 20 5c st %g3, [ %i0 + 0x5c ]
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
200b8dc: 82 10 20 01 mov 1, %g1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
200b8e0: 80 a0 a0 02 cmp %g2, 2
200b8e4: 02 80 00 0e be 200b91c <_CORE_mutex_Seize_interrupt_trylock+0x78><== ALWAYS TAKEN
200b8e8: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
200b8ec: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED
200b8f0: 22 80 00 0d be,a 200b924 <_CORE_mutex_Seize_interrupt_trylock+0x80><== NOT EXECUTED
200b8f4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
executing->resource_count++;
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
_ISR_Enable( level );
200b8f8: 7f ff d9 3f call 2001df4 <sparc_enable_interrupts>
200b8fc: b0 10 20 00 clr %i0
200b900: 81 c7 e0 08 ret
200b904: 81 e8 00 00 restore
/*
* 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 ) ) {
200b908: 80 a0 c0 01 cmp %g3, %g1
200b90c: 22 80 00 2a be,a 200b9b4 <_CORE_mutex_Seize_interrupt_trylock+0x110>
200b910: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
200b914: 81 c7 e0 08 ret
200b918: 91 e8 20 01 restore %g0, 1, %o0
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
200b91c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
200b920: 80 a0 a0 03 cmp %g2, 3
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
200b924: 82 00 60 01 inc %g1
}
if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
200b928: 12 bf ff f4 bne 200b8f8 <_CORE_mutex_Seize_interrupt_trylock+0x54><== ALWAYS TAKEN
200b92c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
200b930: c4 06 20 4c ld [ %i0 + 0x4c ], %g2 <== NOT EXECUTED
current = executing->current_priority;
200b934: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED
if ( current == ceiling ) {
200b938: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200b93c: 02 80 00 2f be 200b9f8 <_CORE_mutex_Seize_interrupt_trylock+0x154><== NOT EXECUTED
200b940: 01 00 00 00 nop <== NOT EXECUTED
_ISR_Enable( level );
return 0;
}
if ( current > ceiling ) {
200b944: 1a 80 00 11 bcc 200b988 <_CORE_mutex_Seize_interrupt_trylock+0xe4><== NOT EXECUTED
200b948: 82 10 20 06 mov 6, %g1 ! 6 <PROM_START+0x6> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
200b94c: 05 00 80 5c sethi %hi(0x2017000), %g2 <== NOT EXECUTED
200b950: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
200b954: 82 00 60 01 inc %g1 <== NOT EXECUTED
200b958: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ] <== NOT EXECUTED
_Thread_Disable_dispatch();
_ISR_Enable( level );
200b95c: 7f ff d9 26 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200b960: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Change_priority(
200b964: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== NOT EXECUTED
200b968: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 <== NOT EXECUTED
200b96c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200b970: 7f ff ee ec call 2007520 <_Thread_Change_priority> <== NOT EXECUTED
200b974: b0 10 20 00 clr %i0 <== NOT EXECUTED
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
FALSE
);
_Thread_Enable_dispatch();
200b978: 7f ff f0 80 call 2007b78 <_Thread_Enable_dispatch> <== NOT EXECUTED
200b97c: 01 00 00 00 nop <== NOT EXECUTED
200b980: 81 c7 e0 08 ret <== NOT EXECUTED
200b984: 81 e8 00 00 restore <== NOT EXECUTED
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
200b988: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
200b98c: 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;
200b990: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
200b994: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
200b998: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
200b99c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
200b9a0: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED
_ISR_Enable( level );
200b9a4: 7f ff d9 14 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200b9a8: b0 10 20 00 clr %i0 <== NOT EXECUTED
200b9ac: 81 c7 e0 08 ret <== NOT EXECUTED
200b9b0: 81 e8 00 00 restore <== 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 ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
200b9b4: 80 a0 60 00 cmp %g1, 0
200b9b8: 22 80 00 0a be,a 200b9e0 <_CORE_mutex_Seize_interrupt_trylock+0x13c>
200b9bc: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
200b9c0: 80 a0 60 01 cmp %g1, 1
200b9c4: 12 bf ff d4 bne 200b914 <_CORE_mutex_Seize_interrupt_trylock+0x70>
200b9c8: 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;
200b9cc: c2 20 e0 34 st %g1, [ %g3 + 0x34 ]
_ISR_Enable( level );
200b9d0: 7f ff d9 09 call 2001df4 <sparc_enable_interrupts>
200b9d4: b0 10 20 00 clr %i0
200b9d8: 81 c7 e0 08 ret
200b9dc: 81 e8 00 00 restore
* 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++;
200b9e0: 82 00 60 01 inc %g1
200b9e4: c2 26 20 54 st %g1, [ %i0 + 0x54 ]
_ISR_Enable( level );
200b9e8: 7f ff d9 03 call 2001df4 <sparc_enable_interrupts>
200b9ec: b0 10 20 00 clr %i0
200b9f0: 81 c7 e0 08 ret
200b9f4: 81 e8 00 00 restore
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
if ( current == ceiling ) {
_ISR_Enable( level );
200b9f8: 7f ff d8 ff call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200b9fc: b0 10 20 00 clr %i0 <== NOT EXECUTED
200ba00: 81 c7 e0 08 ret <== NOT EXECUTED
200ba04: 81 e8 00 00 restore <== NOT EXECUTED
02006590 <_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
)
{
2006590: 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 ) {
2006594: 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
)
{
2006598: 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 ) {
200659c: 80 a0 60 00 cmp %g1, 0
20065a0: 02 80 00 07 be 20065bc <_CORE_mutex_Surrender+0x2c>
20065a4: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !_Thread_Is_executing( holder ) )
20065a8: 03 00 80 5d sethi %hi(0x2017400), %g1
20065ac: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_Thread_Executing>
20065b0: 80 a2 00 02 cmp %o0, %g2
20065b4: 12 80 00 2e bne 200666c <_CORE_mutex_Surrender+0xdc>
20065b8: 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 )
20065bc: c2 04 20 54 ld [ %l0 + 0x54 ], %g1
20065c0: 80 a0 60 00 cmp %g1, 0
20065c4: 02 80 00 22 be 200664c <_CORE_mutex_Surrender+0xbc>
20065c8: 82 00 7f ff add %g1, -1, %g1
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
20065cc: 80 a0 60 00 cmp %g1, 0
20065d0: 12 80 00 21 bne 2006654 <_CORE_mutex_Surrender+0xc4>
20065d4: c2 24 20 54 st %g1, [ %l0 + 0x54 ]
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
20065d8: c4 04 20 48 ld [ %l0 + 0x48 ], %g2
/*
* Formally release the mutex before possibly transferring it to a
* blocked thread.
*/
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
20065dc: 80 a0 a0 02 cmp %g2, 2
20065e0: 02 80 00 31 be 20066a4 <_CORE_mutex_Surrender+0x114>
20065e4: 80 a0 a0 03 cmp %g2, 3
20065e8: 22 80 00 30 be,a 20066a8 <_CORE_mutex_Surrender+0x118> <== NEVER TAKEN
20065ec: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
}
the_mutex->holder = NULL;
20065f0: 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 ) ||
20065f4: 80 a0 a0 02 cmp %g2, 2
20065f8: 02 80 00 1f be 2006674 <_CORE_mutex_Surrender+0xe4>
20065fc: c0 24 20 60 clr [ %l0 + 0x60 ]
2006600: 80 a0 a0 03 cmp %g2, 3
2006604: 22 80 00 1d be,a 2006678 <_CORE_mutex_Surrender+0xe8> <== NEVER TAKEN
2006608: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
/*
* 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 ) ) ) {
200660c: 40 00 06 55 call 2007f60 <_Thread_queue_Dequeue>
2006610: 90 10 00 10 mov %l0, %o0
2006614: 86 92 20 00 orcc %o0, 0, %g3
2006618: 02 80 00 37 be 20066f4 <_CORE_mutex_Surrender+0x164>
200661c: 82 10 20 01 mov 1, %g1
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
2006620: c2 00 e0 08 ld [ %g3 + 8 ], %g1
the_mutex->nest_count = 1;
switch ( the_mutex->Attributes.discipline ) {
2006624: c4 04 20 48 ld [ %l0 + 0x48 ], %g2
} else
#endif
{
the_mutex->holder = the_thread;
the_mutex->holder_id = the_thread->Object.id;
2006628: c2 24 20 60 st %g1, [ %l0 + 0x60 ]
} else
#endif
{
the_mutex->holder = the_thread;
200662c: c6 24 20 5c st %g3, [ %l0 + 0x5c ]
the_mutex->holder_id = the_thread->Object.id;
the_mutex->nest_count = 1;
2006630: 82 10 20 01 mov 1, %g1
switch ( the_mutex->Attributes.discipline ) {
2006634: 80 a0 a0 02 cmp %g2, 2
2006638: 02 80 00 2a be 20066e0 <_CORE_mutex_Surrender+0x150>
200663c: c2 24 20 54 st %g1, [ %l0 + 0x54 ]
2006640: 80 a0 a0 03 cmp %g2, 3
2006644: 22 80 00 1c be,a 20066b4 <_CORE_mutex_Surrender+0x124> <== NEVER TAKEN
2006648: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
200664c: 81 c7 e0 08 ret
2006650: 91 e8 20 00 restore %g0, 0, %o0
return CORE_MUTEX_STATUS_SUCCESSFUL;
the_mutex->nest_count--;
if ( the_mutex->nest_count != 0 ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
2006654: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
2006658: 80 a0 60 00 cmp %g1, 0
200665c: 02 bf ff fc be 200664c <_CORE_mutex_Surrender+0xbc> <== ALWAYS TAKEN
2006660: 80 a0 60 01 cmp %g1, 1
2006664: 12 bf ff dd bne 20065d8 <_CORE_mutex_Surrender+0x48> <== NOT EXECUTED
2006668: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
return CORE_MUTEX_STATUS_SUCCESSFUL;
}
200666c: 81 c7 e0 08 ret
2006670: 81 e8 00 00 restore
_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 &&
2006674: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
2006678: 80 a0 60 00 cmp %g1, 0
200667c: 12 bf ff e4 bne 200660c <_CORE_mutex_Surrender+0x7c>
2006680: 01 00 00 00 nop
2006684: d2 02 20 18 ld [ %o0 + 0x18 ], %o1
2006688: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200668c: 80 a2 40 01 cmp %o1, %g1
2006690: 02 bf ff df be 200660c <_CORE_mutex_Surrender+0x7c>
2006694: 01 00 00 00 nop
holder->real_priority != holder->current_priority ) {
_Thread_Change_priority( holder, holder->real_priority, TRUE );
2006698: 40 00 03 a2 call 2007520 <_Thread_Change_priority>
200669c: 94 10 20 01 mov 1, %o2 ! 1 <PROM_START+0x1>
20066a0: 30 bf ff db b,a 200660c <_CORE_mutex_Surrender+0x7c>
the_mutex->nest_count++;
return CORE_MUTEX_RELEASE_NOT_ORDER;
}
first_node = _Chain_Get_first_unprotected(&holder->lock_mutex);
#endif
holder->resource_count--;
20066a4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
20066a8: 82 00 7f ff add %g1, -1, %g1
20066ac: 10 bf ff d1 b 20065f0 <_CORE_mutex_Surrender+0x60>
20066b0: c2 22 20 1c st %g1, [ %o0 + 0x1c ]
#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 <
20066b4: 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++;
20066b8: 82 00 60 01 inc %g1 <== NOT EXECUTED
20066bc: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED
if (the_mutex->Attributes.priority_ceiling <
20066c0: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 <== NOT EXECUTED
20066c4: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
20066c8: 1a bf ff e1 bcc 200664c <_CORE_mutex_Surrender+0xbc> <== NOT EXECUTED
20066cc: 94 10 20 00 clr %o2 <== NOT EXECUTED
the_thread->current_priority){
_Thread_Change_priority(
20066d0: 40 00 03 94 call 2007520 <_Thread_Change_priority> <== NOT EXECUTED
20066d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
20066d8: 81 c7 e0 08 ret <== NOT EXECUTED
20066dc: 81 e8 00 00 restore <== 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++;
20066e0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
20066e4: 82 00 60 01 inc %g1
20066e8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ]
20066ec: 81 c7 e0 08 ret
20066f0: 91 e8 20 00 restore %g0, 0, %o0
}
break;
}
}
} else
the_mutex->lock = CORE_MUTEX_UNLOCKED;
20066f4: c2 24 20 50 st %g1, [ %l0 + 0x50 ]
20066f8: 81 c7 e0 08 ret
20066fc: 91 e8 20 00 restore %g0, 0, %o0
0200674c <_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
)
{
200674c: 9d e3 bf 98 save %sp, -104, %sp
2006750: 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)) ) {
2006754: b0 10 20 00 clr %i0
2006758: 40 00 06 02 call 2007f60 <_Thread_queue_Dequeue>
200675c: 90 10 00 10 mov %l0, %o0
2006760: 80 a2 20 00 cmp %o0, 0
2006764: 02 80 00 04 be 2006774 <_CORE_semaphore_Surrender+0x28>
2006768: 01 00 00 00 nop
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
200676c: 81 c7 e0 08 ret
2006770: 81 e8 00 00 restore
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
2006774: 7f ff ed 9c call 2001de4 <sparc_disable_interrupts>
2006778: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
200677c: c4 04 20 48 ld [ %l0 + 0x48 ], %g2
2006780: c2 04 20 40 ld [ %l0 + 0x40 ], %g1
2006784: 80 a0 80 01 cmp %g2, %g1
2006788: 0a 80 00 06 bcs 20067a0 <_CORE_semaphore_Surrender+0x54> <== ALWAYS TAKEN
200678c: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
2006790: 7f ff ed 99 call 2001df4 <sparc_enable_interrupts>
2006794: 01 00 00 00 nop
}
return status;
}
2006798: 81 c7 e0 08 ret
200679c: 81 e8 00 00 restore
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
20067a0: 82 00 a0 01 add %g2, 1, %g1
20067a4: b0 10 20 00 clr %i0
20067a8: 10 bf ff fa b 2006790 <_CORE_semaphore_Surrender+0x44>
20067ac: c2 24 20 48 st %g1, [ %l0 + 0x48 ]
0200b844 <_Chain_Initialize>:
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
200b844: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *current;
Chain_Node *next;
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
200b848: c0 26 20 04 clr [ %i0 + 4 ]
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
200b84c: 90 10 00 1b mov %i3, %o0
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
200b850: 80 a6 a0 00 cmp %i2, 0
200b854: 02 80 00 0f be 200b890 <_Chain_Initialize+0x4c> <== NEVER TAKEN
200b858: 84 10 00 18 mov %i0, %g2
200b85c: b4 06 bf ff add %i2, -1, %i2
200b860: 82 10 00 19 mov %i1, %g1
200b864: 92 10 00 1a mov %i2, %o1
current->next = next;
next->previous = current;
200b868: c4 20 60 04 st %g2, [ %g1 + 4 ]
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
current->next = next;
200b86c: c2 20 80 00 st %g1, [ %g2 ]
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
200b870: 80 a6 a0 00 cmp %i2, 0
Chain_Control *the_chain,
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
200b874: 84 10 00 01 mov %g1, %g2
200b878: b4 06 bf ff add %i2, -1, %i2
count = number_nodes;
current = _Chain_Head( the_chain );
the_chain->permanent_null = NULL;
next = starting_address;
while ( count-- ) {
200b87c: 12 bf ff fb bne 200b868 <_Chain_Initialize+0x24>
200b880: 82 00 40 08 add %g1, %o0, %g1
200b884: 40 00 20 01 call 2013888 <.umul>
200b888: 01 00 00 00 nop
200b88c: 84 06 40 08 add %i1, %o0, %g2
next->previous = current;
current = next;
next = (Chain_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
current->next = _Chain_Tail( the_chain );
200b890: 82 06 20 04 add %i0, 4, %g1
200b894: c2 20 80 00 st %g1, [ %g2 ]
the_chain->last = current;
200b898: c4 26 20 08 st %g2, [ %i0 + 8 ]
}
200b89c: 81 c7 e0 08 ret
200b8a0: 81 e8 00 00 restore
0200b764 <_Debug_Is_enabled>:
*/
bool _Debug_Is_enabled(
rtems_debug_control level
)
{
200b764: 03 00 80 5d sethi %hi(0x2017400), %g1 <== NOT EXECUTED
200b768: c4 00 60 a8 ld [ %g1 + 0xa8 ], %g2 ! 20174a8 <_Debug_Level><== NOT EXECUTED
200b76c: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED
200b770: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
return (_Debug_Level & level) ? true : false;
}
200b774: 81 c3 e0 08 retl <== NOT EXECUTED
200b778: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED
020051dc <_Event_Seize>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
20051dc: 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;
20051e0: 03 00 80 5d sethi %hi(0x2017400), %g1
20051e4: e0 00 60 a4 ld [ %g1 + 0xa4 ], %l0 ! 20174a4 <_Thread_Executing>
executing->Wait.return_code = RTEMS_SUCCESSFUL;
20051e8: c0 24 20 34 clr [ %l0 + 0x34 ]
api = executing->API_Extensions[ THREAD_API_RTEMS ];
_ISR_Disable( level );
20051ec: 7f ff f2 fe call 2001de4 <sparc_disable_interrupts>
20051f0: e4 04 21 68 ld [ %l0 + 0x168 ], %l2
pending_events = api->pending_events;
20051f4: c2 04 80 00 ld [ %l2 ], %g1
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
20051f8: a2 8e 00 01 andcc %i0, %g1, %l1
20051fc: 02 80 00 07 be 2005218 <_Event_Seize+0x3c>
2005200: 80 8e 60 01 btst 1, %i1
2005204: 80 a6 00 11 cmp %i0, %l1
2005208: 02 80 00 23 be 2005294 <_Event_Seize+0xb8>
200520c: 80 8e 60 02 btst 2, %i1
2005210: 12 80 00 21 bne 2005294 <_Event_Seize+0xb8> <== ALWAYS TAKEN
2005214: 80 8e 60 01 btst 1, %i1
_ISR_Enable( level );
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
2005218: 12 80 00 18 bne 2005278 <_Event_Seize+0x9c>
200521c: 82 10 20 01 mov 1, %g1
executing->Wait.return_code = RTEMS_UNSATISFIED;
*event_out = seized_events;
return;
}
_Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
2005220: 23 00 80 5d sethi %hi(0x2017400), %l1
executing->Wait.option = (uint32_t) option_set;
2005224: f2 24 20 30 st %i1, [ %l0 + 0x30 ]
executing->Wait.count = (uint32_t) event_in;
2005228: f0 24 20 24 st %i0, [ %l0 + 0x24 ]
executing->Wait.return_argument = event_out;
200522c: 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;
2005230: c2 24 62 b4 st %g1, [ %l1 + 0x2b4 ]
executing->Wait.option = (uint32_t) option_set;
executing->Wait.count = (uint32_t) event_in;
executing->Wait.return_argument = event_out;
_ISR_Enable( level );
2005234: 7f ff f2 f0 call 2001df4 <sparc_enable_interrupts>
2005238: 01 00 00 00 nop
if ( ticks ) {
200523c: 80 a6 a0 00 cmp %i2, 0
2005240: 32 80 00 1c bne,a 20052b0 <_Event_Seize+0xd4>
2005244: c2 04 20 08 ld [ %l0 + 8 ], %g1
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
2005248: 90 10 00 10 mov %l0, %o0
200524c: 40 00 0c e9 call 20085f0 <_Thread_Set_state>
2005250: 92 10 21 00 mov 0x100, %o1
_ISR_Disable( level );
2005254: 7f ff f2 e4 call 2001de4 <sparc_disable_interrupts>
2005258: 01 00 00 00 nop
sync_state = _Event_Sync_state;
200525c: f0 04 62 b4 ld [ %l1 + 0x2b4 ], %i0
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
2005260: c0 24 62 b4 clr [ %l1 + 0x2b4 ]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
2005264: 80 a6 20 01 cmp %i0, 1
2005268: 02 80 00 27 be 2005304 <_Event_Seize+0x128>
200526c: b2 10 00 10 mov %l0, %i1
* 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 );
2005270: 40 00 08 95 call 20074c4 <_Thread_blocking_operation_Cancel>
2005274: 95 e8 00 08 restore %g0, %o0, %o2
*event_out = seized_events;
return;
}
if ( _Options_Is_no_wait( option_set ) ) {
_ISR_Enable( level );
2005278: 7f ff f2 df call 2001df4 <sparc_enable_interrupts>
200527c: 01 00 00 00 nop
executing->Wait.return_code = RTEMS_UNSATISFIED;
2005280: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
2005284: c2 24 20 34 st %g1, [ %l0 + 0x34 ]
*event_out = seized_events;
2005288: e2 26 c0 00 st %l1, [ %i3 ]
200528c: 81 c7 e0 08 ret
2005290: 81 e8 00 00 restore
pending_events = api->pending_events;
seized_events = _Event_sets_Get( pending_events, event_in );
if ( !_Event_sets_Is_empty( seized_events ) &&
(seized_events == event_in || _Options_Is_any( option_set )) ) {
api->pending_events =
2005294: 82 28 40 11 andn %g1, %l1, %g1
2005298: c2 24 80 00 st %g1, [ %l2 ]
_Event_sets_Clear( pending_events, seized_events );
_ISR_Enable( level );
200529c: 7f ff f2 d6 call 2001df4 <sparc_enable_interrupts>
20052a0: 01 00 00 00 nop
*event_out = seized_events;
20052a4: e2 26 c0 00 st %l1, [ %i3 ]
20052a8: 81 c7 e0 08 ret
20052ac: 81 e8 00 00 restore
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20052b0: 92 04 20 48 add %l0, 0x48, %o1
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
20052b4: c2 24 20 68 st %g1, [ %l0 + 0x68 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20052b8: 03 00 80 15 sethi %hi(0x2005400), %g1
20052bc: 82 10 60 b0 or %g1, 0xb0, %g1 ! 20054b0 <_Event_Timeout>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20052c0: f4 24 20 54 st %i2, [ %l0 + 0x54 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20052c4: c2 24 20 64 st %g1, [ %l0 + 0x64 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20052c8: c0 24 20 50 clr [ %l0 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20052cc: c0 24 20 6c clr [ %l0 + 0x6c ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20052d0: 11 00 80 5d sethi %hi(0x2017400), %o0
20052d4: 40 00 0e df call 2008e50 <_Watchdog_Insert>
20052d8: 90 12 20 c4 or %o0, 0xc4, %o0 ! 20174c4 <_Watchdog_Ticks_chain>
NULL
);
_Watchdog_Insert_ticks( &executing->Timer, ticks );
}
_Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
20052dc: 90 10 00 10 mov %l0, %o0
20052e0: 40 00 0c c4 call 20085f0 <_Thread_Set_state>
20052e4: 92 10 21 00 mov 0x100, %o1
_ISR_Disable( level );
20052e8: 7f ff f2 bf call 2001de4 <sparc_disable_interrupts>
20052ec: 01 00 00 00 nop
sync_state = _Event_Sync_state;
20052f0: f0 04 62 b4 ld [ %l1 + 0x2b4 ], %i0
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
20052f4: c0 24 62 b4 clr [ %l1 + 0x2b4 ]
if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
20052f8: 80 a6 20 01 cmp %i0, 1
20052fc: 12 bf ff dd bne 2005270 <_Event_Seize+0x94>
2005300: b2 10 00 10 mov %l0, %i1
_ISR_Enable( level );
2005304: 7f ff f2 bc call 2001df4 <sparc_enable_interrupts>
2005308: 91 e8 00 08 restore %g0, %o0, %o0
02005368 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
2005368: 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 ];
200536c: f2 06 21 68 ld [ %i0 + 0x168 ], %i1
option_set = (rtems_option) the_thread->Wait.option;
_ISR_Disable( level );
2005370: 7f ff f2 9d call 2001de4 <sparc_disable_interrupts>
2005374: e2 06 20 30 ld [ %i0 + 0x30 ], %l1
2005378: a0 10 00 08 mov %o0, %l0
pending_events = api->pending_events;
200537c: c8 06 40 00 ld [ %i1 ], %g4
event_condition = (rtems_event_set) the_thread->Wait.count;
2005380: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
2005384: 9a 88 c0 04 andcc %g3, %g4, %o5
2005388: 02 80 00 28 be 2005428 <_Event_Surrender+0xc0>
200538c: 03 00 80 5d sethi %hi(0x2017400), %g1
/*
* 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() &&
2005390: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2017480 <_ISR_Nest_level>
2005394: 80 a0 a0 00 cmp %g2, 0
2005398: 22 80 00 08 be,a 20053b8 <_Event_Surrender+0x50>
200539c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20053a0: 03 00 80 5d sethi %hi(0x2017400), %g1
20053a4: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_Thread_Executing>
20053a8: 80 a6 00 02 cmp %i0, %g2
20053ac: 02 80 00 2a be 2005454 <_Event_Surrender+0xec>
20053b0: 19 00 80 5d sethi %hi(0x2017400), %o4
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
20053b4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20053b8: 80 88 61 00 btst 0x100, %g1
20053bc: 02 80 00 19 be 2005420 <_Event_Surrender+0xb8> <== NEVER TAKEN
20053c0: 80 a0 c0 0d cmp %g3, %o5
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
20053c4: 02 80 00 04 be 20053d4 <_Event_Surrender+0x6c>
20053c8: 80 8c 60 02 btst 2, %l1
20053cc: 02 80 00 15 be 2005420 <_Event_Surrender+0xb8> <== NEVER TAKEN
20053d0: 01 00 00 00 nop
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
20053d4: 82 29 00 0d andn %g4, %o5, %g1
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20053d8: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
/*
* 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 );
20053dc: c2 26 40 00 st %g1, [ %i1 ]
the_thread->Wait.count = 0;
20053e0: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20053e4: da 20 80 00 st %o5, [ %g2 ]
_ISR_Flash( level );
20053e8: 7f ff f2 83 call 2001df4 <sparc_enable_interrupts>
20053ec: 90 10 00 10 mov %l0, %o0
20053f0: 7f ff f2 7d call 2001de4 <sparc_disable_interrupts>
20053f4: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
20053f8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
20053fc: 80 a0 60 02 cmp %g1, 2
2005400: 02 80 00 0c be 2005430 <_Event_Surrender+0xc8>
2005404: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
2005408: 90 10 00 10 mov %l0, %o0
200540c: 7f ff f2 7a call 2001df4 <sparc_enable_interrupts>
2005410: 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 );
2005414: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
2005418: 40 00 08 bf call 2007714 <_Thread_Clear_state>
200541c: 81 e8 00 00 restore
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
2005420: 7f ff f2 75 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2005424: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
_ISR_Enable( level );
2005428: 7f ff f2 73 call 2001df4 <sparc_enable_interrupts>
200542c: 91 e8 00 08 restore %g0, %o0, %o0
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
2005430: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
2005434: 7f ff f2 70 call 2001df4 <sparc_enable_interrupts>
2005438: 90 10 00 10 mov %l0, %o0
(void) _Watchdog_Remove( &the_thread->Timer );
200543c: 40 00 0e f0 call 2008ffc <_Watchdog_Remove>
2005440: 90 06 20 48 add %i0, 0x48, %o0
2005444: 33 04 00 ff sethi %hi(0x1003fc00), %i1
2005448: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
200544c: 40 00 08 b2 call 2007714 <_Thread_Clear_state>
2005450: 81 e8 00 00 restore
/*
* 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() &&
2005454: c2 03 22 b4 ld [ %o4 + 0x2b4 ], %g1
2005458: 80 a0 60 01 cmp %g1, 1
200545c: 02 80 00 07 be 2005478 <_Event_Surrender+0x110>
2005460: 80 a0 c0 0d cmp %g3, %o5
2005464: c2 03 22 b4 ld [ %o4 + 0x2b4 ], %g1
2005468: 80 a0 60 02 cmp %g1, 2
200546c: 32 bf ff d3 bne,a 20053b8 <_Event_Surrender+0x50> <== ALWAYS TAKEN
2005470: c2 06 20 10 ld [ %i0 + 0x10 ], %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) ) {
2005474: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED
2005478: 02 80 00 04 be 2005488 <_Event_Surrender+0x120> <== ALWAYS TAKEN
200547c: 80 8c 60 02 btst 2, %l1
2005480: 02 80 00 09 be 20054a4 <_Event_Surrender+0x13c> <== NOT EXECUTED
2005484: 01 00 00 00 nop <== NOT EXECUTED
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
2005488: 82 29 00 0d andn %g4, %o5, %g1
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
200548c: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
if ( _ISR_Is_in_progress() &&
_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 );
2005490: c2 26 40 00 st %g1, [ %i1 ]
the_thread->Wait.count = 0;
2005494: c0 26 20 24 clr [ %i0 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
2005498: 82 10 20 03 mov 3, %g1
((_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;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
200549c: da 20 80 00 st %o5, [ %g2 ]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
20054a0: c2 23 22 b4 st %g1, [ %o4 + 0x2b4 ]
}
_ISR_Enable( level );
20054a4: 7f ff f2 54 call 2001df4 <sparc_enable_interrupts>
20054a8: 91 e8 00 10 restore %g0, %l0, %o0
020054b0 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
20054b0: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
20054b4: 90 10 00 18 mov %i0, %o0
20054b8: 40 00 09 be call 2007bb0 <_Thread_Get>
20054bc: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
20054c0: c2 07 bf f4 ld [ %fp + -12 ], %g1
20054c4: 80 a0 60 00 cmp %g1, 0
20054c8: 12 80 00 19 bne 200552c <_Event_Timeout+0x7c> <== NEVER TAKEN
20054cc: 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 );
20054d0: 7f ff f2 45 call 2001de4 <sparc_disable_interrupts>
20054d4: 01 00 00 00 nop
20054d8: 86 10 00 08 mov %o0, %g3
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
20054dc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
20054e0: 80 a0 60 00 cmp %g1, 0
20054e4: 02 80 00 14 be 2005534 <_Event_Timeout+0x84> <== NEVER TAKEN
20054e8: 03 00 80 5d sethi %hi(0x2017400), %g1
_ISR_Enable( level );
return;
}
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
20054ec: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_Thread_Executing>
20054f0: 80 a6 00 02 cmp %i0, %g2
20054f4: 02 80 00 18 be 2005554 <_Event_Timeout+0xa4>
20054f8: c0 26 20 24 clr [ %i0 + 0x24 ]
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
20054fc: 82 10 20 06 mov 6, %g1
2005500: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
_ISR_Enable( level );
2005504: 7f ff f2 3c call 2001df4 <sparc_enable_interrupts>
2005508: 90 10 00 03 mov %g3, %o0
200550c: 90 10 00 18 mov %i0, %o0
2005510: 13 04 00 ff sethi %hi(0x1003fc00), %o1
2005514: 40 00 08 80 call 2007714 <_Thread_Clear_state>
2005518: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
200551c: 05 00 80 5c sethi %hi(0x2017000), %g2
2005520: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level>
2005524: 82 00 7f ff add %g1, -1, %g1
2005528: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ]
200552c: 81 c7 e0 08 ret
2005530: 81 e8 00 00 restore
2005534: 05 00 80 5c sethi %hi(0x2017000), %g2 <== NOT EXECUTED
2005538: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
200553c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2005540: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ] <== NOT EXECUTED
_ISR_Disable( level );
if ( !the_thread->Wait.count ) { /* verify thread is waiting */
_Thread_Unnest_dispatch();
_ISR_Enable( level );
2005544: 7f ff f2 2c call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2005548: 01 00 00 00 nop <== NOT EXECUTED
200554c: 81 c7 e0 08 ret <== NOT EXECUTED
2005550: 81 e8 00 00 restore <== NOT EXECUTED
return;
}
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
Thread_blocking_operation_States sync = _Event_Sync_state;
2005554: 05 00 80 5d sethi %hi(0x2017400), %g2
2005558: c2 00 a2 b4 ld [ %g2 + 0x2b4 ], %g1 ! 20176b4 <_Event_Sync_state>
if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
200555c: 80 a0 60 01 cmp %g1, 1
2005560: 38 bf ff e8 bgu,a 2005500 <_Event_Timeout+0x50> <== NEVER TAKEN
2005564: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
(sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
2005568: 82 10 20 02 mov 2, %g1
200556c: c2 20 a2 b4 st %g1, [ %g2 + 0x2b4 ]
}
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
2005570: 10 bf ff e4 b 2005500 <_Event_Timeout+0x50>
2005574: 82 10 20 06 mov 6, %g1
0200ba6c <_Heap_Allocate>:
void *_Heap_Allocate(
Heap_Control *the_heap,
size_t size
)
{
200ba6c: 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 =
200ba70: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200ba74: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
200ba78: 90 10 00 19 mov %i1, %o0
200ba7c: 7f ff eb e4 call 2006a0c <_Heap_Calc_block_size>
200ba80: a0 10 00 18 mov %i0, %l0
_Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
if(the_size == 0)
200ba84: 80 a2 20 00 cmp %o0, 0
200ba88: 02 80 00 2c be 200bb38 <_Heap_Allocate+0xcc> <== NEVER TAKEN
200ba8c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
200ba90: f0 06 20 08 ld [ %i0 + 8 ], %i0
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
200ba94: 80 a4 00 18 cmp %l0, %i0
200ba98: 02 80 00 28 be 200bb38 <_Heap_Allocate+0xcc>
200ba9c: b2 10 20 00 clr %i1
/* 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) {
200baa0: c2 06 20 04 ld [ %i0 + 4 ], %g1
200baa4: 80 a2 00 01 cmp %o0, %g1
200baa8: 18 80 00 18 bgu 200bb08 <_Heap_Allocate+0x9c>
200baac: a2 10 20 00 clr %l1
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
200bab0: 94 10 00 08 mov %o0, %o2
200bab4: 92 10 00 18 mov %i0, %o1
200bab8: 7f ff eb e9 call 2006a5c <_Heap_Block_allocate>
200babc: 90 10 00 10 mov %l0, %o0
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
200bac0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
stats->searches += search_count + 1;
200bac4: 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;
200bac8: 82 00 60 01 inc %g1
stats->searches += search_count + 1;
200bacc: 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;
200bad0: c2 24 20 48 st %g1, [ %l0 + 0x48 ]
stats->searches += search_count + 1;
200bad4: 84 00 80 19 add %g2, %i1, %g2
200bad8: b0 06 20 08 add %i0, 8, %i0
200badc: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
200bae0: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
200bae4: 80 a0 40 11 cmp %g1, %l1
200bae8: 2a 80 00 02 bcs,a 200baf0 <_Heap_Allocate+0x84>
200baec: e2 24 20 44 st %l1, [ %l0 + 0x44 ]
stats->max_search = search_count;
return ptr;
}
200baf0: 81 c7 e0 08 ret
200baf4: 81 e8 00 00 restore
/* 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) {
200baf8: c2 06 20 04 ld [ %i0 + 4 ], %g1
200bafc: 80 a2 00 01 cmp %o0, %g1
200bb00: 08 80 00 10 bleu 200bb40 <_Heap_Allocate+0xd4>
200bb04: 94 10 00 08 mov %o0, %o2
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)
200bb08: f0 06 20 08 ld [ %i0 + 8 ], %i0
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
200bb0c: 80 a4 00 18 cmp %l0, %i0
200bb10: 12 bf ff fa bne 200baf8 <_Heap_Allocate+0x8c>
200bb14: b2 06 60 01 inc %i1
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
200bb18: c2 04 20 44 ld [ %l0 + 0x44 ], %g1
if(the_size == 0)
return NULL;
/* Find large enough free block. */
for(the_block = _Heap_First(the_heap), search_count = 0;
the_block != tail;
200bb1c: a2 10 00 19 mov %i1, %l1
_HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
break;
}
}
if(stats->max_search < search_count)
200bb20: 80 a0 40 11 cmp %g1, %l1
200bb24: 1a bf ff f3 bcc 200baf0 <_Heap_Allocate+0x84>
200bb28: b0 10 20 00 clr %i0
stats->max_search = search_count;
200bb2c: e2 24 20 44 st %l1, [ %l0 + 0x44 ]
200bb30: 81 c7 e0 08 ret
200bb34: 81 e8 00 00 restore
return ptr;
}
200bb38: 81 c7 e0 08 ret
200bb3c: 91 e8 20 00 restore %g0, 0, %o0
_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) {
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
200bb40: 92 10 00 18 mov %i0, %o1
200bb44: 7f ff eb c6 call 2006a5c <_Heap_Block_allocate>
200bb48: 90 10 00 10 mov %l0, %o0
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
200bb4c: c2 04 20 48 ld [ %l0 + 0x48 ], %g1
stats->searches += search_count + 1;
200bb50: 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;
200bb54: 82 00 60 01 inc %g1
stats->searches += search_count + 1;
200bb58: 84 00 a0 01 inc %g2
/* 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) {
200bb5c: a2 10 00 19 mov %i1, %l1
(void)_Heap_Block_allocate(the_heap, the_block, the_size );
ptr = _Heap_User_area(the_block);
stats->allocs += 1;
stats->searches += search_count + 1;
200bb60: 84 00 80 19 add %g2, %i1, %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;
200bb64: c2 24 20 48 st %g1, [ %l0 + 0x48 ]
stats->searches += search_count + 1;
200bb68: c4 24 20 4c st %g2, [ %l0 + 0x4c ]
200bb6c: 10 bf ff dd b 200bae0 <_Heap_Allocate+0x74>
200bb70: b0 06 20 08 add %i0, 8, %i0
02008b24 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
Heap_Control *the_heap,
size_t size,
uint32_t alignment
)
{
2008b24: 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;
2008b28: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
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);
2008b2c: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
2008b30: 90 10 00 19 mov %i1, %o0
2008b34: 92 10 00 16 mov %l6, %o1
2008b38: 40 00 01 82 call 2009140 <_Heap_Calc_block_size>
2008b3c: aa 10 00 18 mov %i0, %l5
if(the_size == 0)
2008b40: ae 92 20 00 orcc %o0, 0, %l7
2008b44: 02 80 00 69 be 2008ce8 <_Heap_Allocate_aligned+0x1c4> <== NEVER TAKEN
2008b48: b2 06 7f fc add %i1, -4, %i1
return NULL;
if(alignment == 0)
2008b4c: 80 a6 a0 00 cmp %i2, 0
2008b50: 22 80 00 02 be,a 2008b58 <_Heap_Allocate_aligned+0x34>
2008b54: b4 10 20 08 mov 8, %i2
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
2008b58: e2 05 60 08 ld [ %l5 + 8 ], %l1
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;
2008b5c: 80 a5 40 11 cmp %l5, %l1
2008b60: 02 80 00 62 be 2008ce8 <_Heap_Allocate_aligned+0x1c4> <== NEVER TAKEN
2008b64: a8 10 20 00 clr %l4
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
2008b68: c2 04 60 04 ld [ %l1 + 4 ], %g1
_H_uptr_t *value,
uint32_t alignment
)
{
_H_uptr_t v = *value;
*value = v - (v % alignment);
2008b6c: 92 10 00 1a mov %i2, %o1
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
2008b70: a4 08 7f fe and %g1, -2, %l2
/* 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;
2008b74: a6 04 40 12 add %l1, %l2, %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. */
2008b78: 80 a5 c0 12 cmp %l7, %l2
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;
aligned_user_addr = block_end - end_to_user_offs;
2008b7c: a0 24 c0 19 sub %l3, %i1, %l0
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. */
2008b80: 18 80 00 22 bgu 2008c08 <_Heap_Allocate_aligned+0xe4>
2008b84: 90 10 00 10 mov %l0, %o0
_H_uptr_t *value,
uint32_t alignment
)
{
_H_uptr_t v = *value;
*value = v - (v % alignment);
2008b88: 40 00 3d ae call 2018240 <.urem>
2008b8c: 01 00 00 00 nop
_H_uptr_t user_addr;
_H_uptr_t aligned_user_addr;
_H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block));
2008b90: 92 10 00 16 mov %l6, %o1
2008b94: b0 24 00 08 sub %l0, %o0, %i0
2008b98: 40 00 3d aa call 2018240 <.urem>
2008b9c: 90 10 00 18 mov %i0, %o0
2008ba0: a0 04 60 08 add %l1, 8, %l0
2008ba4: 84 26 00 08 sub %i0, %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) {
2008ba8: 80 a4 00 02 cmp %l0, %g2
2008bac: 38 80 00 18 bgu,a 2008c0c <_Heap_Allocate_aligned+0xe8>
2008bb0: 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) {
2008bb4: fa 05 60 14 ld [ %l5 + 0x14 ], %i5
2008bb8: 82 20 80 10 sub %g2, %l0, %g1
2008bbc: 80 a0 40 1d cmp %g1, %i5
2008bc0: 1a 80 00 1e bcc 2008c38 <_Heap_Allocate_aligned+0x114>
2008bc4: 80 a6 20 00 cmp %i0, 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) {
2008bc8: 82 26 00 10 sub %i0, %l0, %g1
uint32_t alignment
)
{
_H_uptr_t v = *value;
uint32_t a = alignment;
_H_uptr_t r = v % a;
2008bcc: 90 10 00 10 mov %l0, %o0
2008bd0: 92 10 00 1a mov %i2, %o1
2008bd4: 80 a5 80 01 cmp %l6, %g1
2008bd8: 18 80 00 17 bgu 2008c34 <_Heap_Allocate_aligned+0x110> <== ALWAYS TAKEN
2008bdc: 84 10 00 10 mov %l0, %g2
2008be0: 40 00 3d 98 call 2018240 <.urem> <== NOT EXECUTED
2008be4: 01 00 00 00 nop <== 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) {
2008be8: 84 10 00 10 mov %l0, %g2 <== NOT EXECUTED
*value = r ? v - r + a : v;
2008bec: 88 92 20 00 orcc %o0, 0, %g4 <== NOT EXECUTED
2008bf0: 86 10 20 00 clr %g3 <== NOT EXECUTED
2008bf4: 12 80 00 35 bne 2008cc8 <_Heap_Allocate_aligned+0x1a4> <== NOT EXECUTED
2008bf8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2008bfc: 80 a5 80 03 cmp %l6, %g3 <== NOT EXECUTED
2008c00: 38 80 00 0d bgu,a 2008c34 <_Heap_Allocate_aligned+0x110> <== NOT EXECUTED
2008c04: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* 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)
2008c08: e2 04 60 08 ld [ %l1 + 8 ], %l1
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;
2008c0c: 80 a5 40 11 cmp %l5, %l1
2008c10: 12 bf ff d6 bne 2008b68 <_Heap_Allocate_aligned+0x44>
2008c14: a8 05 20 01 inc %l4
2008c18: 90 10 20 00 clr %o0
}
}
}
}
if(stats->max_search < search_count)
2008c1c: c2 05 60 44 ld [ %l5 + 0x44 ], %g1
2008c20: 80 a0 40 14 cmp %g1, %l4
2008c24: 2a 80 00 02 bcs,a 2008c2c <_Heap_Allocate_aligned+0x108>
2008c28: e8 25 60 44 st %l4, [ %l5 + 0x44 ]
stats->max_search = search_count;
return user_ptr;
}
2008c2c: 81 c7 e0 08 ret
2008c30: 91 e8 00 08 restore %g0, %o0, %o0
aligned_user_addr = 0;
}
}
}
if(aligned_user_addr) {
2008c34: 80 a6 20 00 cmp %i0, 0
2008c38: 22 bf ff f5 be,a 2008c0c <_Heap_Allocate_aligned+0xe8> <== NEVER TAKEN
2008c3c: 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;
2008c40: 82 04 e0 08 add %l3, 8, %g1
2008c44: 88 20 40 02 sub %g1, %g2, %g4
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;
2008c48: 84 24 80 04 sub %l2, %g4, %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) {
2008c4c: 80 a0 80 1d cmp %g2, %i5
2008c50: 2a 80 00 29 bcs,a 2008cf4 <_Heap_Allocate_aligned+0x1d0>
2008c54: 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;
2008c58: 82 10 a0 01 or %g2, 1, %g1
2008c5c: 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);
2008c60: a2 04 40 02 add %l1, %g2, %l1
the_block = _Heap_Block_at(the_block, the_rest);
the_block->prev_size = the_rest;
2008c64: c4 24 40 00 st %g2, [ %l1 ]
the_block->size = alloc_size;
2008c68: c8 24 60 04 st %g4, [ %l1 + 4 ]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
2008c6c: 84 04 40 04 add %l1, %g4, %g2
_Heap_Block_remove(the_block);
alloc_size = block_size;
stats->free_blocks -= 1;
}
/* Mark the block as used (in the next block). */
_Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
2008c70: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2008c74: 82 10 60 01 or %g1, 1, %g1
2008c78: c2 20 a0 04 st %g1, [ %g2 + 4 ]
/* Update statistics */
stats->free_size -= alloc_size;
2008c7c: c6 05 60 30 ld [ %l5 + 0x30 ], %g3
if(stats->min_free_size > stats->free_size)
2008c80: c2 05 60 34 ld [ %l5 + 0x34 ], %g1
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;
2008c84: 86 20 c0 04 sub %g3, %g4, %g3
if(stats->min_free_size > stats->free_size)
2008c88: 80 a0 c0 01 cmp %g3, %g1
2008c8c: 1a 80 00 03 bcc 2008c98 <_Heap_Allocate_aligned+0x174>
2008c90: c6 25 60 30 st %g3, [ %l5 + 0x30 ]
stats->min_free_size = stats->free_size;
2008c94: c6 25 60 34 st %g3, [ %l5 + 0x34 ]
stats->used_blocks += 1;
2008c98: c2 05 60 40 ld [ %l5 + 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;
2008c9c: c6 05 60 4c ld [ %l5 + 0x4c ], %g3
stats->allocs += 1;
2008ca0: c4 05 60 48 ld [ %l5 + 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;
2008ca4: 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;
2008ca8: 86 00 e0 01 inc %g3
stats->allocs += 1;
2008cac: 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;
2008cb0: 86 00 c0 14 add %g3, %l4, %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;
2008cb4: c2 25 60 40 st %g1, [ %l5 + 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;
2008cb8: c4 25 60 48 st %g2, [ %l5 + 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;
2008cbc: c6 25 60 4c st %g3, [ %l5 + 0x4c ]
stats->allocs += 1;
check_result(the_heap, the_block, user_addr,
aligned_user_addr, size);
user_ptr = (void*)aligned_user_addr;
2008cc0: 10 bf ff d7 b 2008c1c <_Heap_Allocate_aligned+0xf8>
2008cc4: 90 10 00 18 mov %i0, %o0
)
{
_H_uptr_t v = *value;
uint32_t a = alignment;
_H_uptr_t r = v % a;
*value = r ? v - r + a : v;
2008cc8: 82 04 00 1a add %l0, %i2, %g1 <== NOT EXECUTED
2008ccc: 90 20 40 04 sub %g1, %g4, %o0 <== NOT EXECUTED
2008cd0: 86 22 00 10 sub %o0, %l0, %g3 <== 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) {
2008cd4: 80 a5 80 03 cmp %l6, %g3 <== NOT EXECUTED
2008cd8: 28 bf ff cd bleu,a 2008c0c <_Heap_Allocate_aligned+0xe8> <== NOT EXECUTED
2008cdc: e2 04 60 08 ld [ %l1 + 8 ], %l1 <== NOT EXECUTED
2008ce0: 10 bf ff d5 b 2008c34 <_Heap_Allocate_aligned+0x110> <== NOT EXECUTED
2008ce4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
}
if(stats->max_search < search_count)
stats->max_search = search_count;
2008ce8: 90 10 20 00 clr %o0 <== NOT EXECUTED
return user_ptr;
}
2008cec: 81 c7 e0 08 ret <== NOT EXECUTED
2008cf0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
2008cf4: 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;
2008cf8: c2 05 60 38 ld [ %l5 + 0x38 ], %g1
prev->next = next;
next->prev = prev;
2008cfc: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
2008d00: 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;
2008d04: c6 20 a0 08 st %g3, [ %g2 + 8 ]
2008d08: c2 25 60 38 st %g1, [ %l5 + 0x38 ]
2008d0c: 10 bf ff d8 b 2008c6c <_Heap_Allocate_aligned+0x148>
2008d10: 88 10 00 12 mov %l2, %g4
0200e4dc <_Heap_Extend>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t *amount_extended
)
{
200e4dc: 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 */
200e4e0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200e4e4: 80 a0 40 19 cmp %g1, %i1
200e4e8: 08 80 00 08 bleu 200e508 <_Heap_Extend+0x2c>
200e4ec: a2 10 00 18 mov %i0, %l1
200e4f0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
200e4f4: 80 a6 40 01 cmp %i1, %g1
200e4f8: 02 80 00 0b be 200e524 <_Heap_Extend+0x48> <== NEVER TAKEN
200e4fc: b0 10 20 02 mov 2, %i0
stats->frees -= 1; /* Don't count subsequent call as actual free() */
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
return HEAP_EXTEND_SUCCESSFUL;
}
200e500: 81 c7 e0 08 ret
200e504: 81 e8 00 00 restore
* 5. non-contiguous higher address (NOT SUPPORTED)
*
* As noted, this code only supports (4).
*/
if ( starting_address >= the_heap->begin && /* case 3 */
200e508: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
200e50c: 80 a6 40 01 cmp %i1, %g1
200e510: 0a bf ff fc bcs 200e500 <_Heap_Extend+0x24>
200e514: b0 10 20 01 mov 1, %i0
starting_address < the_heap->end
)
return HEAP_EXTEND_ERROR;
if ( starting_address != the_heap->end )
200e518: 80 a6 40 01 cmp %i1, %g1
200e51c: 12 bf ff f9 bne 200e500 <_Heap_Extend+0x24>
200e520: b0 10 20 02 mov 2, %i0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
200e524: 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;
200e528: e4 04 60 24 ld [ %l1 + 0x24 ], %l2
200e52c: 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;
200e530: 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 );
200e534: c2 24 60 1c st %g1, [ %l1 + 0x1c ]
the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
200e538: a0 04 3f f8 add %l0, -8, %l0
200e53c: 40 00 27 41 call 2018240 <.urem>
200e540: 90 10 00 10 mov %l0, %o0
_Heap_Align_down( &the_size, the_heap->page_size );
*amount_extended = size;
200e544: f4 26 c0 00 st %i2, [ %i3 ]
if( the_size < the_heap->min_block_size )
200e548: c2 04 60 14 ld [ %l1 + 0x14 ], %g1
200e54c: a0 24 00 08 sub %l0, %o0, %l0
200e550: 80 a0 40 10 cmp %g1, %l0
200e554: 18 bf ff eb bgu 200e500 <_Heap_Extend+0x24> <== NEVER TAKEN
200e558: b0 10 20 00 clr %i0
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
200e55c: c2 04 a0 04 ld [ %l2 + 4 ], %g1
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
200e560: 84 10 20 01 mov 1, %g2
*amount_extended = size;
if( the_size < the_heap->min_block_size )
return HEAP_EXTEND_SUCCESSFUL;
old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
200e564: 82 08 60 01 and %g1, 1, %g1
200e568: 82 14 00 01 or %l0, %g1, %g1
200e56c: c2 24 a0 04 st %g1, [ %l2 + 4 ]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
200e570: 88 04 80 10 add %l2, %l0, %g4
new_final = _Heap_Block_at( old_final, the_size );
new_final->size = HEAP_PREV_USED;
200e574: c4 21 20 04 st %g2, [ %g4 + 4 ]
the_heap->final = new_final;
stats->size += size;
200e578: c2 04 60 2c ld [ %l1 + 0x2c ], %g1
stats->used_blocks += 1;
200e57c: c4 04 60 40 ld [ %l1 + 0x40 ], %g2
stats->frees -= 1; /* Don't count subsequent call as actual free() */
200e580: 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;
200e584: 82 00 40 1a add %g1, %i2, %g1
stats->used_blocks += 1;
200e588: 84 00 a0 01 inc %g2
stats->frees -= 1; /* Don't count subsequent call as actual free() */
200e58c: 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;
200e590: c8 24 60 24 st %g4, [ %l1 + 0x24 ]
stats->size += size;
200e594: c2 24 60 2c st %g1, [ %l1 + 0x2c ]
stats->used_blocks += 1;
200e598: c4 24 60 40 st %g2, [ %l1 + 0x40 ]
stats->frees -= 1; /* Don't count subsequent call as actual free() */
200e59c: c6 24 60 50 st %g3, [ %l1 + 0x50 ]
_Heap_Free( the_heap, _Heap_User_area( old_final ) );
200e5a0: 90 10 00 11 mov %l1, %o0
200e5a4: 7f ff ea 1e call 2008e1c <_Heap_Free>
200e5a8: 92 04 a0 08 add %l2, 8, %o1
return HEAP_EXTEND_SUCCESSFUL;
}
200e5ac: 81 c7 e0 08 ret
200e5b0: 81 e8 00 00 restore
0200bb74 <_Heap_Free>:
bool _Heap_Free(
Heap_Control *the_heap,
void *starting_address
)
{
200bb74: 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(
200bb78: e4 06 20 20 ld [ %i0 + 0x20 ], %l2
200bb7c: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
200bb80: 80 a6 40 12 cmp %i1, %l2
200bb84: 84 60 3f ff subx %g0, -1, %g2
200bb88: 80 a4 40 19 cmp %l1, %i1
200bb8c: 82 60 3f ff subx %g0, -1, %g1
200bb90: 80 88 80 01 btst %g2, %g1
200bb94: 02 80 00 42 be 200bc9c <_Heap_Free+0x128>
200bb98: 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);
200bb9c: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200bba0: 40 00 20 20 call 2013c20 <.urem>
200bba4: 90 10 00 19 mov %i1, %o0
200bba8: a0 06 7f f8 add %i1, -8, %l0
200bbac: 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 ) ) {
200bbb0: 80 a2 00 12 cmp %o0, %l2
200bbb4: 84 60 3f ff subx %g0, -1, %g2
200bbb8: 80 a4 40 08 cmp %l1, %o0
200bbbc: 82 60 3f ff subx %g0, -1, %g1
200bbc0: 80 88 80 01 btst %g2, %g1
200bbc4: 02 80 00 36 be 200bc9c <_Heap_Free+0x128> <== NEVER TAKEN
200bbc8: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
200bbcc: c6 02 20 04 ld [ %o0 + 4 ], %g3
200bbd0: 9a 08 ff fe and %g3, -2, %o5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
200bbd4: 88 02 00 0d add %o0, %o5, %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 ) ) {
200bbd8: 80 a1 00 12 cmp %g4, %l2
200bbdc: 84 60 3f ff subx %g0, -1, %g2
200bbe0: 80 a4 40 04 cmp %l1, %g4
200bbe4: 82 60 3f ff subx %g0, -1, %g1
200bbe8: 80 88 80 01 btst %g2, %g1
200bbec: 02 80 00 2c be 200bc9c <_Heap_Free+0x128> <== NEVER TAKEN
200bbf0: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
200bbf4: c2 01 20 04 ld [ %g4 + 4 ], %g1
_HAssert( FALSE );
return( FALSE );
}
if ( !_Heap_Is_prev_used( next_block ) ) {
200bbf8: 80 88 60 01 btst 1, %g1
200bbfc: 02 80 00 28 be 200bc9c <_Heap_Free+0x128> <== NEVER TAKEN
200bc00: 92 08 7f fe and %g1, -2, %o1
_HAssert( FALSE );
return( FALSE );
}
next_size = _Heap_Block_size( next_block );
next_is_free = next_block < the_heap->final &&
200bc04: 80 a4 40 04 cmp %l1, %g4
200bc08: 08 80 00 06 bleu 200bc20 <_Heap_Free+0xac>
200bc0c: 98 10 20 00 clr %o4
200bc10: 84 01 00 09 add %g4, %o1, %g2
200bc14: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200bc18: 82 18 60 01 xor %g1, 1, %g1
200bc1c: 98 08 60 01 and %g1, 1, %o4
!_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));
if ( !_Heap_Is_prev_used( the_block ) ) {
200bc20: 80 88 e0 01 btst 1, %g3
200bc24: 12 80 00 20 bne 200bca4 <_Heap_Free+0x130>
200bc28: 80 8b 20 ff btst 0xff, %o4
uint32_t const prev_size = the_block->prev_size;
200bc2c: d4 02 00 00 ld [ %o0 ], %o2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
200bc30: 96 22 00 0a sub %o0, %o2, %o3
Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );
if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
200bc34: 80 a2 c0 12 cmp %o3, %l2
200bc38: 84 60 3f ff subx %g0, -1, %g2
200bc3c: 80 a4 40 0b cmp %l1, %o3
200bc40: 82 60 3f ff subx %g0, -1, %g1
200bc44: 80 88 80 01 btst %g2, %g1
200bc48: 02 80 00 15 be 200bc9c <_Heap_Free+0x128> <== NEVER TAKEN
200bc4c: 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) ) {
200bc50: c2 02 e0 04 ld [ %o3 + 4 ], %g1
200bc54: 80 88 60 01 btst 1, %g1
200bc58: 02 80 00 11 be 200bc9c <_Heap_Free+0x128> <== NEVER TAKEN
200bc5c: 80 8b 20 ff btst 0xff, %o4
_HAssert( FALSE );
return( FALSE );
}
if ( next_is_free ) { /* coalesce both */
200bc60: 02 80 00 3a be 200bd48 <_Heap_Free+0x1d4>
200bc64: 86 03 40 0a add %o5, %o2, %g3
uint32_t const size = the_size + prev_size + next_size;
_Heap_Block_remove( next_block );
stats->free_blocks -= 1;
200bc68: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
200bc6c: c6 01 20 0c ld [ %g4 + 0xc ], %g3
Heap_Block *the_block
)
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
200bc70: c4 01 20 08 ld [ %g4 + 8 ], %g2
200bc74: 82 00 7f ff add %g1, -1, %g1
200bc78: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
Heap_Block *prev = block->prev;
prev->next = next;
next->prev = prev;
200bc7c: 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;
200bc80: 82 03 40 09 add %o5, %o1, %g1
{
Heap_Block *block = the_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
prev->next = next;
200bc84: c4 20 e0 08 st %g2, [ %g3 + 8 ]
200bc88: 82 00 40 0a add %g1, %o2, %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;
200bc8c: c2 22 c0 01 st %g1, [ %o3 + %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;
200bc90: 82 10 60 01 or %g1, 1, %g1
200bc94: 10 80 00 10 b 200bcd4 <_Heap_Free+0x160>
200bc98: c2 22 e0 04 st %g1, [ %o3 + 4 ]
stats->used_blocks -= 1;
stats->free_size += the_size;
stats->frees += 1;
return( TRUE );
}
200bc9c: 81 c7 e0 08 ret
200bca0: 91 e8 20 00 restore %g0, 0, %o0
prev_block->size = size | HEAP_PREV_USED;
next_block->size &= ~HEAP_PREV_USED;
next_block->prev_size = size;
}
}
else if ( next_is_free ) { /* coalesce next */
200bca4: 02 80 00 17 be 200bd00 <_Heap_Free+0x18c>
200bca8: 82 13 60 01 or %o5, 1, %g1
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
200bcac: 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;
200bcb0: c4 01 20 08 ld [ %g4 + 8 ], %g2
Heap_Block *prev = block->prev;
block = new_block;
block->next = next;
block->prev = prev;
200bcb4: 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;
200bcb8: c4 22 20 08 st %g2, [ %o0 + 8 ]
block->prev = prev;
next->prev = prev->next = block;
200bcbc: d0 20 60 08 st %o0, [ %g1 + 8 ]
200bcc0: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
uint32_t const size = the_size + next_size;
200bcc4: 82 02 40 0d add %o1, %o5, %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;
200bcc8: 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;
200bccc: 82 10 60 01 or %g1, 1, %g1
200bcd0: c2 22 20 04 st %g1, [ %o0 + 4 ]
stats->free_blocks += 1;
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
200bcd4: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
stats->free_size += the_size;
200bcd8: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
stats->frees += 1;
200bcdc: 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;
200bce0: 84 00 80 0d add %g2, %o5, %g2
stats->free_blocks += 1;
if ( stats->max_free_blocks < stats->free_blocks )
stats->max_free_blocks = stats->free_blocks;
}
stats->used_blocks -= 1;
200bce4: 82 00 7f ff add %g1, -1, %g1
stats->free_size += the_size;
200bce8: 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;
200bcec: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
stats->free_size += the_size;
stats->frees += 1;
200bcf0: 86 00 e0 01 inc %g3
200bcf4: c6 26 20 50 st %g3, [ %i0 + 0x50 ]
200bcf8: 81 c7 e0 08 ret
200bcfc: 91 e8 20 01 restore %g0, 1, %o0
}
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;
200bd00: c2 22 20 04 st %g1, [ %o0 + 4 ]
next_block->size &= ~HEAP_PREV_USED;
200bd04: c4 01 20 04 ld [ %g4 + 4 ], %g2
)
{
Heap_Block *prev = prev_block;
Heap_Block *block = the_block;
Heap_Block *next = prev->next;
200bd08: c6 06 20 08 ld [ %i0 + 8 ], %g3
next_block->prev_size = the_size;
200bd0c: da 22 00 0d st %o5, [ %o0 + %o5 ]
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;
200bd10: 84 08 bf fe and %g2, -2, %g2
200bd14: c4 21 20 04 st %g2, [ %g4 + 4 ]
next_block->prev_size = the_size;
stats->free_blocks += 1;
200bd18: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
block->next = next;
200bd1c: c6 22 20 08 st %g3, [ %o0 + 8 ]
block->prev = prev;
200bd20: f0 22 20 0c st %i0, [ %o0 + 0xc ]
if ( stats->max_free_blocks < stats->free_blocks )
200bd24: 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;
200bd28: 82 00 60 01 inc %g1
next->prev = prev->next = block;
200bd2c: d0 20 e0 0c st %o0, [ %g3 + 0xc ]
200bd30: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks )
200bd34: 80 a0 40 02 cmp %g1, %g2
200bd38: 08 bf ff e7 bleu 200bcd4 <_Heap_Free+0x160>
200bd3c: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200bd40: 10 bf ff e5 b 200bcd4 <_Heap_Free+0x160>
200bd44: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_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;
200bd48: 84 10 e0 01 or %g3, 1, %g2
200bd4c: c4 22 e0 04 st %g2, [ %o3 + 4 ]
next_block->size &= ~HEAP_PREV_USED;
200bd50: c2 01 20 04 ld [ %g4 + 4 ], %g1
next_block->prev_size = size;
200bd54: c6 22 00 0d st %g3, [ %o0 + %o5 ]
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;
200bd58: 82 08 7f fe and %g1, -2, %g1
200bd5c: 10 bf ff de b 200bcd4 <_Heap_Free+0x160>
200bd60: c2 21 20 04 st %g1, [ %g4 + 4 ]
0200e5b4 <_Heap_Get_free_information>:
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
200e5b4: da 02 20 08 ld [ %o0 + 8 ], %o5
)
{
Heap_Block *the_block;
Heap_Block *const tail = _Heap_Tail(the_heap);
info->number = 0;
200e5b8: c0 22 40 00 clr [ %o1 ]
info->largest = 0;
200e5bc: c0 22 60 04 clr [ %o1 + 4 ]
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
200e5c0: 80 a2 00 0d cmp %o0, %o5
200e5c4: 02 80 00 12 be 200e60c <_Heap_Get_free_information+0x58> <== NEVER TAKEN
200e5c8: c0 22 60 08 clr [ %o1 + 8 ]
200e5cc: 88 10 20 00 clr %g4
200e5d0: 86 10 20 00 clr %g3
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
200e5d4: c2 03 60 04 ld [ %o5 + 4 ], %g1
/* As we always coalesce free blocks, prev block must have been used. */
_HAssert(_Heap_Is_prev_used(the_block));
info->number++;
info->total += the_size;
if ( info->largest < the_size )
200e5d8: c4 02 60 04 ld [ %o1 + 4 ], %g2
200e5dc: 82 08 7f fe and %g1, -2, %g1
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++;
200e5e0: 88 01 20 01 inc %g4
info->total += the_size;
200e5e4: 86 00 c0 01 add %g3, %g1, %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++;
200e5e8: c8 22 40 00 st %g4, [ %o1 ]
info->total += the_size;
if ( info->largest < the_size )
200e5ec: 80 a0 80 01 cmp %g2, %g1
200e5f0: 1a 80 00 03 bcc 200e5fc <_Heap_Get_free_information+0x48> <== NEVER TAKEN
200e5f4: c6 22 60 08 st %g3, [ %o1 + 8 ]
info->largest = the_size;
200e5f8: c2 22 60 04 st %g1, [ %o1 + 4 ]
info->largest = 0;
info->total = 0;
for(the_block = _Heap_First(the_heap);
the_block != tail;
the_block = the_block->next)
200e5fc: 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;
200e600: 80 a2 00 0d cmp %o0, %o5
200e604: 32 bf ff f5 bne,a 200e5d8 <_Heap_Get_free_information+0x24>
200e608: c2 03 60 04 ld [ %o5 + 4 ], %g1
200e60c: 81 c3 e0 08 retl
0200e614 <_Heap_Get_information>:
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
Heap_Block *the_block = the_heap->start;
Heap_Block *const end = the_heap->final;
200e614: d6 02 20 24 ld [ %o0 + 0x24 ], %o3
Heap_Get_information_status _Heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
Heap_Block *the_block = the_heap->start;
200e618: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
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;
200e61c: c0 22 40 00 clr [ %o1 ]
the_info->Free.total = 0;
200e620: c0 22 60 08 clr [ %o1 + 8 ]
the_info->Free.largest = 0;
200e624: c0 22 60 04 clr [ %o1 + 4 ]
the_info->Used.number = 0;
200e628: c0 22 60 0c clr [ %o1 + 0xc ]
the_info->Used.total = 0;
200e62c: c0 22 60 14 clr [ %o1 + 0x14 ]
the_info->Used.largest = 0;
while ( the_block != end ) {
200e630: 80 a0 40 0b cmp %g1, %o3
200e634: 02 80 00 26 be 200e6cc <_Heap_Get_information+0xb8> <== NEVER TAKEN
200e638: c0 22 60 10 clr [ %o1 + 0x10 ]
200e63c: 10 80 00 0e b 200e674 <_Heap_Get_information+0x60>
200e640: d8 00 60 04 ld [ %g1 + 4 ], %o4
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++;
the_info->Used.total += the_size;
200e644: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
if ( the_info->Used.largest < the_size )
200e648: 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++;
200e64c: 82 00 60 01 inc %g1
the_info->Used.total += the_size;
200e650: 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++;
200e654: c2 22 60 0c st %g1, [ %o1 + 0xc ]
the_info->Used.total += the_size;
if ( the_info->Used.largest < the_size )
200e658: 80 a0 c0 04 cmp %g3, %g4
200e65c: 1a 80 00 03 bcc 200e668 <_Heap_Get_information+0x54>
200e660: c4 22 60 14 st %g2, [ %o1 + 0x14 ]
the_info->Used.largest = the_size;
200e664: c8 22 60 10 st %g4, [ %o1 + 0x10 ]
the_info->Free.largest = 0;
the_info->Used.number = 0;
the_info->Used.total = 0;
the_info->Used.largest = 0;
while ( the_block != end ) {
200e668: 80 a2 c0 0d cmp %o3, %o5
200e66c: 02 80 00 18 be 200e6cc <_Heap_Get_information+0xb8>
200e670: 82 10 00 0d mov %o5, %g1
200e674: 88 0b 3f fe and %o4, -2, %g4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
200e678: 9a 00 40 04 add %g1, %g4, %o5
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
200e67c: d8 03 60 04 ld [ %o5 + 4 ], %o4
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) ) {
200e680: 80 8b 20 01 btst 1, %o4
200e684: 32 bf ff f0 bne,a 200e644 <_Heap_Get_information+0x30>
200e688: c2 02 60 0c ld [ %o1 + 0xc ], %g1
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++;
200e68c: c2 02 40 00 ld [ %o1 ], %g1
the_info->Free.total += the_size;
200e690: c4 02 60 08 ld [ %o1 + 8 ], %g2
if ( the_info->Free.largest < the_size )
200e694: 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++;
200e698: 82 00 60 01 inc %g1
the_info->Free.total += the_size;
200e69c: 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++;
200e6a0: c2 22 40 00 st %g1, [ %o1 ]
the_info->Free.total += the_size;
if ( the_info->Free.largest < the_size )
200e6a4: 80 a0 c0 04 cmp %g3, %g4
200e6a8: 1a 80 00 03 bcc 200e6b4 <_Heap_Get_information+0xa0> <== NEVER TAKEN
200e6ac: c4 22 60 08 st %g2, [ %o1 + 8 ]
the_info->Free.largest = the_size;
200e6b0: c8 22 60 04 st %g4, [ %o1 + 4 ]
if ( the_size != next_block->prev_size )
200e6b4: c2 03 40 00 ld [ %o5 ], %g1
200e6b8: 80 a0 40 04 cmp %g1, %g4
200e6bc: 02 bf ff ec be 200e66c <_Heap_Get_information+0x58> <== ALWAYS TAKEN
200e6c0: 80 a2 c0 0d cmp %o3, %o5
200e6c4: 81 c3 e0 08 retl <== NOT EXECUTED
200e6c8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
}
/* 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;
200e6cc: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
200e6d0: 90 10 20 00 clr %o0
200e6d4: 82 00 60 08 add %g1, 8, %g1
return HEAP_GET_INFORMATION_SUCCESSFUL;
}
200e6d8: 81 c3 e0 08 retl
200e6dc: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
020068d8 <_Heap_Initialize>:
Heap_Control *the_heap,
void *starting_address,
size_t size,
uint32_t page_size
)
{
20068d8: 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)
20068dc: 80 a6 e0 00 cmp %i3, 0
20068e0: 12 80 00 43 bne 20069ec <_Heap_Initialize+0x114>
20068e4: 84 8e e0 07 andcc %i3, 7, %g2
20068e8: b6 10 20 08 mov 8, %i3
20068ec: a2 10 20 00 clr %l1
/* 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;
20068f0: 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;
20068f4: 92 10 00 1b mov %i3, %o1
20068f8: 40 00 34 ca call 2013c20 <.urem>
20068fc: 90 10 00 10 mov %l0, %o0
*value = r ? v - r + a : v;
2006900: 80 a2 20 00 cmp %o0, 0
2006904: 22 80 00 05 be,a 2006918 <_Heap_Initialize+0x40>
2006908: 82 06 e0 10 add %i3, 0x10, %g1
200690c: 82 06 c0 10 add %i3, %l0, %g1
2006910: a0 20 40 08 sub %g1, %o0, %l0
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
*value = r ? v - r + a : v;
2006914: 82 06 e0 10 add %i3, 0x10, %g1
2006918: 80 a4 60 00 cmp %l1, 0
_Heap_Align_up_uptr ( &aligned_start, page_size );
aligned_start -= HEAP_BLOCK_USER_OFFSET;
200691c: a4 04 3f f8 add %l0, -8, %l2
2006920: 12 80 00 03 bne 200692c <_Heap_Initialize+0x54>
2006924: 82 20 40 11 sub %g1, %l1, %g1
2006928: 82 10 20 10 mov 0x10, %g1
200692c: 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);
2006930: 82 24 80 19 sub %l2, %i1, %g1
2006934: 82 00 60 08 add %g1, 8, %g1
if ( size < overhead )
2006938: 80 a0 40 1a cmp %g1, %i2
200693c: 18 80 00 2a bgu 20069e4 <_Heap_Initialize+0x10c> <== NEVER TAKEN
2006940: a0 26 80 01 sub %i2, %g1, %l0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
2006944: 92 10 00 1b mov %i3, %o1
2006948: 40 00 34 b6 call 2013c20 <.urem>
200694c: 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 )
2006950: a0 a4 00 08 subcc %l0, %o0, %l0
2006954: 02 80 00 24 be 20069e4 <_Heap_Initialize+0x10c>
2006958: 09 00 80 5c sethi %hi(0x2017000), %g4
return 0; /* Too small area for the heap */
the_heap->page_size = page_size;
200695c: 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;
2006960: f6 24 80 00 st %i3, [ %l2 ]
the_block->size = the_size | HEAP_PREV_USED;
2006964: 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++;
2006968: c6 01 20 b4 ld [ %g4 + 0xb4 ], %g3
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;
200696c: c2 24 a0 04 st %g1, [ %l2 + 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 */
2006970: e0 24 80 10 st %l0, [ %l2 + %l0 ]
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
void *base,
uint32_t offset
)
{
return (void *)((char *)base + offset);
2006974: 9a 04 80 10 add %l2, %l0, %o5
the_block->size = page_size;
2006978: f6 23 60 04 st %i3, [ %o5 + 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 );
200697c: f0 24 a0 08 st %i0, [ %l2 + 8 ]
the_block->prev = _Heap_Head( the_heap );
2006980: f0 24 a0 0c st %i0, [ %l2 + 0xc ]
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
2006984: c6 26 20 28 st %g3, [ %i0 + 0x28 ]
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;
2006988: f4 26 20 2c st %i2, [ %i0 + 0x2c ]
stats->free_size = the_size;
200698c: e0 26 20 30 st %l0, [ %i0 + 0x30 ]
stats->min_free_size = the_size;
2006990: e0 26 20 34 st %l0, [ %i0 + 0x34 ]
stats->free_blocks = 1;
stats->max_free_blocks = 1;
stats->used_blocks = 0;
2006994: c0 26 20 40 clr [ %i0 + 0x40 ]
stats->max_search = 0;
2006998: c0 26 20 44 clr [ %i0 + 0x44 ]
stats->allocs = 0;
200699c: c0 26 20 48 clr [ %i0 + 0x48 ]
stats->searches = 0;
20069a0: c0 26 20 4c clr [ %i0 + 0x4c ]
stats->frees = 0;
20069a4: c0 26 20 50 clr [ %i0 + 0x50 ]
stats->resizes = 0;
20069a8: c0 26 20 54 clr [ %i0 + 0x54 ]
the_block->size = page_size;
stats->size = size;
stats->free_size = the_size;
stats->min_free_size = the_size;
stats->free_blocks = 1;
20069ac: 84 10 20 01 mov 1, %g2
stats->max_free_blocks = 1;
20069b0: c4 26 20 3c st %g2, [ %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;
20069b4: c4 26 20 38 st %g2, [ %i0 + 0x38 ]
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;
20069b8: 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++;
20069bc: 86 00 e0 01 inc %g3
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;
20069c0: 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;
20069c4: 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;
20069c8: e4 26 20 08 st %l2, [ %i0 + 8 ]
_Heap_Tail(the_heap)->prev = the_block;
20069cc: e4 26 20 0c st %l2, [ %i0 + 0xc ]
the_heap->start = the_block;
20069d0: e4 26 20 20 st %l2, [ %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 */
20069d4: da 26 20 24 st %o5, [ %i0 + 0x24 ]
stats->max_search = 0;
stats->allocs = 0;
stats->searches = 0;
stats->frees = 0;
stats->resizes = 0;
stats->instance = instance++;
20069d8: c6 21 20 b4 st %g3, [ %g4 + 0xb4 ]
return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
20069dc: 81 c7 e0 08 ret
20069e0: 91 ec 3f fc restore %l0, -4, %o0
}
20069e4: 81 c7 e0 08 ret
20069e8: 91 e8 20 00 restore %g0, 0, %o0
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
*value = r ? v - r + a : v;
20069ec: 02 80 00 04 be 20069fc <_Heap_Initialize+0x124>
20069f0: 90 10 20 10 mov 0x10, %o0
20069f4: 82 06 e0 08 add %i3, 8, %g1
20069f8: b6 20 40 02 sub %g1, %g2, %i3
20069fc: 40 00 34 89 call 2013c20 <.urem>
2006a00: 92 10 00 1b mov %i3, %o1
2006a04: 10 bf ff bb b 20068f0 <_Heap_Initialize+0x18>
2006a08: a2 10 00 08 mov %o0, %l1
02014dd0 <_Heap_Resize_block>:
void *starting_address,
size_t size,
uint32_t *old_mem_size,
uint32_t *avail_mem_size
)
{
2014dd0: 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;
2014dd4: ec 06 20 14 ld [ %i0 + 0x14 ], %l6
uint32_t const page_size = the_heap->page_size;
2014dd8: ea 06 20 10 ld [ %i0 + 0x10 ], %l5
*old_mem_size = 0;
2014ddc: c0 26 c0 00 clr [ %i3 ]
*avail_mem_size = 0;
2014de0: 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);
2014de4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
2014de8: 7f ff fb 8e call 2013c20 <.urem>
2014dec: 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 );
2014df0: c8 06 20 20 ld [ %i0 + 0x20 ], %g4
2014df4: 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);
2014df8: 82 06 7f f8 add %i1, -8, %g1
2014dfc: a2 20 40 08 sub %g1, %o0, %l1
_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))
2014e00: 80 a4 40 04 cmp %l1, %g4
2014e04: 84 60 3f ff subx %g0, -1, %g2
2014e08: 80 a0 c0 11 cmp %g3, %l1
2014e0c: 82 60 3f ff subx %g0, -1, %g1
2014e10: 80 88 80 01 btst %g2, %g1
2014e14: 02 80 00 2f be 2014ed0 <_Heap_Resize_block+0x100>
2014e18: a6 10 00 18 mov %i0, %l3
return HEAP_RESIZE_FATAL_ERROR;
prev_used_flag = the_block->size & HEAP_PREV_USED;
2014e1c: da 04 60 04 ld [ %l1 + 4 ], %o5
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
2014e20: b0 0b 7f fe and %o5, -2, %i0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
2014e24: a4 04 40 18 add %l1, %i0, %l2
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) ||
2014e28: 80 a4 80 04 cmp %l2, %g4
2014e2c: 84 60 3f ff subx %g0, -1, %g2
2014e30: 80 a0 c0 12 cmp %g3, %l2
2014e34: 82 60 3f ff subx %g0, -1, %g1
2014e38: 80 88 80 01 btst %g2, %g1
2014e3c: 02 80 00 25 be 2014ed0 <_Heap_Resize_block+0x100> <== NEVER TAKEN
2014e40: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
2014e44: c2 04 a0 04 ld [ %l2 + 4 ], %g1
2014e48: 80 88 60 01 btst 1, %g1
2014e4c: 02 80 00 21 be 2014ed0 <_Heap_Resize_block+0x100> <== NEVER TAKEN
2014e50: ae 08 7f fe and %g1, -2, %l7
!_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) ||
2014e54: 80 a0 c0 12 cmp %g3, %l2
2014e58: a8 10 20 01 mov 1, %l4
2014e5c: 02 80 00 04 be 2014e6c <_Heap_Resize_block+0x9c> <== NEVER TAKEN
2014e60: 82 04 80 17 add %l2, %l7, %g1
2014e64: c2 00 60 04 ld [ %g1 + 4 ], %g1
2014e68: a8 08 60 01 and %g1, 1, %l4
_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)
2014e6c: 82 24 80 19 sub %l2, %i1, %g1
2014e70: 82 00 60 04 add %g1, 4, %g1
+ HEAP_BLOCK_HEADER_OFFSET;
*old_mem_size = old_user_size;
2014e74: c2 26 c0 00 st %g1, [ %i3 ]
if (size > old_user_size) {
2014e78: 80 a0 40 1a cmp %g1, %i2
2014e7c: 1a 80 00 17 bcc 2014ed8 <_Heap_Resize_block+0x108>
2014e80: 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 */
2014e84: 80 8d 20 ff btst 0xff, %l4
2014e88: 12 80 00 10 bne 2014ec8 <_Heap_Resize_block+0xf8>
2014e8c: a0 26 80 01 sub %i2, %g1, %l0
uint32_t alignment
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
2014e90: 92 10 00 15 mov %l5, %o1
2014e94: 7f ff fb 63 call 2013c20 <.urem>
2014e98: 90 10 00 10 mov %l0, %o0
*value = r ? v - r + a : v;
2014e9c: 80 a2 20 00 cmp %o0, 0
2014ea0: 02 80 00 05 be 2014eb4 <_Heap_Resize_block+0xe4> <== NEVER TAKEN
2014ea4: 80 a4 00 16 cmp %l0, %l6
2014ea8: 82 04 00 15 add %l0, %l5, %g1
2014eac: a0 20 40 08 sub %g1, %o0, %l0
2014eb0: 80 a4 00 16 cmp %l0, %l6
2014eb4: 0a 80 00 2e bcs 2014f6c <_Heap_Resize_block+0x19c> <== ALWAYS TAKEN
2014eb8: 90 10 00 10 mov %l0, %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)
2014ebc: 80 a5 c0 08 cmp %l7, %o0
2014ec0: 1a 80 00 32 bcc 2014f88 <_Heap_Resize_block+0x1b8> <== ALWAYS TAKEN
2014ec4: 94 10 00 08 mov %o0, %o2
}
}
++stats->resizes;
return HEAP_RESIZE_SUCCESSFUL;
}
2014ec8: 81 c7 e0 08 ret
2014ecc: 91 e8 20 01 restore %g0, 1, %o0
}
}
}
++stats->resizes;
return HEAP_RESIZE_SUCCESSFUL;
2014ed0: 81 c7 e0 08 ret
2014ed4: 91 e8 20 02 restore %g0, 2, %o0
--stats->used_blocks;
}
} else {
/* Calculate how much memory we could free */
uint32_t free_block_size = old_user_size - size;
2014ed8: a0 20 40 1a sub %g1, %i2, %l0
uint32_t *value,
uint32_t alignment
)
{
uint32_t v = *value;
*value = v - (v % alignment);
2014edc: 92 10 00 15 mov %l5, %o1
2014ee0: 7f ff fb 50 call 2013c20 <.urem>
2014ee4: 90 10 00 10 mov %l0, %o0
_Heap_Align_down(&free_block_size, page_size);
if (free_block_size > 0) {
2014ee8: a0 a4 00 08 subcc %l0, %o0, %l0
2014eec: 22 80 00 1c be,a 2014f5c <_Heap_Resize_block+0x18c>
2014ef0: 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;
2014ef4: 84 26 00 10 sub %i0, %l0, %g2
if (new_block_size < min_block_size) {
2014ef8: 80 a5 80 02 cmp %l6, %g2
2014efc: 18 80 00 1e bgu 2014f74 <_Heap_Resize_block+0x1a4>
2014f00: 82 25 80 02 sub %l6, %g2, %g1
_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) {
2014f04: 80 8d 20 ff btst 0xff, %l4
2014f08: 12 80 00 2a bne 2014fb0 <_Heap_Resize_block+0x1e0> <== NEVER TAKEN
2014f0c: 80 a5 80 10 cmp %l6, %l0
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;
2014f10: 82 10 80 1b or %g2, %i3, %g1
2014f14: c2 24 60 04 st %g1, [ %l1 + 4 ]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
2014f18: 86 04 40 02 add %l1, %g2, %g3
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
Heap_Block *prev = block->prev;
2014f1c: d8 04 a0 0c ld [ %l2 + 0xc ], %o4
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;
2014f20: 88 04 00 17 add %l0, %l7, %g4
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *block = old_block;
Heap_Block *next = block->next;
2014f24: da 04 a0 08 ld [ %l2 + 8 ], %o5
_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;
next_next_block->prev_size = new_next_block_size;
2014f28: c8 24 80 17 st %g4, [ %l2 + %l7 ]
_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;
2014f2c: 84 11 20 01 or %g4, 1, %g2
2014f30: c4 20 e0 04 st %g2, [ %g3 + 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;
2014f34: c2 04 e0 30 ld [ %l3 + 0x30 ], %g1
Heap_Block *prev = block->prev;
block = new_block;
block->next = next;
2014f38: da 20 e0 08 st %o5, [ %g3 + 8 ]
2014f3c: 82 00 40 10 add %g1, %l0, %g1
block->prev = prev;
2014f40: d8 20 e0 0c st %o4, [ %g3 + 0xc ]
2014f44: c2 24 e0 30 st %g1, [ %l3 + 0x30 ]
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
2014f48: 88 01 3f fc add %g4, -4, %g4
next->prev = prev->next = block;
2014f4c: c6 23 60 0c st %g3, [ %o5 + 0xc ]
2014f50: c6 23 20 08 st %g3, [ %o4 + 8 ]
2014f54: c8 27 00 00 st %g4, [ %i4 ]
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
}
}
}
++stats->resizes;
2014f58: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1
2014f5c: 82 00 60 01 inc %g1
2014f60: c2 24 e0 54 st %g1, [ %l3 + 0x54 ]
2014f64: 81 c7 e0 08 ret
2014f68: 91 e8 20 00 restore %g0, 0, %o0
)
{
uint32_t v = *value;
uint32_t a = alignment;
uint32_t r = v % a;
*value = r ? v - r + a : v;
2014f6c: 10 bf ff d4 b 2014ebc <_Heap_Resize_block+0xec>
2014f70: 90 10 00 16 mov %l6, %o0
if (new_block_size < min_block_size) {
uint32_t delta = min_block_size - new_block_size;
_HAssert(free_block_size >= delta);
free_block_size -= delta;
if (free_block_size == 0) {
2014f74: a0 a4 00 01 subcc %l0, %g1, %l0
2014f78: 12 bf ff e3 bne 2014f04 <_Heap_Resize_block+0x134> <== NEVER TAKEN
2014f7c: 84 00 80 01 add %g2, %g1, %g2
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
}
}
}
++stats->resizes;
2014f80: 10 bf ff f7 b 2014f5c <_Heap_Resize_block+0x18c>
2014f84: c2 04 e0 54 ld [ %l3 + 0x54 ], %g1
_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)
return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
add_block_size =
2014f88: 92 10 00 12 mov %l2, %o1
2014f8c: 7f ff c6 b4 call 2006a5c <_Heap_Block_allocate>
2014f90: 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;
2014f94: 90 02 00 18 add %o0, %i0, %o0
2014f98: 90 12 00 1b or %o0, %i3, %o0
2014f9c: d0 24 60 04 st %o0, [ %l1 + 4 ]
--stats->used_blocks;
2014fa0: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1
2014fa4: 82 00 7f ff add %g1, -1, %g1
2014fa8: 10 bf ff ec b 2014f58 <_Heap_Resize_block+0x188>
2014fac: c2 24 e0 40 st %g1, [ %l3 + 0x40 ]
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;
*avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
} else if (free_block_size >= min_block_size) {
2014fb0: 38 bf ff eb bgu,a 2014f5c <_Heap_Resize_block+0x18c> <== NOT EXECUTED
2014fb4: 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;
2014fb8: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
2014fbc: 92 04 40 02 add %l1, %g2, %o1 <== NOT EXECUTED
2014fc0: c2 24 60 04 st %g1, [ %l1 + 4 ] <== NOT EXECUTED
next_block = _Heap_Block_at(the_block, new_block_size);
next_block->size = free_block_size | HEAP_PREV_USED;
2014fc4: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED
2014fc8: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED
++stats->used_blocks; /* We have created used block */
2014fcc: c2 04 e0 40 ld [ %l3 + 0x40 ], %g1 <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
2014fd0: 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 */
2014fd4: 82 00 60 01 inc %g1 <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
2014fd8: 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 */
2014fdc: c2 24 e0 40 st %g1, [ %l3 + 0x40 ] <== NOT EXECUTED
--stats->frees; /* Don't count next call in stats */
2014fe0: c4 24 e0 50 st %g2, [ %l3 + 0x50 ] <== NOT EXECUTED
_Heap_Free(the_heap, _Heap_User_area(next_block));
2014fe4: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED
2014fe8: 7f ff da e3 call 200bb74 <_Heap_Free> <== NOT EXECUTED
2014fec: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
*avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
2014ff0: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED
2014ff4: 10 bf ff d9 b 2014f58 <_Heap_Resize_block+0x188> <== NOT EXECUTED
2014ff8: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED
02014ffc <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
Heap_Control *the_heap,
void *starting_address,
size_t *size
)
{
2014ffc: 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(
2015000: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
2015004: e2 06 20 24 ld [ %i0 + 0x24 ], %l1
2015008: 80 a6 40 10 cmp %i1, %l0
201500c: 84 60 3f ff subx %g0, -1, %g2
2015010: 80 a4 40 19 cmp %l1, %i1
2015014: 82 60 3f ff subx %g0, -1, %g1
2015018: 80 88 80 01 btst %g2, %g1
201501c: 02 80 00 20 be 201509c <_Heap_Size_of_user_area+0xa0>
2015020: 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);
2015024: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
2015028: 7f ff fa fe call 2013c20 <.urem>
201502c: 90 10 00 19 mov %i1, %o0
2015030: 82 06 7f f8 add %i1, -8, %g1
2015034: 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 ) )
2015038: 80 a0 c0 10 cmp %g3, %l0
201503c: 84 60 3f ff subx %g0, -1, %g2
2015040: 80 a4 40 03 cmp %l1, %g3
2015044: 82 60 3f ff subx %g0, -1, %g1
2015048: 80 88 80 01 btst %g2, %g1
201504c: 02 80 00 14 be 201509c <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
2015050: 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 );
2015054: c2 00 e0 04 ld [ %g3 + 4 ], %g1
2015058: 82 08 7f fe and %g1, -2, %g1
201505c: 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 (
2015060: 80 a2 00 10 cmp %o0, %l0
2015064: 84 60 3f ff subx %g0, -1, %g2
2015068: 80 a4 40 08 cmp %l1, %o0
201506c: 82 60 3f ff subx %g0, -1, %g1
2015070: 80 88 80 01 btst %g2, %g1
2015074: 02 80 00 0a be 201509c <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
2015078: 01 00 00 00 nop
201507c: c2 02 20 04 ld [ %o0 + 4 ], %g1
2015080: 80 88 60 01 btst 1, %g1
2015084: 02 80 00 06 be 201509c <_Heap_Size_of_user_area+0xa0> <== NEVER TAKEN
2015088: 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 )
201508c: 82 00 60 04 add %g1, 4, %g1
2015090: c2 26 80 00 st %g1, [ %i2 ]
2015094: 81 c7 e0 08 ret
2015098: 91 e8 20 01 restore %g0, 1, %o0
+ HEAP_BLOCK_HEADER_OFFSET;
return( TRUE );
}
201509c: 81 c7 e0 08 ret
20150a0: 91 e8 20 00 restore %g0, 0, %o0
0200e788 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *the_heap,
int source,
bool do_dump
)
{
200e788: 9d e3 bf 98 save %sp, -104, %sp
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
200e78c: 80 a6 60 00 cmp %i1, 0
Heap_Control *the_heap,
int source,
bool do_dump
)
{
Heap_Block *the_block = the_heap->start;
200e790: e2 06 20 20 ld [ %i0 + 0x20 ], %l1
/*
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
200e794: 06 80 00 8c bl 200e9c4 <_Heap_Walk+0x23c> <== NEVER TAKEN
200e798: ec 06 20 24 ld [ %i0 + 0x24 ], %l6
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
200e79c: c2 04 60 04 ld [ %l1 + 4 ], %g1
200e7a0: 80 88 60 01 btst 1, %g1
200e7a4: 02 80 00 81 be 200e9a8 <_Heap_Walk+0x220> <== NEVER TAKEN
200e7a8: a6 10 20 00 clr %l3
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
200e7ac: c4 04 40 00 ld [ %l1 ], %g2
200e7b0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200e7b4: 80 a0 80 01 cmp %g2, %g1
200e7b8: 02 80 00 08 be 200e7d8 <_Heap_Walk+0x50> <== ALWAYS TAKEN
200e7bc: 80 a4 40 16 cmp %l1, %l6
printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
200e7c0: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e7c4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e7c8: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
200e7cc: 7f ff d9 3f call 2004cc8 <printk> <== NOT EXECUTED
200e7d0: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
error = 1;
}
while ( the_block != end ) {
200e7d4: 80 a4 40 16 cmp %l1, %l6 <== NOT EXECUTED
200e7d8: 22 80 00 63 be,a 200e964 <_Heap_Walk+0x1dc> <== NEVER TAKEN
200e7dc: a2 10 00 16 mov %l6, %l1 <== NOT EXECUTED
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)) {
200e7e0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
200e7e4: c8 04 60 04 ld [ %l1 + 4 ], %g4
200e7e8: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200e7ec: a4 09 3f fe and %g4, -2, %l2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
void *base,
uint32_t offset
)
{
return (Heap_Block *) _Addresses_Add_offset( base, offset );
200e7f0: a0 04 40 12 add %l1, %l2, %l0
200e7f4: 80 a4 00 01 cmp %l0, %g1
200e7f8: 84 60 3f ff subx %g0, -1, %g2
200e7fc: 80 a0 c0 10 cmp %g3, %l0
200e800: 82 60 3f ff subx %g0, -1, %g1
200e804: 80 88 80 01 btst %g2, %g1
200e808: 02 80 00 77 be 200e9e4 <_Heap_Walk+0x25c> <== NEVER TAKEN
200e80c: 03 00 80 67 sethi %hi(0x2019c00), %g1
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);
200e810: 05 00 80 6a sethi %hi(0x201a800), %g2
{ /* Check if 'the_block' is in the free block list */
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");
200e814: ba 10 62 20 or %g1, 0x220, %i5
printk("PASS: %d !the_block not in the free list", source);
200e818: ae 10 a3 28 or %g2, 0x328, %l7
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);
200e81c: 03 00 80 6a sethi %hi(0x201a800), %g1
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);
200e820: 05 00 80 6a sethi %hi(0x201a800), %g2
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
200e824: a8 09 20 01 and %g4, 1, %l4
error = 1;
}
if (!prev_used) {
if (do_dump || error) printk("\n");
printk("PASS: %d !two consecutive blocks are free", source);
200e828: b8 10 62 f8 or %g1, 0x2f8, %i4
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);
200e82c: b6 10 a2 c8 or %g2, 0x2c8, %i3
200e830: aa 10 00 10 mov %l0, %l5
printk("PASS: %d !block %p is out of heap\n", source, next_block);
error = 1;
break;
}
if (!_Heap_Is_prev_used(next_block)) {
200e834: c2 04 20 04 ld [ %l0 + 4 ], %g1
200e838: 80 88 60 01 btst 1, %g1
200e83c: 12 80 00 20 bne 200e8bc <_Heap_Walk+0x134>
200e840: 80 a4 e0 00 cmp %l3, 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) {
200e844: c2 04 00 00 ld [ %l0 ], %g1
200e848: 80 a0 40 12 cmp %g1, %l2
200e84c: 02 80 00 07 be 200e868 <_Heap_Walk+0xe0> <== ALWAYS TAKEN
200e850: 80 8d 20 ff btst 0xff, %l4
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
200e854: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200e858: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e85c: 7f ff d9 1b call 2004cc8 <printk> <== NOT EXECUTED
200e860: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
error = 1;
}
if (!prev_used) {
200e864: 80 8d 20 ff btst 0xff, %l4 <== NOT EXECUTED
200e868: 32 80 00 0a bne,a 200e890 <_Heap_Walk+0x108> <== ALWAYS TAKEN
200e86c: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (do_dump || error) printk("\n");
200e870: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
200e874: 12 80 00 49 bne 200e998 <_Heap_Walk+0x210> <== NOT EXECUTED
200e878: 01 00 00 00 nop <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
200e87c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
200e880: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e884: 7f ff d9 11 call 2004cc8 <printk> <== NOT EXECUTED
200e888: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
Heap_Control *the_heap
)
{
return _Heap_Head(the_heap)->next;
200e88c: c2 06 20 08 ld [ %i0 + 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)
200e890: 80 a0 40 11 cmp %g1, %l1
200e894: 02 80 00 0a be 200e8bc <_Heap_Walk+0x134>
200e898: 80 a4 e0 00 cmp %l3, 0
200e89c: 80 a6 00 01 cmp %i0, %g1
200e8a0: 02 80 00 58 be 200ea00 <_Heap_Walk+0x278> <== NEVER TAKEN
200e8a4: 80 a0 40 11 cmp %g1, %l1
block = block->next;
200e8a8: c2 00 60 08 ld [ %g1 + 8 ], %g1
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)
200e8ac: 80 a0 40 11 cmp %g1, %l1
200e8b0: 12 bf ff fc bne 200e8a0 <_Heap_Walk+0x118>
200e8b4: 80 a6 00 01 cmp %i0, %g1
error = 1;
}
}
}
if (do_dump || error) printk("\n");
200e8b8: 80 a4 e0 00 cmp %l3, 0
200e8bc: 32 80 00 58 bne,a 200ea1c <_Heap_Walk+0x294> <== NEVER TAKEN
200e8c0: 27 00 80 67 sethi %hi(0x2019c00), %l3 <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
200e8c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200e8c8: 80 a0 40 12 cmp %g1, %l2
200e8cc: 18 80 00 40 bgu 200e9cc <_Heap_Walk+0x244> <== NEVER TAKEN
200e8d0: 11 00 80 6a sethi %hi(0x201a800), %o0
printk("PASS: %d !block size is too small\n", source);
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
200e8d4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200e8d8: 40 00 26 5a call 2018240 <.urem>
200e8dc: 90 10 00 12 mov %l2, %o0
200e8e0: 80 a2 20 00 cmp %o0, 0
200e8e4: 12 80 00 15 bne 200e938 <_Heap_Walk+0x1b0> <== NEVER TAKEN
200e8e8: 80 a4 e0 00 cmp %l3, 0
printk("PASS: %d !block size is misaligned\n", source);
error = 1;
}
if (++passes > (do_dump ? 10 : 0) && error)
200e8ec: 12 80 00 17 bne 200e948 <_Heap_Walk+0x1c0> <== NEVER TAKEN
200e8f0: 80 a5 80 10 cmp %l6, %l0
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 ) {
200e8f4: 02 80 00 1c be 200e964 <_Heap_Walk+0x1dc>
200e8f8: a2 10 00 16 mov %l6, %l1
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
200e8fc: c8 04 20 04 ld [ %l0 + 4 ], %g4
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)) {
200e900: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200e904: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200e908: a4 09 3f fe and %g4, -2, %l2
200e90c: a0 04 00 12 add %l0, %l2, %l0
200e910: 80 a4 00 01 cmp %l0, %g1
200e914: 84 60 3f ff subx %g0, -1, %g2
200e918: 80 a0 c0 10 cmp %g3, %l0
200e91c: 82 60 3f ff subx %g0, -1, %g1
200e920: 80 88 80 01 btst %g2, %g1
200e924: 02 80 00 2f be 200e9e0 <_Heap_Walk+0x258> <== NEVER TAKEN
200e928: a8 09 20 01 and %g4, 1, %l4
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
200e92c: a2 10 00 15 mov %l5, %l1
200e930: 10 bf ff c1 b 200e834 <_Heap_Walk+0xac>
200e934: aa 10 00 10 mov %l0, %l5
printk("PASS: %d !block size is too small\n", source);
error = 1;
break;
}
if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
printk("PASS: %d !block size is misaligned\n", source);
200e938: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e93c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e940: 7f ff d8 e2 call 2004cc8 <printk> <== NOT EXECUTED
200e944: 90 12 23 80 or %o0, 0x380, %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",
200e948: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
200e94c: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e950: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e954: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED
200e958: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
200e95c: 7f ff d8 db call 2004cc8 <printk> <== NOT EXECUTED
200e960: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
source, the_block, end);
error = 1;
}
if (_Heap_Block_size(the_block) != the_heap->page_size) {
200e964: d6 06 20 10 ld [ %i0 + 0x10 ], %o3
*/
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
Heap_Block *the_block
)
{
return (the_block->size & ~HEAP_PREV_USED);
200e968: c2 04 60 04 ld [ %l1 + 4 ], %g1
200e96c: 94 08 7f fe and %g1, -2, %o2
200e970: 80 a2 c0 0a cmp %o3, %o2
200e974: 02 80 00 07 be 200e990 <_Heap_Walk+0x208> <== ALWAYS TAKEN
200e978: b0 10 00 13 mov %l3, %i0
printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
200e97c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e980: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e984: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
200e988: 7f ff d8 d0 call 2004cc8 <printk> <== NOT EXECUTED
200e98c: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED
if(do_dump && error)
_Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );
return error;
}
200e990: 81 c7 e0 08 ret
200e994: 81 e8 00 00 restore
if (do_dump) printk("\n");
printk("PASS: %d !front and back sizes don't match", source);
error = 1;
}
if (!prev_used) {
if (do_dump || error) printk("\n");
200e998: 7f ff d8 cc call 2004cc8 <printk> <== NOT EXECUTED
200e99c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printk("PASS: %d !two consecutive blocks are free", source);
200e9a0: 10 bf ff b8 b 200e880 <_Heap_Walk+0xf8> <== NOT EXECUTED
200e9a4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
/*
* Handle the 1st block
*/
if (!_Heap_Is_prev_used(the_block)) {
printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
200e9a8: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e9ac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e9b0: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
200e9b4: 7f ff d8 c5 call 2004cc8 <printk> <== NOT EXECUTED
200e9b8: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
error = 1;
}
if (the_block->prev_size != the_heap->page_size) {
200e9bc: 10 bf ff 7d b 200e7b0 <_Heap_Walk+0x28> <== NOT EXECUTED
200e9c0: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED
if ( !_System_state_Is_up( _System_state_Get() ) )
return TRUE;
*/
if (source < 0)
source = the_heap->stats.instance;
200e9c4: 10 bf ff 76 b 200e79c <_Heap_Walk+0x14> <== NOT EXECUTED
200e9c8: f2 06 20 28 ld [ %i0 + 0x28 ], %i1 <== NOT EXECUTED
}
if (do_dump || error) printk("\n");
if (the_size < the_heap->min_block_size) {
printk("PASS: %d !block size is too small\n", source);
200e9cc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e9d0: 7f ff d8 be call 2004cc8 <printk> <== NOT EXECUTED
200e9d4: 90 12 23 58 or %o0, 0x358, %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",
200e9d8: 10 bf ff dd b 200e94c <_Heap_Walk+0x1c4> <== NOT EXECUTED
200e9dc: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
Heap_Block *the_block
)
{
return (the_block->size & HEAP_PREV_USED);
200e9e0: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
printk(" (prev_size) %d", the_block->prev_size);
}
if (!_Heap_Is_block_in(the_heap, next_block)) {
if (do_dump) printk("\n");
printk("PASS: %d !block %p is out of heap\n", source, next_block);
200e9e4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
200e9e8: 11 00 80 6a sethi %hi(0x201a800), %o0 <== NOT EXECUTED
200e9ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e9f0: 7f ff d8 b6 call 2004cc8 <printk> <== NOT EXECUTED
200e9f4: 90 12 22 a0 or %o0, 0x2a0, %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",
200e9f8: 10 bf ff d5 b 200e94c <_Heap_Walk+0x1c4> <== NOT EXECUTED
200e9fc: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
{ /* Check if 'the_block' is in the free block list */
Heap_Block* block = _Heap_First(the_heap);
while(block != the_block && block != tail)
block = block->next;
if(block != the_block) {
200ea00: 02 bf ff ae be 200e8b8 <_Heap_Walk+0x130> <== NOT EXECUTED
200ea04: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
if (do_dump || error) printk("\n");
200ea08: 12 80 00 0a bne 200ea30 <_Heap_Walk+0x2a8> <== NOT EXECUTED
200ea0c: 27 00 80 67 sethi %hi(0x2019c00), %l3 <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
200ea10: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
200ea14: 7f ff d8 ad call 2004cc8 <printk> <== NOT EXECUTED
200ea18: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
error = 1;
}
}
}
if (do_dump || error) printk("\n");
200ea1c: 90 14 e2 20 or %l3, 0x220, %o0 <== NOT EXECUTED
200ea20: 7f ff d8 aa call 2004cc8 <printk> <== NOT EXECUTED
200ea24: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
if (the_size < the_heap->min_block_size) {
200ea28: 10 bf ff a8 b 200e8c8 <_Heap_Walk+0x140> <== NOT EXECUTED
200ea2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
{ /* Check if 'the_block' is in the free block list */
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");
200ea30: 7f ff d8 a6 call 2004cc8 <printk> <== NOT EXECUTED
200ea34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printk("PASS: %d !the_block not in the free list", source);
200ea38: 10 bf ff f7 b 200ea14 <_Heap_Walk+0x28c> <== NOT EXECUTED
200ea3c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
02005f88 <_IO_Initialize_all_drivers>:
*
* Output Parameters: NONE
*/
void _IO_Initialize_all_drivers( void )
{
2005f88: 9d e3 bf 98 save %sp, -104, %sp
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
2005f8c: 03 00 80 5d sethi %hi(0x2017400), %g1
2005f90: c4 00 62 f8 ld [ %g1 + 0x2f8 ], %g2 ! 20176f8 <_IO_Number_of_drivers>
2005f94: 80 a0 a0 00 cmp %g2, 0
2005f98: 02 80 00 0c be 2005fc8 <_IO_Initialize_all_drivers+0x40> <== NEVER TAKEN
2005f9c: a2 10 62 f8 or %g1, 0x2f8, %l1
2005fa0: a0 10 20 00 clr %l0
(void) rtems_io_initialize( major, 0, NULL );
2005fa4: 90 10 00 10 mov %l0, %o0
2005fa8: 92 10 20 00 clr %o1
2005fac: 40 00 15 f4 call 200b77c <rtems_io_initialize>
2005fb0: 94 10 20 00 clr %o2
void _IO_Initialize_all_drivers( void )
{
rtems_device_major_number major;
for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
2005fb4: c2 04 40 00 ld [ %l1 ], %g1
2005fb8: a0 04 20 01 inc %l0
2005fbc: 80 a0 40 10 cmp %g1, %l0
2005fc0: 18 bf ff fa bgu 2005fa8 <_IO_Initialize_all_drivers+0x20>
2005fc4: 90 10 00 10 mov %l0, %o0
2005fc8: 81 c7 e0 08 ret
2005fcc: 81 e8 00 00 restore
02005fd0 <_IO_Manager_initialization>:
void _IO_Manager_initialization(
rtems_driver_address_table *driver_table,
uint32_t drivers_in_table,
uint32_t number_of_drivers
)
{
2005fd0: 9d e3 bf 98 save %sp, -104, %sp
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
2005fd4: 80 a6 80 19 cmp %i2, %i1
2005fd8: 18 80 00 08 bgu 2005ff8 <_IO_Manager_initialization+0x28>
2005fdc: 83 2e a0 03 sll %i2, 3, %g1
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
2005fe0: 03 00 80 5d sethi %hi(0x2017400), %g1
_IO_Number_of_drivers = number_of_drivers;
2005fe4: 05 00 80 5d sethi %hi(0x2017400), %g2
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
2005fe8: f0 20 62 fc st %i0, [ %g1 + 0x2fc ]
_IO_Number_of_drivers = number_of_drivers;
2005fec: f2 20 a2 f8 st %i1, [ %g2 + 0x2f8 ]
2005ff0: 81 c7 e0 08 ret
2005ff4: 81 e8 00 00 restore
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
2005ff8: a1 2e a0 05 sll %i2, 5, %l0
2005ffc: a0 24 00 01 sub %l0, %g1, %l0
2006000: 40 00 0c 6e call 20091b8 <_Workspace_Allocate_or_fatal_error>
2006004: 90 10 00 10 mov %l0, %o0
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
2006008: 03 00 80 5d sethi %hi(0x2017400), %g1
memset(
200600c: 94 10 00 10 mov %l0, %o2
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
2006010: f4 20 62 f8 st %i2, [ %g1 + 0x2f8 ]
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
2006014: 21 00 80 5d sethi %hi(0x2017400), %l0
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
2006018: 92 10 20 00 clr %o1
200601c: 40 00 1d b5 call 200d6f0 <memset>
2006020: d0 24 22 fc st %o0, [ %l0 + 0x2fc ]
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
2006024: 80 a6 60 00 cmp %i1, 0
2006028: 02 bf ff f2 be 2005ff0 <_IO_Manager_initialization+0x20> <== NEVER TAKEN
200602c: d4 04 22 fc ld [ %l0 + 0x2fc ], %o2
_IO_Driver_address_table[index] = driver_table[index];
2006030: 96 10 20 00 clr %o3
2006034: 98 10 20 00 clr %o4
2006038: c2 06 00 0c ld [ %i0 + %o4 ], %g1
200603c: 9a 06 00 0c add %i0, %o4, %o5
2006040: c2 22 80 0c st %g1, [ %o2 + %o4 ]
2006044: c4 03 60 04 ld [ %o5 + 4 ], %g2
2006048: 86 02 80 0c add %o2, %o4, %g3
200604c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
2006050: c2 03 60 08 ld [ %o5 + 8 ], %g1
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
2006054: 96 02 e0 01 inc %o3
_IO_Driver_address_table[index] = driver_table[index];
2006058: c2 20 e0 08 st %g1, [ %g3 + 8 ]
200605c: c4 03 60 0c ld [ %o5 + 0xc ], %g2
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
2006060: 98 03 20 18 add %o4, 0x18, %o4
_IO_Driver_address_table[index] = driver_table[index];
2006064: c4 20 e0 0c st %g2, [ %g3 + 0xc ]
2006068: c8 03 60 10 ld [ %o5 + 0x10 ], %g4
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
200606c: 80 a6 40 0b cmp %i1, %o3
_IO_Driver_address_table[index] = driver_table[index];
2006070: c8 20 e0 10 st %g4, [ %g3 + 0x10 ]
2006074: c2 03 60 14 ld [ %o5 + 0x14 ], %g1
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
2006078: 18 bf ff f0 bgu 2006038 <_IO_Manager_initialization+0x68>
200607c: c2 20 e0 14 st %g1, [ %g3 + 0x14 ]
2006080: 81 c7 e0 08 ret
2006084: 81 e8 00 00 restore
0200bd64 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>
int _Objects_API_maximum_class(
uint32_t api
)
{
200bd64: 82 10 00 08 mov %o0, %g1
switch (api) {
200bd68: 80 a2 20 02 cmp %o0, 2
200bd6c: 02 80 00 0f be 200bda8 <_Objects_API_maximum_class+0x44>
200bd70: 90 10 20 0a mov 0xa, %o0
200bd74: 80 a0 60 02 cmp %g1, 2
200bd78: 08 80 00 0a bleu 200bda0 <_Objects_API_maximum_class+0x3c>
200bd7c: 80 a0 60 01 cmp %g1, 1
200bd80: 80 a0 60 03 cmp %g1, 3
200bd84: 02 80 00 09 be 200bda8 <_Objects_API_maximum_class+0x44> <== NEVER TAKEN
200bd88: 90 10 20 0c mov 0xc, %o0
200bd8c: 80 a0 60 04 cmp %g1, 4
200bd90: 02 80 00 06 be 200bda8 <_Objects_API_maximum_class+0x44>
200bd94: 90 10 20 08 mov 8, %o0
case OBJECTS_NO_API:
default:
break;
}
return -1;
}
200bd98: 81 c3 e0 08 retl
200bd9c: 90 10 3f ff mov -1, %o0
int _Objects_API_maximum_class(
uint32_t api
)
{
switch (api) {
200bda0: 12 bf ff fe bne 200bd98 <_Objects_API_maximum_class+0x34>
200bda4: 90 10 20 02 mov 2, %o0
200bda8: 81 c3 e0 08 retl
02006bcc <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2006bcc: 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 )
2006bd0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2006bd4: 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 )
2006bd8: 80 a0 60 00 cmp %g1, 0
2006bdc: 02 80 00 1d be 2006c50 <_Objects_Allocate+0x84> <== NEVER TAKEN
2006be0: 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 );
2006be4: a2 04 20 20 add %l0, 0x20, %l1
2006be8: 40 00 13 04 call 200b7f8 <_Chain_Get>
2006bec: 90 10 00 11 mov %l1, %o0
if ( information->auto_extend ) {
2006bf0: c2 0c 20 12 ldub [ %l0 + 0x12 ], %g1
2006bf4: 80 a0 60 00 cmp %g1, 0
2006bf8: 02 80 00 16 be 2006c50 <_Objects_Allocate+0x84>
2006bfc: 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 ) {
2006c00: 80 a2 20 00 cmp %o0, 0
2006c04: 02 80 00 15 be 2006c58 <_Objects_Allocate+0x8c>
2006c08: 01 00 00 00 nop
}
if ( the_object ) {
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
2006c0c: c4 06 20 08 ld [ %i0 + 8 ], %g2
2006c10: d0 04 20 08 ld [ %l0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
2006c14: d2 04 20 14 ld [ %l0 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = _Objects_Get_index( the_object->id ) -
2006c18: 03 00 00 3f sethi %hi(0xfc00), %g1
2006c1c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2006c20: 84 08 80 01 and %g2, %g1, %g2
2006c24: 90 0a 00 01 and %o0, %g1, %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
information->inactive_per_block[ block ]--;
2006c28: 40 00 33 52 call 2013970 <.udiv>
2006c2c: 90 20 80 08 sub %g2, %o0, %o0
2006c30: c6 04 20 30 ld [ %l0 + 0x30 ], %g3
2006c34: 91 2a 20 02 sll %o0, 2, %o0
information->inactive--;
2006c38: 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 ]--;
2006c3c: c4 00 c0 08 ld [ %g3 + %o0 ], %g2
information->inactive--;
2006c40: 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 ]--;
2006c44: 84 00 bf ff add %g2, -1, %g2
information->inactive--;
2006c48: 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 ]--;
2006c4c: c4 20 c0 08 st %g2, [ %g3 + %o0 ]
information->inactive--;
}
}
return the_object;
}
2006c50: 81 c7 e0 08 ret
2006c54: 81 e8 00 00 restore
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
_Objects_Extend_information( information );
2006c58: 40 00 00 14 call 2006ca8 <_Objects_Extend_information>
2006c5c: 90 10 00 10 mov %l0, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2006c60: 40 00 12 e6 call 200b7f8 <_Chain_Get>
2006c64: 90 10 00 11 mov %l1, %o0
}
if ( the_object ) {
2006c68: b0 92 20 00 orcc %o0, 0, %i0
2006c6c: 32 bf ff e9 bne,a 2006c10 <_Objects_Allocate+0x44> <== ALWAYS TAKEN
2006c70: c4 06 20 08 ld [ %i0 + 8 ], %g2
information->inactive--;
}
}
return the_object;
}
2006c74: 81 c7 e0 08 ret <== NOT EXECUTED
2006c78: 81 e8 00 00 restore <== NOT EXECUTED
02006ca8 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
2006ca8: 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;
2006cac: 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 )
2006cb0: ea 16 20 10 lduh [ %i0 + 0x10 ], %l5
2006cb4: 03 00 00 3f sethi %hi(0xfc00), %g1
2006cb8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2006cbc: a8 08 80 01 and %g2, %g1, %l4
2006cc0: 80 a5 40 14 cmp %l5, %l4
2006cc4: 1a 80 00 79 bcc 2006ea8 <_Objects_Extend_information+0x200>
2006cc8: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
2006ccc: a6 10 00 14 mov %l4, %l3
2006cd0: a4 10 20 00 clr %l2
2006cd4: a2 10 20 00 clr %l1
2006cd8: ac 10 20 01 mov 1, %l6
2006cdc: 90 10 20 03 mov 3, %o0
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
2006ce0: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
2006ce4: 80 a0 60 00 cmp %g1, 0
2006ce8: 12 80 00 8d bne 2006f1c <_Objects_Extend_information+0x274>
2006cec: ba 04 00 15 add %l0, %l5, %i5
if ( !object_blocks )
return;
}
else {
object_blocks = (void**)
2006cf0: 90 02 00 14 add %o0, %l4, %o0
2006cf4: 90 02 00 1d add %o0, %i5, %o0
2006cf8: 40 00 09 30 call 20091b8 <_Workspace_Allocate_or_fatal_error>
2006cfc: 91 2a 20 02 sll %o0, 2, %o0
2006d00: ae 10 00 08 mov %o0, %l7
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
2006d04: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
2006d08: 85 2d a0 02 sll %l6, 2, %g2
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
2006d0c: 80 a0 40 14 cmp %g1, %l4
/*
* Break the block into the various sections.
*
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
2006d10: ac 05 c0 02 add %l7, %g2, %l6
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
2006d14: 18 80 00 94 bgu 2006f64 <_Objects_Extend_information+0x2bc>
2006d18: a0 05 80 02 add %l6, %g2, %l0
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
2006d1c: 80 a5 20 00 cmp %l4, 0
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
2006d20: 84 10 20 00 clr %g2
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
2006d24: 02 80 00 08 be 2006d44 <_Objects_Extend_information+0x9c> <== NEVER TAKEN
2006d28: ab 2c a0 02 sll %l2, 2, %l5
local_table[ index ] = NULL;
2006d2c: 83 28 a0 02 sll %g2, 2, %g1
else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
2006d30: 84 00 a0 01 inc %g2
2006d34: 80 a0 80 14 cmp %g2, %l4
2006d38: 0a bf ff fd bcs 2006d2c <_Objects_Extend_information+0x84><== NEVER TAKEN
2006d3c: c0 24 00 01 clr [ %l0 + %g1 ]
2006d40: ab 2c a0 02 sll %l2, 2, %l5
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
2006d44: c0 25 80 15 clr [ %l6 + %l5 ]
for ( index=index_base ;
index < ( information->allocation_size + index_base );
2006d48: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2006d4c: 86 04 c0 01 add %l3, %g1, %g3
2006d50: 80 a4 c0 03 cmp %l3, %g3
2006d54: 1a 80 00 0a bcc 2006d7c <_Objects_Extend_information+0xd4><== NEVER TAKEN
2006d58: c0 25 c0 15 clr [ %l7 + %l5 ]
2006d5c: 83 2c e0 02 sll %l3, 2, %g1
2006d60: 84 04 00 01 add %l0, %g1, %g2
2006d64: 82 10 00 13 mov %l3, %g1
index++ ) {
local_table[ index ] = NULL;
2006d68: c0 20 80 00 clr [ %g2 ]
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
2006d6c: 82 00 60 01 inc %g1
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
2006d70: 80 a0 40 03 cmp %g1, %g3
2006d74: 0a bf ff fd bcs 2006d68 <_Objects_Extend_information+0xc0>
2006d78: 84 00 a0 04 add %g2, 4, %g2
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
2006d7c: 7f ff ec 1a call 2001de4 <sparc_disable_interrupts>
2006d80: 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(
2006d84: c2 06 00 00 ld [ %i0 ], %g1
2006d88: c8 16 20 04 lduh [ %i0 + 4 ], %g4
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
2006d8c: e0 26 20 1c st %l0, [ %i0 + 0x1c ]
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
2006d90: 89 29 20 1b sll %g4, 0x1b, %g4
2006d94: 87 2f 60 10 sll %i5, 0x10, %g3
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
2006d98: 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(
2006d9c: 87 30 e0 10 srl %g3, 0x10, %g3
2006da0: 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;
2006da4: ec 26 20 30 st %l6, [ %i0 + 0x30 ]
information->local_table = local_table;
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
2006da8: 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;
2006dac: fa 36 20 10 sth %i5, [ %i0 + 0x10 ]
information->maximum_id = _Objects_Build_id(
2006db0: 82 10 40 02 or %g1, %g2, %g1
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
2006db4: ee 26 20 34 st %l7, [ %i0 + 0x34 ]
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = maximum;
information->maximum_id = _Objects_Build_id(
2006db8: 82 10 40 04 or %g1, %g4, %g1
2006dbc: 82 10 40 03 or %g1, %g3, %g1
2006dc0: c2 26 20 0c st %g1, [ %i0 + 0xc ]
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
2006dc4: 7f ff ec 0c call 2001df4 <sparc_enable_interrupts>
2006dc8: 01 00 00 00 nop
if ( old_tables )
2006dcc: 80 a4 20 00 cmp %l0, 0
2006dd0: 22 80 00 05 be,a 2006de4 <_Objects_Extend_information+0x13c>
2006dd4: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
_Workspace_Free( old_tables );
2006dd8: 40 00 08 ea call 2009180 <_Workspace_Free>
2006ddc: 90 10 00 10 mov %l0, %o0
2006de0: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
2006de4: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
2006de8: 80 a0 60 00 cmp %g1, 0
2006dec: 02 80 00 55 be 2006f40 <_Objects_Extend_information+0x298>
2006df0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
information->object_blocks[ block ] =
2006df4: 90 10 00 10 mov %l0, %o0
2006df8: 40 00 32 a4 call 2013888 <.umul>
2006dfc: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
2006e00: 40 00 08 e7 call 200919c <_Workspace_Allocate>
2006e04: a9 2c 60 02 sll %l1, 2, %l4
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
2006e08: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
/*
* Allocate the name table, and the objects
*/
if ( information->auto_extend ) {
information->object_blocks[ block ] =
2006e0c: d0 24 00 14 st %o0, [ %l0 + %l4 ]
_Workspace_Allocate(
(information->allocation_size * information->size)
);
if ( !information->object_blocks[ block ] )
2006e10: d2 00 40 14 ld [ %g1 + %l4 ], %o1
2006e14: 80 a2 60 00 cmp %o1, 0
2006e18: 02 80 00 64 be 2006fa8 <_Objects_Extend_information+0x300><== NEVER TAKEN
2006e1c: 01 00 00 00 nop
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
2006e20: d4 06 20 14 ld [ %i0 + 0x14 ], %o2
2006e24: d6 06 20 18 ld [ %i0 + 0x18 ], %o3
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
2006e28: a0 10 00 13 mov %l3, %l0
2006e2c: a2 06 20 20 add %i0, 0x20, %l1
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
2006e30: a6 07 bf ec add %fp, -20, %l3
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
2006e34: 25 00 00 40 sethi %hi(0x10000), %l2
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
2006e38: 40 00 12 83 call 200b844 <_Chain_Initialize>
2006e3c: 90 10 00 13 mov %l3, %o0
2006e40: 30 80 00 0c b,a 2006e70 <_Objects_Extend_information+0x1c8>
index = index_base;
while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {
the_object->id = _Objects_Build_id(
2006e44: c4 16 20 04 lduh [ %i0 + 4 ], %g2
2006e48: 83 28 60 18 sll %g1, 0x18, %g1
2006e4c: 85 28 a0 1b sll %g2, 0x1b, %g2
2006e50: 82 10 40 12 or %g1, %l2, %g1
2006e54: 82 10 40 02 or %g1, %g2, %g1
2006e58: 82 10 40 10 or %g1, %l0, %g1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
2006e5c: 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(
2006e60: c2 22 20 08 st %g1, [ %o0 + 8 ]
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
2006e64: a0 04 20 01 inc %l0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
2006e68: 7f ff fd 2f call 2006324 <_Chain_Append>
2006e6c: 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 ) {
2006e70: 40 00 12 62 call 200b7f8 <_Chain_Get>
2006e74: 90 10 00 13 mov %l3, %o0
2006e78: 80 a2 20 00 cmp %o0, 0
2006e7c: 32 bf ff f2 bne,a 2006e44 <_Objects_Extend_information+0x19c>
2006e80: c2 06 00 00 ld [ %i0 ], %g1
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
2006e84: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
2006e88: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
information->inactive += information->allocation_size;
2006e8c: c8 16 20 2c lduh [ %i0 + 0x2c ], %g4
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
2006e90: c4 20 c0 14 st %g2, [ %g3 + %l4 ]
information->inactive += information->allocation_size;
2006e94: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2006e98: 82 00 40 04 add %g1, %g4, %g1
2006e9c: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
2006ea0: 81 c7 e0 08 ret
2006ea4: 81 e8 00 00 restore
block = 0;
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
2006ea8: 90 10 00 15 mov %l5, %o0
2006eac: 40 00 32 b1 call 2013970 <.udiv>
2006eb0: 92 10 00 10 mov %l0, %o1
for ( ; block < block_count; block++ ) {
2006eb4: a4 92 20 00 orcc %o0, 0, %l2
2006eb8: 02 80 00 3e be 2006fb0 <_Objects_Extend_information+0x308><== NEVER TAKEN
2006ebc: a6 10 00 14 mov %l4, %l3
if ( information->object_blocks[ block ] == NULL )
2006ec0: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
2006ec4: c2 00 80 00 ld [ %g2 ], %g1
2006ec8: 80 a0 60 00 cmp %g1, 0
2006ecc: 12 80 00 08 bne 2006eec <_Objects_Extend_information+0x244><== ALWAYS TAKEN
2006ed0: a2 10 20 00 clr %l1
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
2006ed4: 10 80 00 0c b 2006f04 <_Objects_Extend_information+0x25c> <== NOT EXECUTED
2006ed8: 80 a4 c0 15 cmp %l3, %l5 <== NOT EXECUTED
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL )
2006edc: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2006ee0: 80 a0 60 00 cmp %g1, 0
2006ee4: 02 80 00 08 be 2006f04 <_Objects_Extend_information+0x25c>
2006ee8: 80 a4 c0 15 cmp %l3, %l5
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
2006eec: a2 04 60 01 inc %l1
if ( information->object_blocks[ block ] == NULL )
break;
else
index_base += information->allocation_size;
2006ef0: a6 04 c0 10 add %l3, %l0, %l3
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
2006ef4: 80 a4 80 11 cmp %l2, %l1
2006ef8: 18 bf ff f9 bgu 2006edc <_Objects_Extend_information+0x234>
2006efc: 83 2c 60 02 sll %l1, 2, %g1
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
2006f00: 80 a4 c0 15 cmp %l3, %l5
2006f04: 2a bf ff b9 bcs,a 2006de8 <_Objects_Extend_information+0x140>
2006f08: c2 0e 20 12 ldub [ %i0 + 0x12 ], %g1
2006f0c: ac 04 a0 01 add %l2, 1, %l6
2006f10: 83 2d a0 01 sll %l6, 1, %g1
2006f14: 10 bf ff 73 b 2006ce0 <_Objects_Extend_information+0x38>
2006f18: 90 00 40 16 add %g1, %l6, %o0
/*
* Allocate the tables and break it up.
*/
if ( information->auto_extend ) {
object_blocks = (void**)
2006f1c: 90 02 00 14 add %o0, %l4, %o0
2006f20: 90 02 00 1d add %o0, %i5, %o0
2006f24: 40 00 08 9e call 200919c <_Workspace_Allocate>
2006f28: 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 )
2006f2c: ae 92 20 00 orcc %o0, 0, %l7
2006f30: 32 bf ff 76 bne,a 2006d08 <_Objects_Extend_information+0x60><== ALWAYS TAKEN
2006f34: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
2006f38: 81 c7 e0 08 ret <== NOT EXECUTED
2006f3c: 81 e8 00 00 restore <== NOT EXECUTED
if ( !information->object_blocks[ block ] )
return;
}
else {
information->object_blocks[ block ] =
2006f40: 90 10 00 10 mov %l0, %o0
2006f44: 40 00 32 51 call 2013888 <.umul>
2006f48: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
2006f4c: 40 00 08 9b call 20091b8 <_Workspace_Allocate_or_fatal_error>
2006f50: a9 2c 60 02 sll %l1, 2, %l4
2006f54: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
2006f58: d0 24 00 14 st %o0, [ %l0 + %l4 ]
2006f5c: 10 bf ff b1 b 2006e20 <_Objects_Extend_information+0x178>
2006f60: d2 00 40 14 ld [ %g1 + %l4 ], %o1
/*
* 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,
2006f64: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
2006f68: ab 2c a0 02 sll %l2, 2, %l5
2006f6c: 90 10 00 17 mov %l7, %o0
2006f70: 40 00 19 a7 call 200d60c <memcpy>
2006f74: 94 10 00 15 mov %l5, %o2
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
2006f78: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
2006f7c: 94 10 00 15 mov %l5, %o2
2006f80: 40 00 19 a3 call 200d60c <memcpy>
2006f84: 90 10 00 16 mov %l6, %o0
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
2006f88: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2
2006f8c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
2006f90: 94 05 00 0a add %l4, %o2, %o2
2006f94: 90 10 00 10 mov %l0, %o0
2006f98: 40 00 19 9d call 200d60c <memcpy>
2006f9c: 95 2a a0 02 sll %o2, 2, %o2
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
2006fa0: 10 bf ff 6a b 2006d48 <_Objects_Extend_information+0xa0>
2006fa4: c0 25 80 15 clr [ %l6 + %l5 ]
2006fa8: 81 c7 e0 08 ret <== NOT EXECUTED
2006fac: 81 e8 00 00 restore <== NOT EXECUTED
if ( information->maximum < minimum_index )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
2006fb0: 10 bf ff d4 b 2006f00 <_Objects_Extend_information+0x258> <== NOT EXECUTED
2006fb4: a2 10 20 00 clr %l1 <== NOT EXECUTED
02007068 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint32_t the_class
)
{
2007068: 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 )
200706c: 82 06 3f ff add %i0, -1, %g1
2007070: 80 a0 60 03 cmp %g1, 3
2007074: 38 80 00 1e bgu,a 20070ec <_Objects_Get_information+0x84>
2007078: b0 10 20 00 clr %i0
int the_class_api_maximum;
if ( !_Objects_Is_api_valid( the_api ) )
return NULL;
if ( !the_class )
200707c: 80 a6 60 00 cmp %i1, 0
2007080: 12 80 00 04 bne 2007090 <_Objects_Get_information+0x28>
2007084: 01 00 00 00 nop
if ( info->maximum == 0 )
return NULL;
#endif
return info;
}
2007088: 81 c7 e0 08 ret
200708c: 91 e8 20 00 restore %g0, 0, %o0
return NULL;
if ( !the_class )
return NULL;
the_class_api_maximum = _Objects_API_maximum_class( the_api );
2007090: 40 00 13 35 call 200bd64 <_Objects_API_maximum_class>
2007094: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum < 0 ||
2007098: 80 a2 20 00 cmp %o0, 0
200709c: 06 bf ff fb bl 2007088 <_Objects_Get_information+0x20> <== NEVER TAKEN
20070a0: 80 a2 00 19 cmp %o0, %i1
20070a4: 2a 80 00 12 bcs,a 20070ec <_Objects_Get_information+0x84><== NEVER TAKEN
20070a8: b0 10 20 00 clr %i0 <== NOT EXECUTED
the_class > (uint32_t) the_class_api_maximum )
return NULL;
if ( !_Objects_Information_table[ the_api ] )
20070ac: 85 2e 20 02 sll %i0, 2, %g2
20070b0: 03 00 80 5c sethi %hi(0x2017000), %g1
20070b4: 82 10 63 40 or %g1, 0x340, %g1 ! 2017340 <_Objects_Information_table>
20070b8: c4 00 40 02 ld [ %g1 + %g2 ], %g2
20070bc: 80 a0 a0 00 cmp %g2, 0
20070c0: 02 80 00 0b be 20070ec <_Objects_Get_information+0x84> <== NEVER TAKEN
20070c4: b0 10 20 00 clr %i0
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
20070c8: 83 2e 60 02 sll %i1, 2, %g1
20070cc: f0 00 80 01 ld [ %g2 + %g1 ], %i0
if ( !info )
20070d0: 80 a6 20 00 cmp %i0, 0
20070d4: 02 80 00 06 be 20070ec <_Objects_Get_information+0x84> <== NEVER TAKEN
20070d8: 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 )
20070dc: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
20070e0: 80 a0 60 00 cmp %g1, 0
20070e4: 22 80 00 02 be,a 20070ec <_Objects_Get_information+0x84>
20070e8: b0 10 20 00 clr %i0
return NULL;
#endif
return info;
}
20070ec: 81 c7 e0 08 ret
20070f0: 81 e8 00 00 restore
020070f4 <_Objects_Get_isr_disable>:
Objects_Information *information,
Objects_Id id,
Objects_Locations *location,
ISR_Level *level_p
)
{
20070f4: 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;
20070f8: 03 00 00 3f sethi %hi(0xfc00), %g1
20070fc: 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 );
2007100: 7f ff eb 39 call 2001de4 <sparc_disable_interrupts>
2007104: b2 0e 40 01 and %i1, %g1, %i1
if ( information->maximum >= index ) {
2007108: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
200710c: 80 a6 40 01 cmp %i1, %g1
2007110: 18 80 00 0b bgu 200713c <_Objects_Get_isr_disable+0x48>
2007114: 83 2e 60 02 sll %i1, 2, %g1
if ( (the_object = information->local_table[ index ]) != NULL ) {
2007118: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
200711c: f0 00 80 01 ld [ %g2 + %g1 ], %i0
2007120: 80 a6 20 00 cmp %i0, 0
2007124: 02 80 00 0c be 2007154 <_Objects_Get_isr_disable+0x60> <== NEVER TAKEN
2007128: 01 00 00 00 nop
*location = OBJECTS_LOCAL;
*level_p = level;
200712c: 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;
2007130: c0 26 80 00 clr [ %i2 ]
2007134: 81 c7 e0 08 ret
2007138: 81 e8 00 00 restore
}
_ISR_Enable( level );
*location = OBJECTS_ERROR;
return NULL;
}
_ISR_Enable( level );
200713c: 7f ff eb 2e call 2001df4 <sparc_enable_interrupts>
2007140: b0 10 20 00 clr %i0
*location = OBJECTS_ERROR;
2007144: 82 10 20 01 mov 1, %g1
2007148: c2 26 80 00 st %g1, [ %i2 ]
_Objects_MP_Is_remote( information, id, location, &the_object );
return the_object;
#else
return NULL;
#endif
}
200714c: 81 c7 e0 08 ret
2007150: 81 e8 00 00 restore
if ( (the_object = information->local_table[ index ]) != NULL ) {
*location = OBJECTS_LOCAL;
*level_p = level;
return the_object;
}
_ISR_Enable( level );
2007154: 7f ff eb 28 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2007158: 01 00 00 00 nop <== NOT EXECUTED
*location = OBJECTS_ERROR;
200715c: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1> <== NOT EXECUTED
2007160: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
2007164: 81 c7 e0 08 ret <== NOT EXECUTED
2007168: 81 e8 00 00 restore <== NOT EXECUTED
020089e4 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
Objects_Id id,
size_t length,
char *name
)
{
20089e4: 9d e3 bf 88 save %sp, -120, %sp
20089e8: 90 10 00 18 mov %i0, %o0
char lname[5];
Objects_Control *the_object;
Objects_Locations location;
Objects_Id tmpId;
if ( length == 0 )
20089ec: 80 a6 60 00 cmp %i1, 0
20089f0: 12 80 00 04 bne 2008a00 <_Objects_Get_name_as_string+0x1c>
20089f4: b0 10 00 1a mov %i2, %i0
_Thread_Enable_dispatch();
return name;
}
return NULL; /* unreachable path */
}
20089f8: 81 c7 e0 08 ret
20089fc: 91 e8 20 00 restore %g0, 0, %o0
Objects_Id tmpId;
if ( length == 0 )
return NULL;
if ( name == NULL )
2008a00: 80 a6 a0 00 cmp %i2, 0
2008a04: 02 80 00 38 be 2008ae4 <_Objects_Get_name_as_string+0x100>
2008a08: b4 92 20 00 orcc %o0, 0, %i2
return NULL;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
2008a0c: 12 80 00 04 bne 2008a1c <_Objects_Get_name_as_string+0x38>
2008a10: 03 00 80 8e sethi %hi(0x2023800), %g1
2008a14: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 2023914 <_Thread_Executing>
2008a18: f4 00 a0 08 ld [ %g2 + 8 ], %i2
information = _Objects_Get_information_id( tmpId );
2008a1c: 7f ff ff aa call 20088c4 <_Objects_Get_information_id>
2008a20: 90 10 00 1a mov %i2, %o0
if ( !information )
2008a24: a0 92 20 00 orcc %o0, 0, %l0
2008a28: 22 80 00 2f be,a 2008ae4 <_Objects_Get_name_as_string+0x100>
2008a2c: b0 10 20 00 clr %i0
return NULL;
the_object = _Objects_Get( information, tmpId, &location );
2008a30: 92 10 00 1a mov %i2, %o1
2008a34: 40 00 00 38 call 2008b14 <_Objects_Get>
2008a38: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
2008a3c: c2 07 bf f4 ld [ %fp + -12 ], %g1
2008a40: 80 a0 60 00 cmp %g1, 0
2008a44: 32 80 00 28 bne,a 2008ae4 <_Objects_Get_name_as_string+0x100>
2008a48: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
return NULL;
case OBJECTS_LOCAL:
if ( information->is_string ) {
2008a4c: c2 0c 20 38 ldub [ %l0 + 0x38 ], %g1
2008a50: 80 a0 60 00 cmp %g1, 0
2008a54: 22 80 00 26 be,a 2008aec <_Objects_Get_name_as_string+0x108>
2008a58: c2 02 20 0c ld [ %o0 + 0xc ], %g1
s = the_object->name.name_p;
2008a5c: d0 02 20 0c ld [ %o0 + 0xc ], %o0
lname[ 4 ] = '\0';
s = lname;
}
d = name;
if ( s ) {
2008a60: 80 a2 20 00 cmp %o0, 0
2008a64: 02 80 00 1e be 2008adc <_Objects_Get_name_as_string+0xf8> <== NEVER TAKEN
2008a68: 98 10 00 18 mov %i0, %o4
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
2008a6c: 96 86 7f ff addcc %i1, -1, %o3
2008a70: 02 80 00 1b be 2008adc <_Objects_Get_name_as_string+0xf8> <== NEVER TAKEN
2008a74: 98 10 00 18 mov %i0, %o4
2008a78: da 0a 00 00 ldub [ %o0 ], %o5
2008a7c: 85 2b 60 18 sll %o5, 0x18, %g2
2008a80: 80 a0 a0 00 cmp %g2, 0
2008a84: 02 80 00 16 be 2008adc <_Objects_Get_name_as_string+0xf8>
2008a88: 03 00 80 6c sethi %hi(0x201b000), %g1
2008a8c: 98 10 00 18 mov %i0, %o4
2008a90: 94 10 62 08 or %g1, 0x208, %o2
2008a94: 10 80 00 07 b 2008ab0 <_Objects_Get_name_as_string+0xcc>
2008a98: 88 10 20 00 clr %g4
2008a9c: da 0a 00 04 ldub [ %o0 + %g4 ], %o5
2008aa0: 85 2b 60 18 sll %o5, 0x18, %g2
2008aa4: 80 a0 a0 00 cmp %g2, 0
2008aa8: 02 80 00 0d be 2008adc <_Objects_Get_name_as_string+0xf8>
2008aac: 01 00 00 00 nop
*d = (isprint(*s)) ? *s : '*';
2008ab0: c2 02 80 00 ld [ %o2 ], %g1
2008ab4: 85 38 a0 18 sra %g2, 0x18, %g2
2008ab8: c6 48 40 02 ldsb [ %g1 + %g2 ], %g3
2008abc: 80 88 e0 97 btst 0x97, %g3
2008ac0: 12 80 00 03 bne 2008acc <_Objects_Get_name_as_string+0xe8>
2008ac4: 88 01 20 01 inc %g4
2008ac8: 9a 10 20 2a mov 0x2a, %o5
2008acc: da 2b 00 00 stb %o5, [ %o4 ]
s = lname;
}
d = name;
if ( s ) {
for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
2008ad0: 80 a1 00 0b cmp %g4, %o3
2008ad4: 0a bf ff f2 bcs 2008a9c <_Objects_Get_name_as_string+0xb8>
2008ad8: 98 03 20 01 inc %o4
*d = (isprint(*s)) ? *s : '*';
}
}
*d = '\0';
_Thread_Enable_dispatch();
2008adc: 40 00 02 63 call 2009468 <_Thread_Enable_dispatch>
2008ae0: c0 2b 00 00 clrb [ %o4 ]
2008ae4: 81 c7 e0 08 ret
2008ae8: 81 e8 00 00 restore
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';
2008aec: 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;
2008af0: 85 30 60 18 srl %g1, 0x18, %g2
lname[ 1 ] = (u32_name >> 16) & 0xff;
2008af4: 87 30 60 10 srl %g1, 0x10, %g3
lname[ 2 ] = (u32_name >> 8) & 0xff;
lname[ 3 ] = (u32_name >> 0) & 0xff;
2008af8: 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;
2008afc: c4 2f bf e8 stb %g2, [ %fp + -24 ]
lname[ 1 ] = (u32_name >> 16) & 0xff;
lname[ 2 ] = (u32_name >> 8) & 0xff;
2008b00: 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;
2008b04: c6 2f bf e9 stb %g3, [ %fp + -23 ]
lname[ 2 ] = (u32_name >> 8) & 0xff;
2008b08: c2 2f bf ea stb %g1, [ %fp + -22 ]
lname[ 3 ] = (u32_name >> 0) & 0xff;
lname[ 4 ] = '\0';
2008b0c: 10 bf ff d8 b 2008a6c <_Objects_Get_name_as_string+0x88>
2008b10: 90 07 bf e8 add %fp, -24, %o0
02014218 <_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;
2014218: c2 02 20 08 ld [ %o0 + 8 ], %g1
if ( information->maximum >= index ) {
201421c: 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;
2014220: 92 22 40 01 sub %o1, %g1, %o1
2014224: 82 02 60 01 add %o1, 1, %g1
if ( information->maximum >= index ) {
2014228: 80 a0 40 02 cmp %g1, %g2
201422c: 18 80 00 09 bgu 2014250 <_Objects_Get_no_protection+0x38>
2014230: 83 28 60 02 sll %g1, 2, %g1
if ( (the_object = information->local_table[ index ]) != NULL ) {
2014234: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
2014238: d0 00 80 01 ld [ %g2 + %g1 ], %o0
201423c: 80 a2 20 00 cmp %o0, 0
2014240: 02 80 00 05 be 2014254 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
2014244: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
2014248: 81 c3 e0 08 retl
201424c: 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;
2014250: 82 10 20 01 mov 1, %g1
2014254: 90 10 20 00 clr %o0
return NULL;
}
2014258: 81 c3 e0 08 retl
201425c: c2 22 80 00 st %g1, [ %o2 ]
0200846c <_Objects_Id_to_name>:
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200846c: 9d e3 bf 90 save %sp, -112, %sp
2008470: 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 )
2008474: 80 a6 60 00 cmp %i1, 0
2008478: 02 80 00 24 be 2008508 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN
200847c: b0 10 20 01 mov 1, %i0
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
2008480: 80 a2 60 00 cmp %o1, 0
2008484: 02 80 00 26 be 200851c <_Objects_Id_to_name+0xb0>
2008488: 03 00 80 6d sethi %hi(0x201b400), %g1
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
200848c: 83 32 60 18 srl %o1, 0x18, %g1
2008490: 82 08 60 07 and %g1, 7, %g1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
2008494: 84 00 7f ff add %g1, -1, %g2
2008498: 80 a0 a0 03 cmp %g2, 3
200849c: 38 80 00 1b bgu,a 2008508 <_Objects_Id_to_name+0x9c>
20084a0: 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 ] )
20084a4: 85 28 60 02 sll %g1, 2, %g2
20084a8: 03 00 80 6c sethi %hi(0x201b000), %g1
20084ac: 82 10 63 80 or %g1, 0x380, %g1 ! 201b380 <_Objects_Information_table>
20084b0: c4 00 40 02 ld [ %g1 + %g2 ], %g2
20084b4: 80 a0 a0 00 cmp %g2, 0
20084b8: 02 80 00 16 be 2008510 <_Objects_Id_to_name+0xa4> <== NEVER TAKEN
20084bc: 83 32 60 1b srl %o1, 0x1b, %g1
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
20084c0: 83 28 60 02 sll %g1, 2, %g1
20084c4: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !information )
20084c8: 80 a2 20 00 cmp %o0, 0
20084cc: 02 80 00 0f be 2008508 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN
20084d0: b0 10 20 03 mov 3, %i0
return OBJECTS_INVALID_ID;
if ( information->is_string )
20084d4: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
20084d8: 80 a0 60 00 cmp %g1, 0
20084dc: 12 80 00 0e bne 2008514 <_Objects_Id_to_name+0xa8> <== NEVER TAKEN
20084e0: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &ignored_location );
20084e4: 7f ff ff c5 call 20083f8 <_Objects_Get>
20084e8: 94 07 bf f4 add %fp, -12, %o2
if ( !the_object )
20084ec: 80 a2 20 00 cmp %o0, 0
20084f0: 22 80 00 06 be,a 2008508 <_Objects_Id_to_name+0x9c>
20084f4: b0 10 20 03 mov 3, %i0
return OBJECTS_INVALID_ID;
*name = the_object->name;
20084f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
20084fc: b0 10 20 00 clr %i0
2008500: 40 00 02 77 call 2008edc <_Thread_Enable_dispatch>
2008504: c2 26 40 00 st %g1, [ %i1 ]
2008508: 81 c7 e0 08 ret
200850c: 81 e8 00 00 restore
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
2008510: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
2008514: 81 c7 e0 08 ret <== NOT EXECUTED
2008518: 81 e8 00 00 restore <== NOT EXECUTED
Objects_Locations ignored_location;
if ( !name )
return OBJECTS_INVALID_NAME;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
200851c: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2
2008520: d2 00 a0 08 ld [ %g2 + 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);
2008524: 83 32 60 18 srl %o1, 0x18, %g1
2008528: 82 08 60 07 and %g1, 7, %g1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
200852c: 84 00 7f ff add %g1, -1, %g2
2008530: 80 a0 a0 03 cmp %g2, 3
2008534: 38 bf ff f5 bgu,a 2008508 <_Objects_Id_to_name+0x9c> <== NEVER TAKEN
2008538: b0 10 20 03 mov 3, %i0 <== 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 ] )
200853c: 10 bf ff db b 20084a8 <_Objects_Id_to_name+0x3c>
2008540: 85 28 60 02 sll %g1, 2, %g2
020071e0 <_Objects_Initialize_information>:
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
20071e0: 9d e3 bf 98 save %sp, -104, %sp
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
20071e4: 03 00 80 5c sethi %hi(0x2017000), %g1
20071e8: 85 2e 60 02 sll %i1, 2, %g2
20071ec: 82 10 63 40 or %g1, 0x340, %g1
20071f0: c8 00 40 02 ld [ %g1 + %g2 ], %g4
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
20071f4: de 07 a0 5c ld [ %fp + 0x5c ], %o7
/*
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
20071f8: 83 36 e0 1f srl %i3, 0x1f, %g1
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
20071fc: 05 20 00 00 sethi %hi(0x80000000), %g2
/*
* Set the size of the object
*/
information->size = size;
2007200: b9 2f 20 10 sll %i4, 0x10, %i4
2007204: b9 37 20 10 srl %i4, 0x10, %i4
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
information->is_string = is_string;
2007208: fa 2e 20 38 stb %i5, [ %i0 + 0x38 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
200720c: 87 2e 60 18 sll %i1, 0x18, %g3
2007210: bb 2e a0 1b sll %i2, 0x1b, %i5
/*
* Set the size of the object
*/
information->size = size;
2007214: f8 26 20 18 st %i4, [ %i0 + 0x18 ]
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
2007218: f4 36 20 04 sth %i2, [ %i0 + 4 ]
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE;
maximum &= ~OBJECTS_UNLIMITED_OBJECTS;
200721c: b8 2e c0 02 andn %i3, %g2, %i4
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
2007220: b5 2e a0 02 sll %i2, 2, %i2
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007224: 80 a0 00 1c cmp %g0, %i4
/*
* Set the entry in the object information table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
2007228: f0 21 00 1a st %i0, [ %g4 + %i2 ]
/*
* Are we operating in unlimited, or auto-extend mode
*/
information->auto_extend =
200722c: c2 2e 20 12 stb %g1, [ %i0 + 0x12 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007230: 88 40 20 00 addx %g0, 0, %g4
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
2007234: 03 00 80 5c sethi %hi(0x2017000), %g1
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007238: 05 00 00 40 sethi %hi(0x10000), %g2
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
200723c: 82 10 60 b8 or %g1, 0xb8, %g1
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007240: 86 10 c0 02 or %g3, %g2, %g3
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
2007244: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007248: 86 10 c0 1d or %g3, %i5, %g3
uint32_t name_length;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
200724c: f2 26 00 00 st %i1, [ %i0 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007250: 86 10 c0 04 or %g3, %g4, %g3
information->the_api = the_api;
information->the_class = the_class;
information->is_string = is_string;
information->local_table = 0;
information->inactive_per_block = 0;
2007254: c0 26 20 30 clr [ %i0 + 0x30 ]
information->object_blocks = 0;
2007258: c0 26 20 34 clr [ %i0 + 0x34 ]
information->inactive = 0;
200725c: c0 36 20 2c clrh [ %i0 + 0x2c ]
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum;
2007260: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
*/
if ( maximum == 0 ) minimum_index = 0;
else minimum_index = 1;
information->minimum_id =
2007264: c6 26 20 08 st %g3, [ %i0 + 8 ]
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
2007268: 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) )
200726c: 80 8b e0 03 btst 3, %o7
2007270: 12 80 00 03 bne 200727c <_Objects_Initialize_information+0x9c><== NEVER TAKEN
2007274: 82 08 7f fc and %g1, -4, %g1
2007278: 82 10 00 0f mov %o7, %g1
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
200727c: c2 36 20 3a sth %g1, [ %i0 + 0x3a ]
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2007280: 84 06 20 20 add %i0, 0x20, %g2
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2007284: 82 06 20 24 add %i0, 0x24, %g1
the_chain->permanent_null = NULL;
2007288: 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);
200728c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
/*
* Initialize objects .. if there are any
*/
if ( maximum ) {
2007290: 80 a7 20 00 cmp %i4, 0
2007294: 12 80 00 04 bne 20072a4 <_Objects_Initialize_information+0xc4>
2007298: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
200729c: 81 c7 e0 08 ret
20072a0: 81 e8 00 00 restore
/*
* Reset the maximum value. It will be updated when the information is
* extended.
*/
information->maximum = 0;
20072a4: 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 );
20072a8: 7f ff fe 80 call 2006ca8 <_Objects_Extend_information>
20072ac: 81 e8 00 00 restore
020072ec <_Objects_Name_to_id_u32>:
Objects_Information *information,
uint32_t name,
uint32_t node,
Objects_Id *id
)
{
20072ec: 86 10 00 08 mov %o0, %g3
Objects_Name name_for_mp;
#endif
/* ASSERT: information->is_string == FALSE */
if ( !id )
20072f0: 80 a2 e0 00 cmp %o3, 0
20072f4: 02 80 00 20 be 2007374 <_Objects_Name_to_id_u32+0x88>
20072f8: 90 10 20 02 mov 2, %o0
return OBJECTS_INVALID_ADDRESS;
if ( name == 0 )
20072fc: 80 a2 60 00 cmp %o1, 0
2007300: 22 80 00 1d be,a 2007374 <_Objects_Name_to_id_u32+0x88>
2007304: 90 10 20 01 mov 1, %o0
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
2007308: c2 10 e0 10 lduh [ %g3 + 0x10 ], %g1
200730c: 85 28 60 10 sll %g1, 0x10, %g2
2007310: 80 a0 a0 00 cmp %g2, 0
2007314: 22 80 00 18 be,a 2007374 <_Objects_Name_to_id_u32+0x88> <== NEVER TAKEN
2007318: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
200731c: 80 a2 a0 00 cmp %o2, 0
2007320: 12 80 00 17 bne 200737c <_Objects_Name_to_id_u32+0x90>
2007324: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
2007328: 89 30 a0 10 srl %g2, 0x10, %g4
200732c: 80 a1 20 00 cmp %g4, 0
2007330: 02 80 00 11 be 2007374 <_Objects_Name_to_id_u32+0x88> <== NEVER TAKEN
2007334: 90 10 20 01 mov 1, %o0
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
2007338: d0 00 e0 1c ld [ %g3 + 0x1c ], %o0
200733c: 86 10 20 01 mov 1, %g3
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
the_object = information->local_table[ index ];
2007340: 83 28 e0 02 sll %g3, 2, %g1
2007344: c4 02 00 01 ld [ %o0 + %g1 ], %g2
if ( !the_object )
2007348: 80 a0 a0 00 cmp %g2, 0
200734c: 02 80 00 06 be 2007364 <_Objects_Name_to_id_u32+0x78>
2007350: 86 00 e0 01 inc %g3
continue;
if ( name == the_object->name.name_u32 ) {
2007354: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
2007358: 80 a0 40 09 cmp %g1, %o1
200735c: 22 80 00 0f be,a 2007398 <_Objects_Name_to_id_u32+0xac>
2007360: c2 00 a0 08 ld [ %g2 + 8 ], %g1
search_local_node = TRUE;
if ( search_local_node ) {
name_length = information->name_length;
for ( index = 1; index <= information->maximum; index++ ) {
2007364: 80 a0 c0 04 cmp %g3, %g4
2007368: 08 bf ff f7 bleu 2007344 <_Objects_Name_to_id_u32+0x58>
200736c: 83 28 e0 02 sll %g3, 2, %g1
2007370: 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
}
2007374: 81 c3 e0 08 retl
2007378: 01 00 00 00 nop
if ( name == 0 )
return OBJECTS_INVALID_NAME;
search_local_node = FALSE;
if ( information->maximum != 0 &&
200737c: 82 10 63 ff or %g1, 0x3ff, %g1
2007380: 80 a2 80 01 cmp %o2, %g1
2007384: 02 bf ff e9 be 2007328 <_Objects_Name_to_id_u32+0x3c>
2007388: 80 a2 a0 01 cmp %o2, 1
200738c: 02 bf ff e7 be 2007328 <_Objects_Name_to_id_u32+0x3c>
2007390: 90 10 20 01 mov 1, %o0
2007394: 30 bf ff f8 b,a 2007374 <_Objects_Name_to_id_u32+0x88>
the_object = information->local_table[ index ];
if ( !the_object )
continue;
if ( name == the_object->name.name_u32 ) {
*id = the_object->id;
2007398: 90 10 20 00 clr %o0
200739c: 81 c3 e0 08 retl
20073a0: c2 22 c0 00 st %g1, [ %o3 ]
020072b4 <_Objects_Namespace_remove>:
void _Objects_Namespace_remove(
Objects_Information *information,
Objects_Control *the_object
)
{
20072b4: 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 )
20072b8: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
20072bc: 80 a0 60 00 cmp %g1, 0
20072c0: 22 80 00 09 be,a 20072e4 <_Objects_Namespace_remove+0x30><== ALWAYS TAKEN
20072c4: c0 26 60 0c clr [ %i1 + 0xc ]
20072c8: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED
20072cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20072d0: 22 80 00 05 be,a 20072e4 <_Objects_Namespace_remove+0x30><== NOT EXECUTED
20072d4: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
20072d8: 40 00 07 aa call 2009180 <_Workspace_Free> <== NOT EXECUTED
20072dc: 01 00 00 00 nop <== NOT EXECUTED
/*
* Clear out either format.
*/
the_object->name.name_p = NULL;
the_object->name.name_u32 = 0;
20072e0: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
}
20072e4: 81 c7 e0 08 ret
20072e8: 81 e8 00 00 restore
02008fe4 <_Objects_Set_name>:
bool _Objects_Set_name(
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
2008fe4: 9d e3 bf 98 save %sp, -104, %sp
size_t length;
const char *s;
s = name;
length = strnlen( name, information->name_length ) + 1;
2008fe8: d2 16 20 3a lduh [ %i0 + 0x3a ], %o1
2008fec: 40 00 1e 74 call 20109bc <strnlen>
2008ff0: 90 10 00 1a mov %i2, %o0
if ( information->is_string ) {
2008ff4: c2 0e 20 38 ldub [ %i0 + 0x38 ], %g1
2008ff8: 80 a0 60 00 cmp %g1, 0
2008ffc: 12 80 00 21 bne 2009080 <_Objects_Set_name+0x9c> <== NEVER TAKEN
2009000: a0 02 20 01 add %o0, 1, %l0
strncpy( d, name, length );
d[ length ] = '\0';
the_object->name.name_p = d;
} else {
the_object->name.name_u32 = _Objects_Build_name(
2009004: 03 08 08 08 sethi %hi(0x20202000), %g1
2009008: 80 a4 20 00 cmp %l0, 0
200900c: 02 80 00 19 be 2009070 <_Objects_Set_name+0x8c> <== NEVER TAKEN
2009010: 82 10 60 20 or %g1, 0x20, %g1
2009014: c4 4e 80 00 ldsb [ %i2 ], %g2
2009018: 03 00 08 08 sethi %hi(0x202000), %g1
200901c: 87 28 a0 18 sll %g2, 0x18, %g3
2009020: 82 10 60 20 or %g1, 0x20, %g1
2009024: 80 a4 20 01 cmp %l0, 1
2009028: 02 80 00 12 be 2009070 <_Objects_Set_name+0x8c>
200902c: 82 10 c0 01 or %g3, %g1, %g1
2009030: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
2009034: 03 00 00 08 sethi %hi(0x2000), %g1
2009038: 85 28 a0 10 sll %g2, 0x10, %g2
200903c: 82 10 60 20 or %g1, 0x20, %g1
2009040: 84 10 80 03 or %g2, %g3, %g2
2009044: 80 a4 20 02 cmp %l0, 2
2009048: 02 80 00 0a be 2009070 <_Objects_Set_name+0x8c>
200904c: 82 10 80 01 or %g2, %g1, %g1
2009050: c2 4e a0 02 ldsb [ %i2 + 2 ], %g1
2009054: 80 a4 20 03 cmp %l0, 3
2009058: 83 28 60 08 sll %g1, 8, %g1
200905c: 84 10 80 01 or %g2, %g1, %g2
2009060: 02 80 00 04 be 2009070 <_Objects_Set_name+0x8c>
2009064: 82 10 a0 20 or %g2, 0x20, %g1
2009068: c2 4e a0 03 ldsb [ %i2 + 3 ], %g1
200906c: 82 10 80 01 or %g2, %g1, %g1
2009070: c2 26 60 0c st %g1, [ %i1 + 0xc ]
2009074: b0 10 20 01 mov 1, %i0
);
}
return TRUE;
}
2009078: 81 c7 e0 08 ret
200907c: 81 e8 00 00 restore
length = strnlen( name, information->name_length ) + 1;
if ( information->is_string ) {
char *d;
d = _Workspace_Allocate( length );
2009080: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2009084: 40 00 07 90 call 200aec4 <_Workspace_Allocate> <== NOT EXECUTED
2009088: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( !d )
200908c: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED
2009090: 02 bf ff fa be 2009078 <_Objects_Set_name+0x94> <== NOT EXECUTED
2009094: 01 00 00 00 nop <== NOT EXECUTED
return FALSE;
if ( the_object->name.name_p ) {
2009098: d0 06 60 0c ld [ %i1 + 0xc ], %o0 <== NOT EXECUTED
200909c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20090a0: 02 80 00 06 be 20090b8 <_Objects_Set_name+0xd4> <== NOT EXECUTED
20090a4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
_Workspace_Free( (void *)the_object->name.name_p );
20090a8: 40 00 07 80 call 200aea8 <_Workspace_Free> <== NOT EXECUTED
20090ac: 01 00 00 00 nop <== NOT EXECUTED
the_object->name.name_p = NULL;
20090b0: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED
}
strncpy( d, name, length );
20090b4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
20090b8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20090bc: 40 00 1e 06 call 20108d4 <strncpy> <== NOT EXECUTED
20090c0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
d[ length ] = '\0';
20090c4: c0 2c 40 10 clrb [ %l1 + %l0 ] <== NOT EXECUTED
the_object->name.name_p = d;
20090c8: e2 26 60 0c st %l1, [ %i1 + 0xc ] <== NOT EXECUTED
20090cc: 81 c7 e0 08 ret <== NOT EXECUTED
20090d0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
020073ac <_Objects_Shrink_information>:
*/
void _Objects_Shrink_information(
Objects_Information *information
)
{
20073ac: 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;
20073b0: 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;
20073b4: e0 06 20 14 ld [ %i0 + 0x14 ], %l0
20073b8: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0
20073bc: 03 00 00 3f sethi %hi(0xfc00), %g1
20073c0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20073c4: 92 10 00 10 mov %l0, %o1
20073c8: a4 08 80 01 and %g2, %g1, %l2
20073cc: 40 00 31 69 call 2013970 <.udiv>
20073d0: 90 22 00 12 sub %o0, %l2, %o0
for ( block = 0; block < block_count; block++ ) {
20073d4: 80 a2 20 00 cmp %o0, 0
20073d8: 02 80 00 12 be 2007420 <_Objects_Shrink_information+0x74> <== NEVER TAKEN
20073dc: 84 10 20 00 clr %g2
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
20073e0: c6 06 20 30 ld [ %i0 + 0x30 ], %g3
20073e4: c2 00 c0 00 ld [ %g3 ], %g1
20073e8: 80 a4 00 01 cmp %l0, %g1
20073ec: 12 80 00 09 bne 2007410 <_Objects_Shrink_information+0x64><== ALWAYS TAKEN
20073f0: a2 10 20 04 mov 4, %l1
20073f4: 10 80 00 0d b 2007428 <_Objects_Shrink_information+0x7c> <== NOT EXECUTED
20073f8: a2 10 20 00 clr %l1 <== NOT EXECUTED
information->inactive -= information->allocation_size;
return;
}
index_base += information->allocation_size;
20073fc: a4 04 80 10 add %l2, %l0, %l2
index_base = _Objects_Get_index( information->minimum_id );
block_count = ( information->maximum - index_base ) / information->allocation_size;
for ( block = 0; block < block_count; block++ ) {
if ( information->inactive_per_block[ block ] == information->allocation_size ) {
2007400: 80 a4 00 01 cmp %l0, %g1
2007404: 02 80 00 09 be 2007428 <_Objects_Shrink_information+0x7c>
2007408: 82 04 60 04 add %l1, 4, %g1
200740c: a2 10 00 01 mov %g1, %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++ ) {
2007410: 84 00 a0 01 inc %g2
2007414: 80 a2 00 02 cmp %o0, %g2
2007418: 38 bf ff f9 bgu,a 20073fc <_Objects_Shrink_information+0x50>
200741c: c2 00 c0 11 ld [ %g3 + %l1 ], %g1
2007420: 81 c7 e0 08 ret
2007424: 81 e8 00 00 restore
2007428: 03 00 00 3f sethi %hi(0xfc00), %g1
/*
* 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;
200742c: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
2007430: 10 80 00 0f b 200746c <_Objects_Shrink_information+0xc0>
2007434: a6 10 63 ff or %g1, 0x3ff, %l3
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
2007438: 82 04 80 01 add %l2, %g1, %g1
200743c: 80 a0 40 03 cmp %g1, %g3
2007440: 08 80 00 10 bleu 2007480 <_Objects_Shrink_information+0xd4>
2007444: 90 10 00 02 mov %g2, %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 );
2007448: 40 00 10 e2 call 200b7d0 <_Chain_Extract>
200744c: e0 00 80 00 ld [ %g2 ], %l0
}
else {
the_object = (Objects_Control *) the_object->Node.next;
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
2007450: 80 a4 20 00 cmp %l0, 0
2007454: 22 80 00 10 be,a 2007494 <_Objects_Shrink_information+0xe8><== NEVER TAKEN
2007458: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
200745c: c2 04 00 00 ld [ %l0 ], %g1
2007460: 80 a0 60 00 cmp %g1, 0
2007464: 02 80 00 0b be 2007490 <_Objects_Shrink_information+0xe4>
2007468: 84 10 00 10 mov %l0, %g2
200746c: c2 00 a0 08 ld [ %g2 + 8 ], %g1
2007470: 86 08 40 13 and %g1, %l3, %g3
*/
do {
index = _Objects_Get_index( the_object->id );
if ((index >= index_base) &&
2007474: 80 a0 c0 12 cmp %g3, %l2
2007478: 3a bf ff f0 bcc,a 2007438 <_Objects_Shrink_information+0x8c>
200747c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
the_object = NULL;
_Chain_Extract( &extract_me->Node );
}
else {
the_object = (Objects_Control *) the_object->Node.next;
2007480: e0 00 80 00 ld [ %g2 ], %l0
}
}
while ( the_object && !_Chain_Is_last( &the_object->Node ) );
2007484: 80 a4 20 00 cmp %l0, 0
2007488: 32 bf ff f6 bne,a 2007460 <_Objects_Shrink_information+0xb4><== ALWAYS TAKEN
200748c: c2 04 00 00 ld [ %l0 ], %g1
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
2007490: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
2007494: 40 00 07 3b call 2009180 <_Workspace_Free>
2007498: d0 00 40 11 ld [ %g1 + %l1 ], %o0
information->object_blocks[ block ] = NULL;
information->inactive_per_block[ block ] = 0;
200749c: c4 06 20 30 ld [ %i0 + 0x30 ], %g2
information->inactive -= information->allocation_size;
20074a0: 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;
20074a4: c0 20 80 11 clr [ %g2 + %l1 ]
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
20074a8: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
20074ac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
/*
* Free the memory and reset the structures in the object' information
*/
_Workspace_Free( information->object_blocks[ block ] );
information->object_blocks[ block ] = NULL;
20074b0: c0 20 c0 11 clr [ %g3 + %l1 ]
information->inactive_per_block[ block ] = 0;
information->inactive -= information->allocation_size;
20074b4: 82 20 40 02 sub %g1, %g2, %g1
20074b8: c2 36 20 2c sth %g1, [ %i0 + 0x2c ]
20074bc: 81 c7 e0 08 ret
20074c0: 81 e8 00 00 restore
02009f5c <_Protected_heap_Get_information>:
bool _Protected_heap_Get_information(
Heap_Control *the_heap,
Heap_Information_block *the_info
)
{
2009f5c: 9d e3 bf 98 save %sp, -104, %sp
Heap_Get_information_status status;
if ( !the_heap )
2009f60: 80 a6 20 00 cmp %i0, 0
2009f64: 02 80 00 10 be 2009fa4 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
2009f68: 80 a6 60 00 cmp %i1, 0
return false;
if ( !the_info )
2009f6c: 02 80 00 0e be 2009fa4 <_Protected_heap_Get_information+0x48><== NEVER TAKEN
2009f70: 23 00 80 74 sethi %hi(0x201d000), %l1
return false;
_RTEMS_Lock_allocator();
2009f74: 7f ff f9 22 call 20083fc <_API_Mutex_Lock>
2009f78: d0 04 60 dc ld [ %l1 + 0xdc ], %o0 ! 201d0dc <_RTEMS_Allocator_Mutex>
status = _Heap_Get_information( the_heap, the_info );
2009f7c: 90 10 00 18 mov %i0, %o0
2009f80: 40 00 11 a5 call 200e614 <_Heap_Get_information>
2009f84: 92 10 00 19 mov %i1, %o1
2009f88: a0 10 00 08 mov %o0, %l0
_RTEMS_Unlock_allocator();
2009f8c: 7f ff f9 32 call 2008454 <_API_Mutex_Unlock>
2009f90: d0 04 60 dc ld [ %l1 + 0xdc ], %o0
if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
2009f94: 80 a0 00 10 cmp %g0, %l0
2009f98: 82 60 3f ff subx %g0, -1, %g1
2009f9c: 81 c7 e0 08 ret
2009fa0: 91 e8 00 01 restore %g0, %g1, %o0
return true;
return false;
}
2009fa4: 81 c7 e0 08 ret <== NOT EXECUTED
2009fa8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200b650 <_RTEMS_tasks_Create_extension>:
bool _RTEMS_tasks_Create_extension(
Thread_Control *executing,
Thread_Control *created
)
{
200b650: 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() )
200b654: 21 00 80 5d sethi %hi(0x2017400), %l0
200b658: c6 04 20 7c ld [ %l0 + 0x7c ], %g3 ! 201747c <_Configuration_Table>
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
if ( !api )
200b65c: 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() )
200b660: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
200b664: c4 08 60 04 ldub [ %g1 + 4 ], %g2
200b668: 80 a0 00 02 cmp %g0, %g2
200b66c: 90 60 20 00 subx %g0, 0, %o0
200b670: 90 0a 20 40 and %o0, 0x40, %o0
to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));
api = _Workspace_Allocate( to_allocate );
200b674: 7f ff f6 ca call 200919c <_Workspace_Allocate>
200b678: 90 02 20 20 add %o0, 0x20, %o0
if ( !api )
200b67c: 80 a2 20 00 cmp %o0, 0
200b680: 02 80 00 17 be 200b6dc <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN
200b684: c2 04 20 7c ld [ %l0 + 0x7c ], %g1
*/
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
ASR_Information *information
)
{
information->is_enabled = true;
200b688: 84 10 20 01 mov 1, %g2
api->pending_events = EVENT_SETS_NONE_PENDING;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
200b68c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
200b690: c4 2a 20 08 stb %g2, [ %o0 + 8 ]
200b694: c2 08 e0 04 ldub [ %g3 + 4 ], %g1
created->API_Extensions[ THREAD_API_RTEMS ] = api;
api->pending_events = EVENT_SETS_NONE_PENDING;
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
200b698: c0 26 61 78 clr [ %i1 + 0x178 ]
api = _Workspace_Allocate( to_allocate );
if ( !api )
return false;
created->API_Extensions[ THREAD_API_RTEMS ] = api;
200b69c: d0 26 61 68 st %o0, [ %i1 + 0x168 ]
api->pending_events = EVENT_SETS_NONE_PENDING;
200b6a0: c0 22 00 00 clr [ %o0 ]
information->handler = NULL;
200b6a4: c0 22 20 0c clr [ %o0 + 0xc ]
information->mode_set = RTEMS_DEFAULT_MODES;
200b6a8: c0 22 20 10 clr [ %o0 + 0x10 ]
information->signals_posted = 0;
200b6ac: c0 22 20 14 clr [ %o0 + 0x14 ]
information->signals_pending = 0;
200b6b0: c0 22 20 18 clr [ %o0 + 0x18 ]
_ASR_Initialize( &api->Signal );
created->task_variables = NULL;
if ( rtems_configuration_get_notepads_enabled() ) {
200b6b4: 80 a0 60 00 cmp %g1, 0
200b6b8: 02 80 00 08 be 200b6d8 <_RTEMS_tasks_Create_extension+0x88>
200b6bc: c0 22 20 1c clr [ %o0 + 0x1c ]
200b6c0: 84 10 20 00 clr %g2
for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
api->Notepads[i] = 0;
200b6c4: 82 02 00 02 add %o0, %g2, %g1
200b6c8: 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++)
200b6cc: 80 a0 a0 40 cmp %g2, 0x40
200b6d0: 12 bf ff fd bne 200b6c4 <_RTEMS_tasks_Create_extension+0x74>
200b6d4: c0 20 60 20 clr [ %g1 + 0x20 ]
200b6d8: b0 10 20 01 mov 1, %i0
api->Notepads[i] = 0;
}
return true;
}
200b6dc: 81 c7 e0 08 ret
200b6e0: 81 e8 00 00 restore
02005c34 <_RTEMS_tasks_Initialize_user_tasks_body>:
*
* Output parameters: NONE
*/
void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
2005c34: 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;
2005c38: 03 00 80 5d sethi %hi(0x2017400), %g1
2005c3c: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201747c <_Configuration_Table>
2005c40: c6 00 a0 40 ld [ %g2 + 0x40 ], %g3
/*
* NOTE: This is slightly different from the Ada implementation.
*/
user_tasks = api_configuration->User_initialization_tasks_table;
2005c44: d0 00 e0 2c ld [ %g3 + 0x2c ], %o0
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
2005c48: 80 a2 20 00 cmp %o0, 0
2005c4c: 02 80 00 1b be 2005cb8 <_RTEMS_tasks_Initialize_user_tasks_body+0x84><== NEVER TAKEN
2005c50: e4 00 e0 28 ld [ %g3 + 0x28 ], %l2
2005c54: 80 a4 a0 00 cmp %l2, 0
2005c58: 02 80 00 18 be 2005cb8 <_RTEMS_tasks_Initialize_user_tasks_body+0x84><== NEVER TAKEN
2005c5c: a0 10 00 08 mov %o0, %l0
return;
2005c60: a2 10 20 00 clr %l1
2005c64: a6 07 bf f4 add %fp, -12, %l3
for ( index=0 ; index < maximum ; index++ ) {
return_value = rtems_task_create(
2005c68: d0 04 00 00 ld [ %l0 ], %o0
2005c6c: d2 04 20 08 ld [ %l0 + 8 ], %o1
2005c70: d4 04 20 04 ld [ %l0 + 4 ], %o2
2005c74: d6 04 20 14 ld [ %l0 + 0x14 ], %o3
2005c78: d8 04 20 0c ld [ %l0 + 0xc ], %o4
2005c7c: 7f ff ff 6c call 2005a2c <rtems_task_create>
2005c80: 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 ) )
2005c84: 80 a2 20 00 cmp %o0, 0
2005c88: 12 80 00 0f bne 2005cc4 <_RTEMS_tasks_Initialize_user_tasks_body+0x90>
2005c8c: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
return_value = rtems_task_start(
2005c90: d0 07 bf f4 ld [ %fp + -12 ], %o0
2005c94: d2 04 20 10 ld [ %l0 + 0x10 ], %o1
2005c98: 40 00 00 0f call 2005cd4 <rtems_task_start>
2005c9c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2
id,
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
2005ca0: 80 a2 20 00 cmp %o0, 0
2005ca4: 12 80 00 07 bne 2005cc0 <_RTEMS_tasks_Initialize_user_tasks_body+0x8c>
2005ca8: a2 04 60 01 inc %l1
maximum = api_configuration->number_of_initialization_tasks;
if ( !user_tasks || maximum == 0 )
return;
for ( index=0 ; index < maximum ; index++ ) {
2005cac: 80 a4 80 11 cmp %l2, %l1
2005cb0: 18 bf ff ee bgu 2005c68 <_RTEMS_tasks_Initialize_user_tasks_body+0x34><== NEVER TAKEN
2005cb4: a0 04 20 1c add %l0, 0x1c, %l0
2005cb8: 81 c7 e0 08 ret
2005cbc: 81 e8 00 00 restore
user_tasks[ index ].entry_point,
user_tasks[ index ].argument
);
if ( !rtems_is_status_successful( return_value ) )
_Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
2005cc0: 94 10 00 08 mov %o0, %o2
2005cc4: 92 10 20 01 mov 1, %o1
2005cc8: 40 00 03 91 call 2006b0c <_Internal_error_Occurred>
2005ccc: 90 10 20 01 mov 1, %o0
0200b580 <_RTEMS_tasks_Post_switch_extension>:
*/
void _RTEMS_tasks_Post_switch_extension(
Thread_Control *executing
)
{
200b580: 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 ];
200b584: f0 06 21 68 ld [ %i0 + 0x168 ], %i0
if ( !api )
200b588: 80 a6 20 00 cmp %i0, 0
200b58c: 02 80 00 1f be 200b608 <_RTEMS_tasks_Post_switch_extension+0x88><== NEVER TAKEN
200b590: 01 00 00 00 nop
* Signal Processing
*/
asr = &api->Signal;
_ISR_Disable( level );
200b594: 7f ff da 14 call 2001de4 <sparc_disable_interrupts>
200b598: 01 00 00 00 nop
signal_set = asr->signals_posted;
200b59c: e4 06 20 14 ld [ %i0 + 0x14 ], %l2
asr->signals_posted = 0;
200b5a0: c0 26 20 14 clr [ %i0 + 0x14 ]
_ISR_Enable( level );
200b5a4: 7f ff da 14 call 2001df4 <sparc_enable_interrupts>
200b5a8: 01 00 00 00 nop
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
200b5ac: 80 a4 a0 00 cmp %l2, 0
200b5b0: 32 80 00 04 bne,a 200b5c0 <_RTEMS_tasks_Post_switch_extension+0x40><== ALWAYS TAKEN
200b5b4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
200b5b8: 81 c7 e0 08 ret <== NOT EXECUTED
200b5bc: 81 e8 00 00 restore <== NOT EXECUTED
return;
asr->nest_level += 1;
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b5c0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
200b5c4: 82 00 60 01 inc %g1
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b5c8: a2 07 bf f4 add %fp, -12, %l1
if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
return;
asr->nest_level += 1;
200b5cc: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b5d0: 94 10 00 11 mov %l1, %o2
200b5d4: 21 00 00 3f sethi %hi(0xfc00), %l0
200b5d8: 40 00 04 92 call 200c820 <rtems_task_mode>
200b5dc: 92 14 23 ff or %l0, 0x3ff, %o1 ! ffff <PROM_START+0xffff>
(*asr->handler)( signal_set );
200b5e0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200b5e4: 9f c0 40 00 call %g1
200b5e8: 90 10 00 12 mov %l2, %o0
asr->nest_level -= 1;
200b5ec: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b5f0: 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;
200b5f4: 82 00 7f ff add %g1, -1, %g1
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b5f8: 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;
200b5fc: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
200b600: 40 00 04 88 call 200c820 <rtems_task_mode>
200b604: 94 10 00 11 mov %l1, %o2
200b608: 81 c7 e0 08 ret
200b60c: 81 e8 00 00 restore
0200b4a8 <_RTEMS_tasks_Switch_extension>:
/*
* Per Task Variables
*/
tvp = executing->task_variables;
200b4a8: c8 02 21 78 ld [ %o0 + 0x178 ], %g4
while (tvp) {
200b4ac: 80 a1 20 00 cmp %g4, 0
200b4b0: 22 80 00 0b be,a 200b4dc <_RTEMS_tasks_Switch_extension+0x34>
200b4b4: d2 02 61 78 ld [ %o1 + 0x178 ], %o1
tvp->tval = *tvp->ptr;
200b4b8: c2 01 20 04 ld [ %g4 + 4 ], %g1
*tvp->ptr = tvp->gval;
200b4bc: c6 01 20 08 ld [ %g4 + 8 ], %g3
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
tvp->tval = *tvp->ptr;
200b4c0: c4 00 40 00 ld [ %g1 ], %g2
200b4c4: c4 21 20 0c st %g2, [ %g4 + 0xc ]
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
200b4c8: c8 01 00 00 ld [ %g4 ], %g4
/*
* Per Task Variables
*/
tvp = executing->task_variables;
while (tvp) {
200b4cc: 80 a1 20 00 cmp %g4, 0
200b4d0: 12 bf ff fa bne 200b4b8 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN
200b4d4: c6 20 40 00 st %g3, [ %g1 ]
tvp->tval = *tvp->ptr;
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
200b4d8: d2 02 61 78 ld [ %o1 + 0x178 ], %o1
while (tvp) {
200b4dc: 80 a2 60 00 cmp %o1, 0
200b4e0: 02 80 00 0a be 200b508 <_RTEMS_tasks_Switch_extension+0x60>
200b4e4: 01 00 00 00 nop
tvp->gval = *tvp->ptr;
200b4e8: c2 02 60 04 ld [ %o1 + 4 ], %g1
*tvp->ptr = tvp->tval;
200b4ec: c6 02 60 0c ld [ %o1 + 0xc ], %g3
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
tvp->gval = *tvp->ptr;
200b4f0: c4 00 40 00 ld [ %g1 ], %g2
200b4f4: c4 22 60 08 st %g2, [ %o1 + 8 ]
*tvp->ptr = tvp->tval;
tvp = (rtems_task_variable_t *)tvp->next;
200b4f8: d2 02 40 00 ld [ %o1 ], %o1
*tvp->ptr = tvp->gval;
tvp = (rtems_task_variable_t *)tvp->next;
}
tvp = heir->task_variables;
while (tvp) {
200b4fc: 80 a2 60 00 cmp %o1, 0
200b500: 12 bf ff fa bne 200b4e8 <_RTEMS_tasks_Switch_extension+0x40><== NEVER TAKEN
200b504: c6 20 40 00 st %g3, [ %g1 ]
200b508: 81 c3 e0 08 retl
02006ec0 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
2006ec0: 9d e3 bf 90 save %sp, -112, %sp
2006ec4: 11 00 80 6f sethi %hi(0x201bc00), %o0
2006ec8: 92 10 00 18 mov %i0, %o1
2006ecc: 90 12 21 54 or %o0, 0x154, %o0
2006ed0: 40 00 07 f3 call 2008e9c <_Objects_Get>
2006ed4: 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 ) {
2006ed8: c2 07 bf f4 ld [ %fp + -12 ], %g1
2006edc: 80 a0 60 00 cmp %g1, 0
2006ee0: 12 80 00 11 bne 2006f24 <_Rate_monotonic_Timeout+0x64> <== NEVER TAKEN
2006ee4: b0 10 00 08 mov %o0, %i0
case OBJECTS_LOCAL:
the_thread = the_period->owner;
2006ee8: d0 02 20 50 ld [ %o0 + 0x50 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
2006eec: 03 00 00 10 sethi %hi(0x4000), %g1
2006ef0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
2006ef4: 80 88 80 01 btst %g2, %g1
2006ef8: 32 80 00 0d bne,a 2006f2c <_Rate_monotonic_Timeout+0x6c>
2006efc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
2006f00: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
2006f04: 80 a0 60 01 cmp %g1, 1
2006f08: 02 80 00 12 be 2006f50 <_Rate_monotonic_Timeout+0x90> <== NEVER TAKEN
2006f0c: 82 10 20 04 mov 4, %g1
_Rate_monotonic_Initiate_statistics( the_period );
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
2006f10: 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;
2006f14: 05 00 80 6f sethi %hi(0x201bc00), %g2
2006f18: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 201bed0 <_Thread_Dispatch_disable_level>
2006f1c: 82 00 7f ff add %g1, -1, %g1
2006f20: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
2006f24: 81 c7 e0 08 ret
2006f28: 81 e8 00 00 restore
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_thread = the_period->owner;
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
2006f2c: c2 06 20 08 ld [ %i0 + 8 ], %g1
2006f30: 80 a0 80 01 cmp %g2, %g1
2006f34: 32 bf ff f4 bne,a 2006f04 <_Rate_monotonic_Timeout+0x44> <== NEVER TAKEN
2006f38: 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 );
2006f3c: 13 04 00 ff sethi %hi(0x1003fc00), %o1
2006f40: 40 00 09 41 call 2009444 <_Thread_Clear_state>
2006f44: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
the_thread->Wait.id == the_period->Object.id ) {
_Thread_Unblock( the_thread );
_Rate_monotonic_Initiate_statistics( the_period );
2006f48: 10 80 00 05 b 2006f5c <_Rate_monotonic_Timeout+0x9c>
2006f4c: 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 ) {
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
2006f50: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
2006f54: 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;
2006f58: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED
_Rate_monotonic_Initiate_statistics( the_period );
2006f5c: 7f ff fe 2e call 2006814 <_Rate_monotonic_Initiate_statistics>
2006f60: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2006f64: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006f68: 92 06 20 10 add %i0, 0x10, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2006f6c: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006f70: 11 00 80 6f sethi %hi(0x201bc00), %o0
2006f74: 40 00 0f e8 call 200af14 <_Watchdog_Insert>
2006f78: 90 12 23 b4 or %o0, 0x3b4, %o0 ! 201bfb4 <_Watchdog_Ticks_chain>
2006f7c: 30 bf ff e6 b,a 2006f14 <_Rate_monotonic_Timeout+0x54>
02006850 <_TOD_Tickle_ticks>:
*
* Output parameters: NONE
*/
void _TOD_Tickle_ticks( void )
{
2006850: 9d e3 bf 90 save %sp, -112, %sp
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
tick.tv_sec = 0;
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
2006854: 09 00 80 5d sethi %hi(0x2017400), %g4
2006858: c2 01 21 34 ld [ %g4 + 0x134 ], %g1 ! 2017534 <_Watchdog_Ticks_since_boot>
{
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
200685c: 05 00 80 5d sethi %hi(0x2017400), %g2
2006860: c6 00 a1 80 ld [ %g2 + 0x180 ], %g3 ! 2017580 <_TOD_Microseconds_per_tick>
tick.tv_sec = 0;
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
2006864: 82 00 60 01 inc %g1
{
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
2006868: 85 28 e0 02 sll %g3, 2, %g2
tick.tv_sec = 0;
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
200686c: c2 21 21 34 st %g1, [ %g4 + 0x134 ]
{
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
2006870: 83 28 e0 07 sll %g3, 7, %g1
2006874: 82 20 40 02 sub %g1, %g2, %g1
2006878: 82 00 40 03 add %g1, %g3, %g1
200687c: 83 28 60 03 sll %g1, 3, %g1
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
(void) _Timespec_Add_to( &_TOD_Uptime, &tick );
2006880: a0 07 bf f0 add %fp, -16, %l0
{
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
2006884: c2 27 bf f4 st %g1, [ %fp + -12 ]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
(void) _Timespec_Add_to( &_TOD_Uptime, &tick );
2006888: 92 10 00 10 mov %l0, %o1
struct timespec tick;
uint32_t seconds;
/* Convert the tick quantum to a timespec */
tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
tick.tv_sec = 0;
200688c: c0 27 bf f0 clr [ %fp + -16 ]
/* Update the counter of ticks since boot */
_Watchdog_Ticks_since_boot += 1;
/* Update the timespec format uptime */
(void) _Timespec_Add_to( &_TOD_Uptime, &tick );
2006890: 11 00 80 5d sethi %hi(0x2017400), %o0
2006894: 40 00 08 86 call 2008aac <_Timespec_Add_to>
2006898: 90 12 20 60 or %o0, 0x60, %o0 ! 2017460 <_TOD_Uptime>
/* we do not care how much the uptime changed */
/* Update the timespec format TOD */
seconds = _Timespec_Add_to( &_TOD_Now, &tick );
200689c: 92 10 00 10 mov %l0, %o1
20068a0: 11 00 80 5d sethi %hi(0x2017400), %o0
20068a4: 40 00 08 82 call 2008aac <_Timespec_Add_to>
20068a8: 90 12 20 74 or %o0, 0x74, %o0 ! 2017474 <_TOD_Now>
while ( seconds ) {
20068ac: a0 92 20 00 orcc %o0, 0, %l0
20068b0: 02 80 00 08 be 20068d0 <_TOD_Tickle_ticks+0x80>
20068b4: 03 00 80 5d sethi %hi(0x2017400), %g1
*/
RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{
_Watchdog_Tickle( &_Watchdog_Seconds_chain );
20068b8: a2 10 60 b8 or %g1, 0xb8, %l1 ! 20174b8 <_Watchdog_Seconds_chain>
20068bc: 40 00 0a 06 call 20090d4 <_Watchdog_Tickle>
20068c0: 90 10 00 11 mov %l1, %o0
20068c4: a0 84 3f ff addcc %l0, -1, %l0
20068c8: 12 bf ff fd bne 20068bc <_TOD_Tickle_ticks+0x6c> <== NEVER TAKEN
20068cc: 01 00 00 00 nop
20068d0: 81 c7 e0 08 ret
20068d4: 81 e8 00 00 restore
02006494 <_TOD_Validate>:
*/
bool _TOD_Validate(
rtems_time_of_day *the_tod
)
{
2006494: 9d e3 bf 98 save %sp, -104, %sp
uint32_t days_in_month;
if ((!the_tod) ||
2006498: 80 a6 20 00 cmp %i0, 0
200649c: 02 80 00 2f be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN
20064a0: 03 00 80 8e sethi %hi(0x2023800), %g1
20064a4: d2 00 61 f0 ld [ %g1 + 0x1f0 ], %o1 ! 20239f0 <_TOD_Microseconds_per_tick>
20064a8: 11 00 03 d0 sethi %hi(0xf4000), %o0
20064ac: 40 00 43 16 call 2017104 <.udiv>
20064b0: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
20064b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20064b8: 80 a0 40 08 cmp %g1, %o0
20064bc: 1a 80 00 27 bcc 2006558 <_TOD_Validate+0xc4>
20064c0: 01 00 00 00 nop
20064c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20064c8: 80 a0 60 3b cmp %g1, 0x3b
20064cc: 18 80 00 23 bgu 2006558 <_TOD_Validate+0xc4>
20064d0: 01 00 00 00 nop
20064d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20064d8: 80 a0 60 3b cmp %g1, 0x3b
20064dc: 18 80 00 1f bgu 2006558 <_TOD_Validate+0xc4>
20064e0: 01 00 00 00 nop
20064e4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20064e8: 80 a0 60 17 cmp %g1, 0x17
20064ec: 18 80 00 1b bgu 2006558 <_TOD_Validate+0xc4>
20064f0: 01 00 00 00 nop
20064f4: c4 06 20 04 ld [ %i0 + 4 ], %g2
20064f8: 80 a0 a0 00 cmp %g2, 0
20064fc: 02 80 00 17 be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN
2006500: 80 a0 a0 0c cmp %g2, 0xc
2006504: 18 80 00 15 bgu 2006558 <_TOD_Validate+0xc4>
2006508: 01 00 00 00 nop
200650c: c2 06 00 00 ld [ %i0 ], %g1
2006510: 80 a0 67 c3 cmp %g1, 0x7c3
2006514: 08 80 00 11 bleu 2006558 <_TOD_Validate+0xc4>
2006518: 01 00 00 00 nop
200651c: f0 06 20 08 ld [ %i0 + 8 ], %i0
2006520: 80 a6 20 00 cmp %i0, 0
2006524: 02 80 00 0d be 2006558 <_TOD_Validate+0xc4> <== NEVER TAKEN
2006528: 80 88 60 03 btst 3, %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 )
200652c: 32 80 00 0d bne,a 2006560 <_TOD_Validate+0xcc>
2006530: 85 28 a0 02 sll %g2, 2, %g2
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
2006534: 84 00 a0 0d add %g2, 0xd, %g2
2006538: 03 00 80 65 sethi %hi(0x2019400), %g1
200653c: 85 28 a0 02 sll %g2, 2, %g2
2006540: 82 10 62 c8 or %g1, 0x2c8, %g1
2006544: c4 00 40 02 ld [ %g1 + %g2 ], %g2
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
2006548: 80 a0 80 18 cmp %g2, %i0
200654c: 82 60 3f ff subx %g0, -1, %g1
2006550: 81 c7 e0 08 ret
2006554: 91 e8 00 01 restore %g0, %g1, %o0
if ( the_tod->day > days_in_month )
return false;
return true;
}
2006558: 81 c7 e0 08 ret
200655c: 91 e8 20 00 restore %g0, 0, %o0
return false;
if ( (the_tod->year % 4) == 0 )
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
2006560: 03 00 80 65 sethi %hi(0x2019400), %g1
2006564: 82 10 62 c8 or %g1, 0x2c8, %g1 ! 20196c8 <_TOD_Days_per_month>
2006568: 10 bf ff f8 b 2006548 <_TOD_Validate+0xb4>
200656c: c4 00 40 02 ld [ %g1 + %g2 ], %g2
02007520 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2007520: 9d e3 bf 98 save %sp, -104, %sp
*/
/*
* Save original state
*/
original_state = the_thread->current_state;
2007524: 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 );
2007528: 40 00 04 94 call 2008778 <_Thread_Set_transient>
200752c: 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 )
2007530: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2007534: 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 )
2007538: 80 a0 40 19 cmp %g1, %i1
200753c: 02 80 00 04 be 200754c <_Thread_Change_priority+0x2c>
2007540: 92 10 00 19 mov %i1, %o1
_Thread_Set_priority( the_thread, new_priority );
2007544: 40 00 04 11 call 2008588 <_Thread_Set_priority>
2007548: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200754c: 7f ff ea 26 call 2001de4 <sparc_disable_interrupts>
2007550: 01 00 00 00 nop
2007554: 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;
2007558: f2 04 20 10 ld [ %l0 + 0x10 ], %i1
if ( state != STATES_TRANSIENT ) {
200755c: 80 a6 60 04 cmp %i1, 4
2007560: 02 80 00 10 be 20075a0 <_Thread_Change_priority+0x80>
2007564: 80 8c 60 04 btst 4, %l1
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
2007568: 12 80 00 03 bne 2007574 <_Thread_Change_priority+0x54> <== NEVER TAKEN
200756c: 82 0e 7f fb and %i1, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2007570: c2 24 20 10 st %g1, [ %l0 + 0x10 ]
_ISR_Enable( level );
2007574: 7f ff ea 20 call 2001df4 <sparc_enable_interrupts>
2007578: 90 10 00 18 mov %i0, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
200757c: 03 00 00 ef sethi %hi(0x3bc00), %g1
2007580: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2007584: 80 8e 40 01 btst %i1, %g1
2007588: 32 80 00 04 bne,a 2007598 <_Thread_Change_priority+0x78>
200758c: f0 04 20 44 ld [ %l0 + 0x44 ], %i0
2007590: 81 c7 e0 08 ret
2007594: 81 e8 00 00 restore
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
2007598: 40 00 03 cc call 20084c8 <_Thread_queue_Requeue>
200759c: 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 ) ) {
20075a0: 12 80 00 14 bne 20075f0 <_Thread_Change_priority+0xd0> <== NEVER TAKEN
20075a4: 23 00 80 5d sethi %hi(0x2017400), %l1
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
20075a8: c6 04 20 90 ld [ %l0 + 0x90 ], %g3
20075ac: c4 14 20 96 lduh [ %l0 + 0x96 ], %g2
20075b0: c2 10 c0 00 lduh [ %g3 ], %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 );
20075b4: c0 24 20 10 clr [ %l0 + 0x10 ]
20075b8: 82 10 40 02 or %g1, %g2, %g1
20075bc: c2 30 c0 00 sth %g1, [ %g3 ]
_Priority_Major_bit_map |= the_priority_map->ready_major;
20075c0: c4 14 60 98 lduh [ %l1 + 0x98 ], %g2
20075c4: c2 14 20 94 lduh [ %l0 + 0x94 ], %g1
_Priority_Add_to_bit_map( &the_thread->Priority_map );
if ( prepend_it )
20075c8: 80 8e a0 ff btst 0xff, %i2
20075cc: 84 10 80 01 or %g2, %g1, %g2
20075d0: c4 34 60 98 sth %g2, [ %l1 + 0x98 ]
20075d4: 02 80 00 49 be 20076f8 <_Thread_Change_priority+0x1d8>
20075d8: c2 04 20 8c ld [ %l0 + 0x8c ], %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
20075dc: c4 00 40 00 ld [ %g1 ], %g2
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
20075e0: c2 24 20 04 st %g1, [ %l0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
20075e4: e0 20 40 00 st %l0, [ %g1 ]
the_node->next = before_node;
before_node->previous = the_node;
20075e8: e0 20 a0 04 st %l0, [ %g2 + 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;
20075ec: c4 24 00 00 st %g2, [ %l0 ]
_Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node );
else
_Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node );
}
_ISR_Flash( level );
20075f0: 7f ff ea 01 call 2001df4 <sparc_enable_interrupts>
20075f4: 90 10 00 18 mov %i0, %o0
20075f8: 7f ff e9 fb call 2001de4 <sparc_disable_interrupts>
20075fc: 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 );
2007600: c2 14 60 98 lduh [ %l1 + 0x98 ], %g1
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
2007604: 05 00 80 5c sethi %hi(0x2017000), %g2
2007608: 83 28 60 10 sll %g1, 0x10, %g1
200760c: 87 30 60 10 srl %g1, 0x10, %g3
2007610: 80 a0 e0 ff cmp %g3, 0xff
2007614: 08 80 00 28 bleu 20076b4 <_Thread_Change_priority+0x194>
2007618: d8 00 a3 34 ld [ %g2 + 0x334 ], %o4
200761c: 05 00 80 56 sethi %hi(0x2015800), %g2
2007620: 83 30 60 18 srl %g1, 0x18, %g1
2007624: 88 10 a0 e0 or %g2, 0xe0, %g4
2007628: c2 09 00 01 ldub [ %g4 + %g1 ], %g1
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
200762c: 05 00 80 5d sethi %hi(0x2017400), %g2
2007630: 9b 28 60 10 sll %g1, 0x10, %o5
2007634: 84 10 a1 10 or %g2, 0x110, %g2
2007638: 83 33 60 0f srl %o5, 0xf, %g1
200763c: c6 10 80 01 lduh [ %g2 + %g1 ], %g3
2007640: 83 28 e0 10 sll %g3, 0x10, %g1
2007644: 85 30 60 10 srl %g1, 0x10, %g2
2007648: 80 a0 a0 ff cmp %g2, 0xff
200764c: 18 80 00 29 bgu 20076f0 <_Thread_Change_priority+0x1d0>
2007650: 83 30 60 18 srl %g1, 0x18, %g1
2007654: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
2007658: 82 00 60 08 add %g1, 8, %g1
200765c: 87 33 60 0c srl %o5, 0xc, %g3
2007660: 83 28 60 10 sll %g1, 0x10, %g1
2007664: 83 30 60 10 srl %g1, 0x10, %g1
2007668: 82 00 40 03 add %g1, %g3, %g1
200766c: 85 28 60 04 sll %g1, 4, %g2
2007670: 83 28 60 02 sll %g1, 2, %g1
2007674: 84 20 80 01 sub %g2, %g1, %g2
2007678: c6 03 00 02 ld [ %o4 + %g2 ], %g3
* is also the heir thread, and FALSE otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
200767c: 03 00 80 5d sethi %hi(0x2017400), %g1
2007680: c2 00 60 a4 ld [ %g1 + 0xa4 ], %g1 ! 20174a4 <_Thread_Executing>
* ready thread.
*/
RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
_Thread_Heir = (Thread_Control *)
2007684: 05 00 80 5d sethi %hi(0x2017400), %g2
* 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() &&
2007688: 80 a0 c0 01 cmp %g3, %g1
200768c: 02 80 00 08 be 20076ac <_Thread_Change_priority+0x18c>
2007690: c6 20 a0 70 st %g3, [ %g2 + 0x70 ]
2007694: c2 08 60 76 ldub [ %g1 + 0x76 ], %g1
2007698: 80 a0 60 00 cmp %g1, 0
200769c: 02 80 00 04 be 20076ac <_Thread_Change_priority+0x18c>
20076a0: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Context_Switch_necessary = TRUE;
20076a4: 03 00 80 5d sethi %hi(0x2017400), %g1
20076a8: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ] ! 20174b4 <_Context_Switch_necessary>
_ISR_Enable( level );
20076ac: 7f ff e9 d2 call 2001df4 <sparc_enable_interrupts>
20076b0: 81 e8 00 00 restore
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 );
20076b4: 05 00 80 56 sethi %hi(0x2015800), %g2
20076b8: 88 10 a0 e0 or %g2, 0xe0, %g4 ! 20158e0 <__log2table>
20076bc: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
20076c0: 05 00 80 5d sethi %hi(0x2017400), %g2
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 );
20076c4: 82 00 60 08 add %g1, 8, %g1
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
20076c8: 84 10 a1 10 or %g2, 0x110, %g2
20076cc: 9b 28 60 10 sll %g1, 0x10, %o5
20076d0: 83 33 60 0f srl %o5, 0xf, %g1
20076d4: c6 10 80 01 lduh [ %g2 + %g1 ], %g3
20076d8: 83 28 e0 10 sll %g3, 0x10, %g1
20076dc: 85 30 60 10 srl %g1, 0x10, %g2
20076e0: 80 a0 a0 ff cmp %g2, 0xff
20076e4: 28 bf ff dd bleu,a 2007658 <_Thread_Change_priority+0x138>
20076e8: c2 09 00 02 ldub [ %g4 + %g2 ], %g1
20076ec: 83 30 60 18 srl %g1, 0x18, %g1
20076f0: 10 bf ff db b 200765c <_Thread_Change_priority+0x13c>
20076f4: c2 09 00 01 ldub [ %g4 + %g1 ], %g1
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
20076f8: 84 00 60 04 add %g1, 4, %g2
20076fc: c4 24 00 00 st %g2, [ %l0 ]
old_last_node = the_chain->last;
2007700: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_chain->last = the_node;
2007704: e0 20 60 08 st %l0, [ %g1 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
2007708: c6 24 20 04 st %g3, [ %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;
200770c: 10 bf ff b9 b 20075f0 <_Thread_Change_priority+0xd0>
2007710: e0 20 c0 00 st %l0, [ %g3 ]
02007714 <_Thread_Clear_state>:
void _Thread_Clear_state(
Thread_Control *the_thread,
States_Control state
)
{
2007714: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
2007718: 7f ff e9 b3 call 2001de4 <sparc_disable_interrupts>
200771c: a0 10 00 19 mov %i1, %l0
2007720: a2 10 00 08 mov %o0, %l1
current_state = the_thread->current_state;
2007724: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
if ( current_state & state ) {
2007728: 80 8c 00 19 btst %l0, %i1
200772c: 02 80 00 05 be 2007740 <_Thread_Clear_state+0x2c>
2007730: 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 ) ) {
2007734: 80 a0 60 00 cmp %g1, 0
2007738: 02 80 00 04 be 2007748 <_Thread_Clear_state+0x34>
200773c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
}
}
}
_ISR_Enable( level );
2007740: 7f ff e9 ad call 2001df4 <sparc_enable_interrupts>
2007744: 91 e8 00 11 restore %g0, %l1, %o0
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
2007748: c8 06 20 90 ld [ %i0 + 0x90 ], %g4
200774c: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2
2007750: c2 11 00 00 lduh [ %g4 ], %g1
if ( _States_Is_ready( current_state ) ) {
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
2007754: c6 06 20 8c ld [ %i0 + 0x8c ], %g3
2007758: 82 10 40 02 or %g1, %g2, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
200775c: 1b 00 80 5d sethi %hi(0x2017400), %o5
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
2007760: c2 31 00 00 sth %g1, [ %g4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
2007764: 82 00 e0 04 add %g3, 4, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
2007768: d8 16 20 94 lduh [ %i0 + 0x94 ], %o4
200776c: c2 26 00 00 st %g1, [ %i0 ]
2007770: c4 13 60 98 lduh [ %o5 + 0x98 ], %g2
old_last_node = the_chain->last;
2007774: c8 00 e0 08 ld [ %g3 + 8 ], %g4
the_chain->last = the_node;
2007778: f0 20 e0 08 st %i0, [ %g3 + 8 ]
200777c: 84 10 80 0c or %g2, %o4, %g2
old_last_node->next = the_node;
the_node->previous = old_last_node;
2007780: c8 26 20 04 st %g4, [ %i0 + 4 ]
2007784: c4 33 60 98 sth %g2, [ %o5 + 0x98 ]
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;
2007788: f0 21 00 00 st %i0, [ %g4 ]
_ISR_Flash( level );
200778c: 7f ff e9 9a call 2001df4 <sparc_enable_interrupts>
2007790: 01 00 00 00 nop
2007794: 7f ff e9 94 call 2001de4 <sparc_disable_interrupts>
2007798: 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 ) {
200779c: 09 00 80 5d sethi %hi(0x2017400), %g4
20077a0: c4 01 20 70 ld [ %g4 + 0x70 ], %g2 ! 2017470 <_Thread_Heir>
20077a4: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
20077a8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
20077ac: 80 a0 c0 01 cmp %g3, %g1
20077b0: 1a bf ff e4 bcc 2007740 <_Thread_Clear_state+0x2c>
20077b4: 03 00 80 5d sethi %hi(0x2017400), %g1
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
20077b8: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_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;
20077bc: f0 21 20 70 st %i0, [ %g4 + 0x70 ]
if ( _Thread_Executing->is_preemptible ||
20077c0: c2 08 a0 76 ldub [ %g2 + 0x76 ], %g1
20077c4: 80 a0 60 00 cmp %g1, 0
20077c8: 12 80 00 05 bne 20077dc <_Thread_Clear_state+0xc8>
20077cc: 84 10 20 01 mov 1, %g2
20077d0: 80 a0 e0 00 cmp %g3, 0
20077d4: 12 bf ff db bne 2007740 <_Thread_Clear_state+0x2c> <== ALWAYS TAKEN
20077d8: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
20077dc: 03 00 80 5d sethi %hi(0x2017400), %g1
20077e0: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ] ! 20174b4 <_Context_Switch_necessary>
20077e4: 30 bf ff d7 b,a 2007740 <_Thread_Clear_state+0x2c>
020078d0 <_Thread_Create_idle>:
*
* _Thread_Create_idle
*/
void _Thread_Create_idle( void )
{
20078d0: 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 );
20078d4: 35 00 80 5d sethi %hi(0x2017400), %i2
20078d8: 7f ff fc bd call 2006bcc <_Objects_Allocate>
20078dc: 90 16 a1 40 or %i2, 0x140, %o0 ! 2017540 <_Thread_Internal_information>
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
20078e0: 37 00 80 5c sethi %hi(0x2017000), %i3
20078e4: c2 06 e3 e0 ld [ %i3 + 0x3e0 ], %g1 ! 20173e0 <_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();
20078e8: 39 00 80 5d sethi %hi(0x2017400), %i4
20078ec: 82 00 60 01 inc %g1
20078f0: d0 27 21 8c st %o0, [ %i4 + 0x18c ]
20078f4: c2 26 e3 e0 st %g1, [ %i3 + 0x3e0 ]
* that when _Thread_Initialize unnests dispatch that we do not
* do anything stupid.
*/
_Thread_Disable_dispatch();
_Thread_Initialize(
20078f8: 33 00 80 5d sethi %hi(0x2017400), %i1
20078fc: c2 06 60 7c ld [ %i1 + 0x7c ], %g1 ! 201747c <_Configuration_Table>
2007900: 05 00 80 59 sethi %hi(0x2016400), %g2
2007904: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2007908: d6 00 a2 30 ld [ %g2 + 0x230 ], %o3
200790c: 03 00 80 56 sethi %hi(0x2015800), %g1
2007910: 82 10 62 48 or %g1, 0x248, %g1 ! 2015a48 <_Status_Object_name_errors_to_status+0x18>
2007914: c2 27 bf f4 st %g1, [ %fp + -12 ]
2007918: 80 a2 c0 03 cmp %o3, %g3
200791c: 1a 80 00 03 bcc 2007928 <_Thread_Create_idle+0x58> <== ALWAYS TAKEN
2007920: d2 07 21 8c ld [ %i4 + 0x18c ], %o1
2007924: 96 10 00 03 mov %g3, %o3 <== NOT EXECUTED
2007928: 03 00 80 59 sethi %hi(0x2016400), %g1
200792c: da 08 62 34 ldub [ %g1 + 0x234 ], %o5 ! 2016634 <rtems_maximum_priority>
2007930: 84 07 bf f4 add %fp, -12, %g2
2007934: 82 10 20 01 mov 1, %g1
2007938: c0 23 a0 60 clr [ %sp + 0x60 ]
200793c: c0 23 a0 64 clr [ %sp + 0x64 ]
2007940: c0 23 a0 68 clr [ %sp + 0x68 ]
2007944: 90 16 a1 40 or %i2, 0x140, %o0
2007948: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200794c: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
2007950: 94 10 20 00 clr %o2
2007954: 40 00 00 c3 call 2007c60 <_Thread_Initialize>
2007958: 98 10 20 00 clr %o4
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
_Thread_Executing = _Thread_Idle;
_Thread_Start(
200795c: c4 06 60 7c ld [ %i1 + 0x7c ], %g2
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
2007960: c2 06 e3 e0 ld [ %i3 + 0x3e0 ], %g1
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
2007964: c6 07 21 8c ld [ %i4 + 0x18c ], %g3
2007968: 82 00 7f ff add %g1, -1, %g1
_Thread_Executing = _Thread_Idle;
_Thread_Start(
200796c: f4 00 a0 14 ld [ %g2 + 0x14 ], %i2
2007970: c2 26 e3 e0 st %g1, [ %i3 + 0x3e0 ]
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
2007974: 05 00 80 5d sethi %hi(0x2017400), %g2
2007978: 03 00 80 5d sethi %hi(0x2017400), %g1
_Thread_Executing = _Thread_Idle;
_Thread_Start(
200797c: b0 10 00 03 mov %g3, %i0
/*
* WARNING!!! This is necessary to "kick" start the system and
* MUST be done before _Thread_Start is invoked.
*/
_Thread_Heir =
2007980: c6 20 a0 a4 st %g3, [ %g2 + 0xa4 ]
2007984: c6 20 60 70 st %g3, [ %g1 + 0x70 ]
_Thread_Executing = _Thread_Idle;
_Thread_Start(
2007988: b2 10 20 00 clr %i1
200798c: b6 10 20 00 clr %i3
2007990: 40 00 03 e0 call 2008910 <_Thread_Start>
2007994: 99 e8 20 00 restore %g0, 0, %o4
0200799c <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored
)
{
200799c: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
20079a0: 90 10 00 18 mov %i0, %o0
20079a4: 40 00 00 83 call 2007bb0 <_Thread_Get>
20079a8: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
20079ac: c2 07 bf f4 ld [ %fp + -12 ], %g1
20079b0: 80 a0 60 00 cmp %g1, 0
20079b4: 12 80 00 08 bne 20079d4 <_Thread_Delay_ended+0x38> <== NEVER TAKEN
20079b8: 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 );
20079bc: 7f ff ff 56 call 2007714 <_Thread_Clear_state>
20079c0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
20079c4: 05 00 80 5c sethi %hi(0x2017000), %g2
20079c8: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level>
20079cc: 82 00 7f ff add %g1, -1, %g1
20079d0: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ]
20079d4: 81 c7 e0 08 ret
20079d8: 81 e8 00 00 restore
020079dc <_Thread_Dispatch>:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
20079dc: 9d e3 bf 88 save %sp, -120, %sp
Thread_Control *executing;
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
20079e0: 03 00 80 5d sethi %hi(0x2017400), %g1
20079e4: e2 00 60 a4 ld [ %g1 + 0xa4 ], %l1 ! 20174a4 <_Thread_Executing>
_ISR_Disable( level );
20079e8: 7f ff e8 ff call 2001de4 <sparc_disable_interrupts>
20079ec: ae 10 60 a4 or %g1, 0xa4, %l7
while ( _Context_Switch_necessary == TRUE ) {
20079f0: 05 00 80 5d sethi %hi(0x2017400), %g2
20079f4: c2 08 a0 b4 ldub [ %g2 + 0xb4 ], %g1 ! 20174b4 <_Context_Switch_necessary>
20079f8: aa 10 a0 b4 or %g2, 0xb4, %l5
20079fc: 80 a0 60 00 cmp %g1, 0
2007a00: 03 00 80 5c sethi %hi(0x2017000), %g1
2007a04: 02 80 00 4d be 2007b38 <_Thread_Dispatch+0x15c>
2007a08: b2 10 63 e0 or %g1, 0x3e0, %i1 ! 20173e0 <_Thread_Dispatch_disable_level>
2007a0c: 03 00 80 5d sethi %hi(0x2017400), %g1
2007a10: 05 00 80 5d sethi %hi(0x2017400), %g2
2007a14: b4 10 60 70 or %g1, 0x70, %i2
2007a18: 03 00 80 5d sethi %hi(0x2017400), %g1
2007a1c: a4 10 a0 ac or %g2, 0xac, %l2
2007a20: b6 10 60 6c or %g1, 0x6c, %i3
#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;
2007a24: 05 00 80 5c sethi %hi(0x2017000), %g2
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
2007a28: 03 00 80 5d sethi %hi(0x2017400), %g1
2007a2c: b0 10 a3 38 or %g2, 0x338, %i0
2007a30: ac 10 60 68 or %g1, 0x68, %l6
2007a34: a8 07 bf f0 add %fp, -16, %l4
2007a38: 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;
2007a3c: b8 10 20 01 mov 1, %i4
#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);
2007a40: 10 80 00 34 b 2007b10 <_Thread_Dispatch+0x134>
2007a44: ba 10 00 12 mov %l2, %i5
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;
_ISR_Enable( level );
2007a48: 7f ff e8 eb call 2001df4 <sparc_enable_interrupts>
2007a4c: 01 00 00 00 nop
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
{
struct timespec uptime, ran;
_TOD_Get_uptime( &uptime );
2007a50: 40 00 0f ee call 200ba08 <_TOD_Get_uptime>
2007a54: 90 10 00 14 mov %l4, %o0
_Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
2007a58: 90 10 00 1d mov %i5, %o0
2007a5c: 92 10 00 14 mov %l4, %o1
2007a60: 40 00 04 2d call 2008b14 <_Timespec_Subtract>
2007a64: 94 10 00 13 mov %l3, %o2
_Timespec_Add_to( &executing->cpu_time_used, &ran );
2007a68: 92 10 00 13 mov %l3, %o1
2007a6c: 40 00 04 10 call 2008aac <_Timespec_Add_to>
2007a70: 90 04 60 84 add %l1, 0x84, %o0
_Thread_Time_of_last_context_switch = uptime;
2007a74: c2 07 bf f0 ld [ %fp + -16 ], %g1
2007a78: c4 07 bf f4 ld [ %fp + -12 ], %g2
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
2007a7c: c6 06 c0 00 ld [ %i3 ], %g3
{
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;
2007a80: c2 24 80 00 st %g1, [ %l2 ]
2007a84: c4 24 a0 04 st %g2, [ %l2 + 4 ]
if ( _Thread_libc_reent ) {
executing->libc_reent = *_Thread_libc_reent;
*_Thread_libc_reent = heir->libc_reent;
}
_User_extensions_Thread_switch( executing, heir );
2007a88: 90 10 00 11 mov %l1, %o0
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
2007a8c: 80 a0 e0 00 cmp %g3, 0
2007a90: 02 80 00 06 be 2007aa8 <_Thread_Dispatch+0xcc> <== NEVER TAKEN
2007a94: 92 10 00 10 mov %l0, %o1
executing->libc_reent = *_Thread_libc_reent;
2007a98: c2 00 c0 00 ld [ %g3 ], %g1
2007a9c: c2 24 61 64 st %g1, [ %l1 + 0x164 ]
*_Thread_libc_reent = heir->libc_reent;
2007aa0: c4 04 21 64 ld [ %l0 + 0x164 ], %g2
2007aa4: c4 20 c0 00 st %g2, [ %g3 ]
}
_User_extensions_Thread_switch( executing, heir );
2007aa8: 40 00 04 d8 call 2008e08 <_User_extensions_Thread_switch>
2007aac: 01 00 00 00 nop
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
2007ab0: 92 04 20 d8 add %l0, 0xd8, %o1
2007ab4: 40 00 06 2b call 2009360 <_CPU_Context_switch>
2007ab8: 90 04 60 d8 add %l1, 0xd8, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
2007abc: c2 04 61 60 ld [ %l1 + 0x160 ], %g1
2007ac0: 80 a0 60 00 cmp %g1, 0
2007ac4: 02 80 00 0d be 2007af8 <_Thread_Dispatch+0x11c>
2007ac8: 01 00 00 00 nop
2007acc: d0 05 80 00 ld [ %l6 ], %o0
2007ad0: 80 a4 40 08 cmp %l1, %o0
2007ad4: 02 80 00 09 be 2007af8 <_Thread_Dispatch+0x11c>
2007ad8: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
2007adc: 02 80 00 04 be 2007aec <_Thread_Dispatch+0x110>
2007ae0: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
2007ae4: 40 00 05 e5 call 2009278 <_CPU_Context_save_fp>
2007ae8: 90 02 21 60 add %o0, 0x160, %o0
_Context_Restore_fp( &executing->fp_context );
2007aec: 40 00 06 00 call 20092ec <_CPU_Context_restore_fp>
2007af0: 90 04 61 60 add %l1, 0x160, %o0
_Thread_Allocated_fp = executing;
2007af4: e2 25 80 00 st %l1, [ %l6 ]
#endif
#endif
executing = _Thread_Executing;
_ISR_Disable( level );
2007af8: 7f ff e8 bb call 2001de4 <sparc_disable_interrupts>
2007afc: e2 05 c0 00 ld [ %l7 ], %l1
Thread_Control *heir;
ISR_Level level;
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Context_Switch_necessary == TRUE ) {
2007b00: c2 0d 40 00 ldub [ %l5 ], %g1
2007b04: 80 a0 60 00 cmp %g1, 0
2007b08: 02 80 00 0c be 2007b38 <_Thread_Dispatch+0x15c>
2007b0c: 03 00 80 5c sethi %hi(0x2017000), %g1
heir = _Thread_Heir;
2007b10: e0 06 80 00 ld [ %i2 ], %l0
_Thread_Dispatch_disable_level = 1;
2007b14: f8 26 40 00 st %i4, [ %i1 ]
_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 )
2007b18: 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;
2007b1c: 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 )
2007b20: 80 a0 60 01 cmp %g1, 1
2007b24: 12 bf ff c9 bne 2007a48 <_Thread_Dispatch+0x6c>
2007b28: e0 25 c0 00 st %l0, [ %l7 ]
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
2007b2c: c2 06 00 00 ld [ %i0 ], %g1
2007b30: 10 bf ff c6 b 2007a48 <_Thread_Dispatch+0x6c>
2007b34: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
executing = _Thread_Executing;
_ISR_Disable( level );
}
_Thread_Dispatch_disable_level = 0;
2007b38: c0 20 63 e0 clr [ %g1 + 0x3e0 ]
_ISR_Enable( level );
2007b3c: 7f ff e8 ae call 2001df4 <sparc_enable_interrupts>
2007b40: 01 00 00 00 nop
if ( _Thread_Do_post_task_switch_extension ||
2007b44: 03 00 80 5d sethi %hi(0x2017400), %g1
2007b48: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 ! 2017488 <_Thread_Do_post_task_switch_extension>
2007b4c: 80 a0 a0 00 cmp %g2, 0
2007b50: 12 80 00 06 bne 2007b68 <_Thread_Dispatch+0x18c> <== NEVER TAKEN
2007b54: 01 00 00 00 nop
2007b58: c2 0c 60 75 ldub [ %l1 + 0x75 ], %g1
2007b5c: 80 a0 60 00 cmp %g1, 0
2007b60: 02 80 00 04 be 2007b70 <_Thread_Dispatch+0x194>
2007b64: 01 00 00 00 nop
executing->do_post_task_switch_extension ) {
executing->do_post_task_switch_extension = false;
_API_extensions_Run_postswitch();
2007b68: 7f ff f9 96 call 20061c0 <_API_extensions_Run_postswitch>
2007b6c: c0 2c 60 75 clrb [ %l1 + 0x75 ]
2007b70: 81 c7 e0 08 ret
2007b74: 81 e8 00 00 restore
0200cb7c <_Thread_Evaluate_mode>:
bool _Thread_Evaluate_mode( void )
{
Thread_Control *executing;
executing = _Thread_Executing;
200cb7c: 03 00 80 5d sethi %hi(0x2017400), %g1
200cb80: c6 00 60 a4 ld [ %g1 + 0xa4 ], %g3 ! 20174a4 <_Thread_Executing>
if ( !_States_Is_ready( executing->current_state ) ||
200cb84: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2
200cb88: 80 a0 a0 00 cmp %g2, 0
200cb8c: 12 80 00 0b bne 200cbb8 <_Thread_Evaluate_mode+0x3c> <== NEVER TAKEN
200cb90: 84 10 20 01 mov 1, %g2
200cb94: 03 00 80 5d sethi %hi(0x2017400), %g1
200cb98: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 ! 2017470 <_Thread_Heir>
200cb9c: 80 a0 c0 02 cmp %g3, %g2
200cba0: 02 80 00 0b be 200cbcc <_Thread_Evaluate_mode+0x50>
200cba4: 01 00 00 00 nop
200cba8: c2 08 e0 76 ldub [ %g3 + 0x76 ], %g1
200cbac: 80 a0 60 00 cmp %g1, 0
200cbb0: 02 80 00 07 be 200cbcc <_Thread_Evaluate_mode+0x50> <== NEVER TAKEN
200cbb4: 84 10 20 01 mov 1, %g2
( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
_Context_Switch_necessary = TRUE;
200cbb8: 03 00 80 5d sethi %hi(0x2017400), %g1
200cbbc: 90 10 20 01 mov 1, %o0
200cbc0: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ]
200cbc4: 81 c3 e0 08 retl
200cbc8: 01 00 00 00 nop
return TRUE;
}
return FALSE;
}
200cbcc: 81 c3 e0 08 retl
200cbd0: 90 10 20 00 clr %o0 ! 0 <PROM_START>
02007bb0 <_Thread_Get>:
Thread_Control *_Thread_Get (
Objects_Id id,
Objects_Locations *location
)
{
2007bb0: 86 10 00 08 mov %o0, %g3
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 ) ) {
2007bb4: 80 a2 20 00 cmp %o0, 0
2007bb8: 02 80 00 1d be 2007c2c <_Thread_Get+0x7c>
2007bbc: 94 10 00 09 mov %o1, %o2
*/
RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API(
Objects_Id id
)
{
return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS);
2007bc0: 83 32 20 18 srl %o0, 0x18, %g1
2007bc4: 82 08 60 07 and %g1, 7, %g1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
2007bc8: 84 00 7f ff add %g1, -1, %g2
2007bcc: 80 a0 a0 03 cmp %g2, 3
2007bd0: 38 80 00 14 bgu,a 2007c20 <_Thread_Get+0x70>
2007bd4: 82 10 20 01 mov 1, %g1
*location = OBJECTS_ERROR;
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
2007bd8: 89 32 20 1b srl %o0, 0x1b, %g4
2007bdc: 80 a1 20 01 cmp %g4, 1
2007be0: 12 80 00 0f bne 2007c1c <_Thread_Get+0x6c>
2007be4: 85 28 60 02 sll %g1, 2, %g2
*location = OBJECTS_ERROR;
goto done;
}
api_information = _Objects_Information_table[ the_api ];
2007be8: 03 00 80 5c sethi %hi(0x2017000), %g1
2007bec: 82 10 63 40 or %g1, 0x340, %g1 ! 2017340 <_Objects_Information_table>
2007bf0: c2 00 40 02 ld [ %g1 + %g2 ], %g1
if ( !api_information ) {
2007bf4: 80 a0 60 00 cmp %g1, 0
2007bf8: 22 80 00 17 be,a 2007c54 <_Thread_Get+0xa4>
2007bfc: c8 22 80 00 st %g4, [ %o2 ]
*location = OBJECTS_ERROR;
goto done;
}
information = api_information[ the_class ];
2007c00: d0 00 60 04 ld [ %g1 + 4 ], %o0
if ( !information ) {
2007c04: 80 a2 20 00 cmp %o0, 0
2007c08: 02 80 00 11 be 2007c4c <_Thread_Get+0x9c> <== NEVER TAKEN
2007c0c: 92 10 00 03 mov %g3, %o1
*location = OBJECTS_ERROR;
goto done;
}
tp = (Thread_Control *) _Objects_Get( information, id, location );
2007c10: 82 13 c0 00 mov %o7, %g1
2007c14: 7f ff fd 56 call 200716c <_Objects_Get>
2007c18: 9e 10 40 00 mov %g1, %o7
goto done;
}
the_class = _Objects_Get_class( id );
if ( the_class != 1 ) { /* threads are always first class :) */
*location = OBJECTS_ERROR;
2007c1c: 82 10 20 01 mov 1, %g1
2007c20: 90 10 20 00 clr %o0
2007c24: 81 c3 e0 08 retl
2007c28: c2 22 80 00 st %g1, [ %o2 ]
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
2007c2c: 03 00 80 5c sethi %hi(0x2017000), %g1
2007c30: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20173e0 <_Thread_Dispatch_disable_level>
2007c34: 84 00 a0 01 inc %g2
2007c38: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
Thread_Control *tp = (Thread_Control *) 0;
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) {
_Thread_Disable_dispatch();
*location = OBJECTS_LOCAL;
tp = _Thread_Executing;
2007c3c: 03 00 80 5d sethi %hi(0x2017400), %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;
2007c40: c0 22 40 00 clr [ %o1 ]
tp = _Thread_Executing;
2007c44: 81 c3 e0 08 retl
2007c48: d0 00 60 a4 ld [ %g1 + 0xa4 ], %o0
goto done;
}
information = api_information[ the_class ];
if ( !information ) {
*location = OBJECTS_ERROR;
2007c4c: 81 c3 e0 08 retl <== NOT EXECUTED
2007c50: c8 22 80 00 st %g4, [ %o2 ] <== NOT EXECUTED
goto done;
}
api_information = _Objects_Information_table[ the_api ];
if ( !api_information ) {
*location = OBJECTS_ERROR;
2007c54: 81 c3 e0 08 retl
2007c58: 90 10 20 00 clr %o0
0200cbd4 <_Thread_Handler>:
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
200cbd4: 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;
200cbd8: 03 00 80 5d sethi %hi(0x2017400), %g1
200cbdc: e0 00 60 a4 ld [ %g1 + 0xa4 ], %l0 ! 20174a4 <_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();
200cbe0: 3f 00 80 32 sethi %hi(0x200c800), %i7
200cbe4: be 17 e3 d4 or %i7, 0x3d4, %i7 ! 200cbd4 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
200cbe8: d0 04 20 b8 ld [ %l0 + 0xb8 ], %o0
_ISR_Set_level(level);
200cbec: 7f ff d4 82 call 2001df4 <sparc_enable_interrupts>
200cbf0: 91 2a 20 08 sll %o0, 8, %o0
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
doneCons = doneConstructors;
200cbf4: 07 00 80 5c sethi %hi(0x2017000), %g3
doneConstructors = 1;
200cbf8: 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;
200cbfc: e4 08 e0 f8 ldub [ %g3 + 0xf8 ], %l2
doneConstructors = 1;
200cc00: c2 28 e0 f8 stb %g1, [ %g3 + 0xf8 ]
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) {
200cc04: c4 04 21 60 ld [ %l0 + 0x160 ], %g2
200cc08: 80 a0 a0 00 cmp %g2, 0
200cc0c: 02 80 00 0b be 200cc38 <_Thread_Handler+0x64>
200cc10: 23 00 80 5d sethi %hi(0x2017400), %l1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
200cc14: d0 04 60 68 ld [ %l1 + 0x68 ], %o0 ! 2017468 <_Thread_Allocated_fp>
200cc18: 80 a4 00 08 cmp %l0, %o0
200cc1c: 02 80 00 07 be 200cc38 <_Thread_Handler+0x64>
200cc20: 80 a2 20 00 cmp %o0, 0
if ( _Thread_Allocated_fp != NULL )
200cc24: 22 80 00 05 be,a 200cc38 <_Thread_Handler+0x64>
200cc28: e0 24 60 68 st %l0, [ %l1 + 0x68 ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200cc2c: 7f ff f1 93 call 2009278 <_CPU_Context_save_fp>
200cc30: 90 02 21 60 add %o0, 0x160, %o0
_Thread_Allocated_fp = executing;
200cc34: e0 24 60 68 st %l0, [ %l1 + 0x68 ]
* 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 );
200cc38: 7f ff ef f4 call 2008c08 <_User_extensions_Thread_begin>
200cc3c: 90 10 00 10 mov %l0, %o0
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
200cc40: 7f ff eb ce call 2007b78 <_Thread_Enable_dispatch>
200cc44: 01 00 00 00 nop
/*
* _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) */
200cc48: 83 2c a0 18 sll %l2, 0x18, %g1
200cc4c: 80 a0 60 00 cmp %g1, 0
200cc50: 02 80 00 1e be 200ccc8 <_Thread_Handler+0xf4>
200cc54: 01 00 00 00 nop
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
200cc58: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1
200cc5c: 80 a0 60 01 cmp %g1, 1
200cc60: 22 80 00 21 be,a 200cce4 <_Thread_Handler+0x110> <== NEVER TAKEN
200cc64: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
200cc68: 80 a0 60 01 cmp %g1, 1
200cc6c: 1a 80 00 0c bcc 200cc9c <_Thread_Handler+0xc8> <== NEVER TAKEN
200cc70: 80 a0 60 02 cmp %g1, 2
case THREAD_START_NUMERIC:
executing->Wait.return_argument =
200cc74: c2 04 20 9c ld [ %l0 + 0x9c ], %g1
200cc78: 9f c0 40 00 call %g1
200cc7c: d0 04 20 a8 ld [ %l0 + 0xa8 ], %o0
200cc80: d0 24 20 28 st %o0, [ %l0 + 0x28 ]
* 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 );
200cc84: 7f ff ef f5 call 2008c58 <_User_extensions_Thread_exitted>
200cc88: 90 10 00 10 mov %l0, %o0
_Internal_error_Occurred(
200cc8c: 90 10 20 00 clr %o0
200cc90: 92 10 20 01 mov 1, %o1
200cc94: 7f ff e7 9e call 2006b0c <_Internal_error_Occurred>
200cc98: 94 10 20 06 mov 6, %o2
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
200cc9c: 22 80 00 16 be,a 200ccf4 <_Thread_Handler+0x120> <== NOT EXECUTED
200cca0: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
200cca4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
200cca8: 12 bf ff f7 bne 200cc84 <_Thread_Handler+0xb0> <== NOT EXECUTED
200ccac: 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 =
200ccb0: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
200ccb4: d0 04 20 a8 ld [ %l0 + 0xa8 ], %o0 <== NOT EXECUTED
200ccb8: 9f c0 40 00 call %g1 <== NOT EXECUTED
200ccbc: d2 04 20 a4 ld [ %l0 + 0xa4 ], %o1 <== NOT EXECUTED
200ccc0: 10 bf ff f1 b 200cc84 <_Thread_Handler+0xb0> <== NOT EXECUTED
200ccc4: d0 24 20 28 st %o0, [ %l0 + 0x28 ] <== NOT EXECUTED
* 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) */
{
_init ();
200ccc8: 40 00 26 20 call 2016548 <_init>
200cccc: 01 00 00 00 nop
#if defined(__USE__MAIN__)
if (!doneCons && _main)
__main ();
#endif
switch ( executing->Start.prototype ) {
200ccd0: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1
200ccd4: 80 a0 60 01 cmp %g1, 1
200ccd8: 12 bf ff e5 bne 200cc6c <_Thread_Handler+0x98> <== ALWAYS TAKEN
200ccdc: 01 00 00 00 nop
(*(Thread_Entry_numeric) executing->Start.entry_point)(
executing->Start.numeric_argument
);
break;
case THREAD_START_POINTER:
executing->Wait.return_argument =
200cce0: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
200cce4: 9f c0 40 00 call %g1 <== NOT EXECUTED
200cce8: d0 04 20 a4 ld [ %l0 + 0xa4 ], %o0 <== NOT EXECUTED
200ccec: 10 bf ff e6 b 200cc84 <_Thread_Handler+0xb0> <== NOT EXECUTED
200ccf0: d0 24 20 28 st %o0, [ %l0 + 0x28 ] <== NOT EXECUTED
(*(Thread_Entry_pointer) executing->Start.entry_point)(
executing->Start.pointer_argument
);
break;
case THREAD_START_BOTH_POINTER_FIRST:
executing->Wait.return_argument =
200ccf4: d0 04 20 a4 ld [ %l0 + 0xa4 ], %o0 <== NOT EXECUTED
200ccf8: 9f c0 40 00 call %g1 <== NOT EXECUTED
200ccfc: d2 04 20 a8 ld [ %l0 + 0xa8 ], %o1 <== NOT EXECUTED
200cd00: 10 bf ff e1 b 200cc84 <_Thread_Handler+0xb0> <== NOT EXECUTED
200cd04: d0 24 20 28 st %o0, [ %l0 + 0x28 ] <== NOT EXECUTED
02007c60 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
2007c60: 9d e3 bf 98 save %sp, -104, %sp
2007c64: c2 07 a0 6c ld [ %fp + 0x6c ], %g1
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
2007c68: 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
)
{
2007c6c: e4 00 40 00 ld [ %g1 ], %l2
2007c70: e6 07 a0 60 ld [ %fp + 0x60 ], %l3
/*
* Allocate and Initialize the stack for this thread.
*/
if ( !stack_area ) {
2007c74: 02 80 00 69 be 2007e18 <_Thread_Initialize+0x1b8> <== ALWAYS TAKEN
2007c78: e2 0f a0 5f ldub [ %fp + 0x5f ], %l1
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = TRUE;
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = FALSE;
2007c7c: c0 2e 60 c0 clrb [ %i1 + 0xc0 ] <== NOT EXECUTED
2007c80: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
2007c84: f4 26 60 c8 st %i2, [ %i1 + 0xc8 ]
the_stack->size = size;
2007c88: d0 26 60 c4 st %o0, [ %i1 + 0xc4 ]
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
2007c8c: 80 8f 20 ff btst 0xff, %i4
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
if ( !fp_area ) {
_Thread_Stack_Free( the_thread );
return FALSE;
2007c90: b4 10 20 00 clr %i2
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
2007c94: 12 80 00 43 bne 2007da0 <_Thread_Initialize+0x140>
2007c98: 82 10 20 00 clr %g1
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
2007c9c: 37 00 80 5d sethi %hi(0x2017400), %i3
2007ca0: d0 06 e0 84 ld [ %i3 + 0x84 ], %o0 ! 2017484 <_Thread_Maximum_extensions>
} else
fp_area = NULL;
the_thread->fp_context = fp_area;
the_thread->Start.fp_context = fp_area;
2007ca4: c2 26 60 cc st %g1, [ %i1 + 0xcc ]
fp_area = _Context_Fp_start( fp_area, 0 );
} else
fp_area = NULL;
the_thread->fp_context = fp_area;
2007ca8: c2 26 61 60 st %g1, [ %i1 + 0x160 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2007cac: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
2007cb0: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
2007cb4: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
2007cb8: c0 26 60 6c clr [ %i1 + 0x6c ]
/*
* Clear the libc reent hook.
*/
the_thread->libc_reent = NULL;
2007cbc: c0 26 61 64 clr [ %i1 + 0x164 ]
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
2007cc0: 80 a2 20 00 cmp %o0, 0
2007cc4: 12 80 00 41 bne 2007dc8 <_Thread_Initialize+0x168>
2007cc8: b8 16 e0 84 or %i3, 0x84, %i4
return FALSE;
}
} else
extensions_area = NULL;
the_thread->extensions = (void **) extensions_area;
2007ccc: c0 26 61 74 clr [ %i1 + 0x174 ]
2007cd0: a0 10 20 00 clr %l0
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
2007cd4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
2007cd8: e2 2e 60 ac stb %l1, [ %i1 + 0xac ]
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
2007cdc: c2 26 60 b4 st %g1, [ %i1 + 0xb4 ]
switch ( budget_algorithm ) {
2007ce0: 80 a4 e0 02 cmp %l3, 2
2007ce4: 12 80 00 05 bne 2007cf8 <_Thread_Initialize+0x98> <== ALWAYS TAKEN
2007ce8: e6 26 60 b0 st %l3, [ %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;
2007cec: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
2007cf0: c4 00 63 38 ld [ %g1 + 0x338 ], %g2 ! 2017338 <_Thread_Ticks_per_timeslice><== NOT EXECUTED
2007cf4: c4 26 60 78 st %g2, [ %i1 + 0x78 ] <== NOT EXECUTED
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
2007cf8: 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 );
2007cfc: 92 10 00 1d mov %i5, %o1
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
}
the_thread->Start.isr_level = isr_level;
2007d00: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ]
the_thread->current_state = STATES_DORMANT;
2007d04: 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 );
2007d08: 90 10 00 19 mov %i1, %o0
break;
}
the_thread->Start.isr_level = isr_level;
the_thread->current_state = STATES_DORMANT;
2007d0c: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
the_thread->Wait.queue = NULL;
2007d10: c0 26 60 44 clr [ %i1 + 0x44 ]
the_thread->resource_count = 0;
2007d14: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->suspend_count = 0;
2007d18: c0 26 60 70 clr [ %i1 + 0x70 ]
the_thread->real_priority = priority;
2007d1c: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
_Thread_Set_priority( the_thread, priority );
2007d20: 40 00 02 1a call 2008588 <_Thread_Set_priority>
2007d24: fa 26 60 bc st %i5, [ %i1 + 0xbc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007d28: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007d2c: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
2007d30: 03 00 00 3f sethi %hi(0xfc00), %g1
2007d34: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2007d38: 84 08 80 01 and %g2, %g1, %g2
2007d3c: 85 28 a0 02 sll %g2, 2, %g2
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2007d40: 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;
2007d44: c0 26 60 84 clr [ %i1 + 0x84 ]
the_thread->cpu_time_used.tv_nsec = 0;
2007d48: c0 26 60 88 clr [ %i1 + 0x88 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007d4c: 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 );
2007d50: 90 10 00 19 mov %i1, %o0
2007d54: 40 00 03 e9 call 2008cf8 <_User_extensions_Thread_create>
2007d58: b0 10 20 01 mov 1, %i0
if ( !extension_status ) {
2007d5c: 80 8a 20 ff btst 0xff, %o0
2007d60: 12 80 00 0e bne 2007d98 <_Thread_Initialize+0x138> <== ALWAYS TAKEN
2007d64: 80 a4 20 00 cmp %l0, 0
if ( extensions_area )
2007d68: 02 80 00 05 be 2007d7c <_Thread_Initialize+0x11c> <== NOT EXECUTED
2007d6c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
(void) _Workspace_Free( extensions_area );
2007d70: 40 00 05 04 call 2009180 <_Workspace_Free> <== NOT EXECUTED
2007d74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
2007d78: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2007d7c: 02 80 00 05 be 2007d90 <_Thread_Initialize+0x130> <== NOT EXECUTED
2007d80: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
(void) _Workspace_Free( fp_area );
2007d84: 40 00 04 ff call 2009180 <_Workspace_Free> <== NOT EXECUTED
2007d88: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
2007d8c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2007d90: 40 00 02 ba call 2008878 <_Thread_Stack_Free> <== NOT EXECUTED
2007d94: b0 10 20 00 clr %i0 <== NOT EXECUTED
return FALSE;
}
return TRUE;
}
2007d98: 81 c7 e0 08 ret
2007d9c: 81 e8 00 00 restore
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
2007da0: 40 00 04 ff call 200919c <_Workspace_Allocate>
2007da4: 90 10 20 88 mov 0x88, %o0
if ( !fp_area ) {
2007da8: b4 92 20 00 orcc %o0, 0, %i2
2007dac: 12 bf ff bc bne 2007c9c <_Thread_Initialize+0x3c> <== ALWAYS TAKEN
2007db0: 82 10 00 1a mov %i2, %g1
_Thread_Stack_Free( the_thread );
2007db4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2007db8: 40 00 02 b0 call 2008878 <_Thread_Stack_Free> <== NOT EXECUTED
2007dbc: b0 10 20 00 clr %i0 <== NOT EXECUTED
2007dc0: 81 c7 e0 08 ret <== NOT EXECUTED
2007dc4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
extensions_area = _Workspace_Allocate(
2007dc8: 90 02 20 01 inc %o0
2007dcc: 40 00 04 f4 call 200919c <_Workspace_Allocate>
2007dd0: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
2007dd4: a0 92 20 00 orcc %o0, 0, %l0
2007dd8: 02 80 00 1b be 2007e44 <_Thread_Initialize+0x1e4> <== NEVER TAKEN
2007ddc: c2 06 e0 84 ld [ %i3 + 0x84 ], %g1
* call.
*/
if ( the_thread->extensions ) {
uint32_t i;
for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
2007de0: 80 a0 7f ff cmp %g1, -1
2007de4: 02 bf ff bc be 2007cd4 <_Thread_Initialize+0x74> <== NEVER TAKEN
2007de8: e0 26 61 74 st %l0, [ %i1 + 0x174 ]
2007dec: 86 10 20 00 clr %g3
2007df0: 88 10 00 10 mov %l0, %g4
2007df4: c4 07 00 00 ld [ %i4 ], %g2
the_thread->extensions[i] = NULL;
2007df8: 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++ )
2007dfc: 86 00 e0 01 inc %g3
2007e00: 84 00 a0 01 inc %g2
2007e04: 80 a0 80 03 cmp %g2, %g3
2007e08: 18 bf ff fb bgu 2007df4 <_Thread_Initialize+0x194>
2007e0c: c0 21 00 01 clr [ %g4 + %g1 ]
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
2007e10: 10 bf ff b2 b 2007cd8 <_Thread_Initialize+0x78>
2007e14: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
*/
if ( !stack_area ) {
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
2007e18: 90 10 00 19 mov %i1, %o0
2007e1c: 40 00 02 7b call 2008808 <_Thread_Stack_Allocate>
2007e20: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
2007e24: 80 a2 20 00 cmp %o0, 0
2007e28: 02 80 00 0e be 2007e60 <_Thread_Initialize+0x200>
2007e2c: 80 a6 c0 08 cmp %i3, %o0
2007e30: 18 80 00 0c bgu 2007e60 <_Thread_Initialize+0x200> <== NEVER TAKEN
2007e34: 82 10 20 01 mov 1, %g1
return FALSE; /* stack allocation failed */
stack = the_thread->Start.stack;
2007e38: f4 06 60 d0 ld [ %i1 + 0xd0 ], %i2
the_thread->Start.core_allocated_stack = TRUE;
2007e3c: 10 bf ff 92 b 2007c84 <_Thread_Initialize+0x24>
2007e40: c2 2e 60 c0 stb %g1, [ %i1 + 0xc0 ]
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area ) {
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( fp_area )
2007e44: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2007e48: 02 80 00 04 be 2007e58 <_Thread_Initialize+0x1f8> <== NOT EXECUTED
2007e4c: 01 00 00 00 nop <== NOT EXECUTED
(void) _Workspace_Free( fp_area );
2007e50: 40 00 04 cc call 2009180 <_Workspace_Free> <== NOT EXECUTED
2007e54: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
#endif
_Thread_Stack_Free( the_thread );
2007e58: 40 00 02 88 call 2008878 <_Thread_Stack_Free> <== NOT EXECUTED
2007e5c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2007e60: 81 c7 e0 08 ret
2007e64: 91 e8 20 00 restore %g0, 0, %o0
0200cf54 <_Thread_Reset>:
void _Thread_Reset(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
200cf54: 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;
200cf58: 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;
200cf5c: c2 0e 20 ac ldub [ %i0 + 0xac ], %g1
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200cf60: 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;
200cf64: 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;
200cf68: c6 26 20 80 st %g3, [ %i0 + 0x80 ]
the_thread->Start.pointer_argument = pointer_argument;
200cf6c: f2 26 20 a4 st %i1, [ %i0 + 0xa4 ]
the_thread->Start.numeric_argument = numeric_argument;
200cf70: 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;
200cf74: c0 26 20 1c clr [ %i0 + 0x1c ]
the_thread->suspend_count = 0;
200cf78: 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 ) ) {
200cf7c: 7f ff f0 09 call 2008fa0 <_Thread_queue_Extract_with_proxy>
200cf80: 90 10 00 18 mov %i0, %o0
200cf84: 80 8a 20 ff btst 0xff, %o0
200cf88: 32 80 00 07 bne,a 200cfa4 <_Thread_Reset+0x50>
200cf8c: f2 06 20 bc ld [ %i0 + 0xbc ], %i1
if ( _Watchdog_Is_active( &the_thread->Timer ) )
200cf90: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200cf94: 80 a0 60 02 cmp %g1, 2
200cf98: 02 80 00 0c be 200cfc8 <_Thread_Reset+0x74> <== NEVER TAKEN
200cf9c: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_thread->Timer );
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
200cfa0: f2 06 20 bc ld [ %i0 + 0xbc ], %i1
200cfa4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200cfa8: 80 a0 40 19 cmp %g1, %i1
200cfac: 02 80 00 05 be 200cfc0 <_Thread_Reset+0x6c>
200cfb0: 01 00 00 00 nop
the_thread->real_priority = the_thread->Start.initial_priority;
200cfb4: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
_Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
200cfb8: 7f ff f0 81 call 20091bc <_Thread_Set_priority>
200cfbc: 81 e8 00 00 restore
200cfc0: 81 c7 e0 08 ret
200cfc4: 81 e8 00 00 restore
the_thread->Start.numeric_argument = numeric_argument;
if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
if ( _Watchdog_Is_active( &the_thread->Timer ) )
(void) _Watchdog_Remove( &the_thread->Timer );
200cfc8: 7f ff f3 2f call 2009c84 <_Watchdog_Remove> <== NOT EXECUTED
200cfcc: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED
}
if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
200cfd0: 10 bf ff f5 b 200cfa4 <_Thread_Reset+0x50> <== NOT EXECUTED
200cfd4: f2 06 20 bc ld [ %i0 + 0xbc ], %i1 <== NOT EXECUTED
0200c208 <_Thread_Reset_timeslice>:
* ready chain
* select heir
*/
void _Thread_Reset_timeslice( void )
{
200c208: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
200c20c: 03 00 80 5d sethi %hi(0x2017400), %g1
200c210: e0 00 60 a4 ld [ %g1 + 0xa4 ], %l0 ! 20174a4 <_Thread_Executing>
ready = executing->ready;
_ISR_Disable( level );
200c214: 7f ff d6 f4 call 2001de4 <sparc_disable_interrupts>
200c218: e2 04 20 8c ld [ %l0 + 0x8c ], %l1
200c21c: b0 10 00 08 mov %o0, %i0
if ( _Chain_Has_only_one_node( ready ) ) {
200c220: c4 04 40 00 ld [ %l1 ], %g2
200c224: c2 04 60 08 ld [ %l1 + 8 ], %g1
200c228: 80 a0 80 01 cmp %g2, %g1
200c22c: 02 80 00 18 be 200c28c <_Thread_Reset_timeslice+0x84>
200c230: 82 04 60 04 add %l1, 4, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200c234: c6 04 00 00 ld [ %l0 ], %g3
previous = the_node->previous;
200c238: c4 04 20 04 ld [ %l0 + 4 ], %g2
next->previous = previous;
previous->next = next;
200c23c: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
200c240: c2 24 00 00 st %g1, [ %l0 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
200c244: 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;
200c248: c2 04 60 08 ld [ %l1 + 8 ], %g1
the_chain->last = the_node;
200c24c: e0 24 60 08 st %l0, [ %l1 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
200c250: 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;
200c254: e0 20 40 00 st %l0, [ %g1 ]
return;
}
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
200c258: 7f ff d6 e7 call 2001df4 <sparc_enable_interrupts>
200c25c: 01 00 00 00 nop
200c260: 7f ff d6 e1 call 2001de4 <sparc_disable_interrupts>
200c264: 01 00 00 00 nop
if ( _Thread_Is_heir( executing ) )
200c268: 07 00 80 5d sethi %hi(0x2017400), %g3
200c26c: c2 00 e0 70 ld [ %g3 + 0x70 ], %g1 ! 2017470 <_Thread_Heir>
200c270: 80 a4 00 01 cmp %l0, %g1
200c274: 02 80 00 08 be 200c294 <_Thread_Reset_timeslice+0x8c> <== ALWAYS TAKEN
200c278: 84 10 20 01 mov 1, %g2
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
200c27c: 03 00 80 5d sethi %hi(0x2017400), %g1 <== NOT EXECUTED
200c280: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ] ! 20174b4 <_Context_Switch_necessary><== NOT EXECUTED
_ISR_Enable( level );
200c284: 7f ff d6 dc call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200c288: 81 e8 00 00 restore <== NOT EXECUTED
executing = _Thread_Executing;
ready = executing->ready;
_ISR_Disable( level );
if ( _Chain_Has_only_one_node( ready ) ) {
_ISR_Enable( level );
200c28c: 7f ff d6 da call 2001df4 <sparc_enable_interrupts>
200c290: 81 e8 00 00 restore
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
200c294: c2 04 40 00 ld [ %l1 ], %g1
200c298: c2 20 e0 70 st %g1, [ %g3 + 0x70 ]
_Context_Switch_necessary = TRUE;
200c29c: 03 00 80 5d sethi %hi(0x2017400), %g1
200c2a0: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ] ! 20174b4 <_Context_Switch_necessary>
_ISR_Enable( level );
200c2a4: 7f ff d6 d4 call 2001df4 <sparc_enable_interrupts>
200c2a8: 81 e8 00 00 restore
02009ed0 <_Thread_Resume>:
void _Thread_Resume(
Thread_Control *the_thread,
bool force
)
{
2009ed0: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
2009ed4: 7f ff e2 e1 call 2002a58 <sparc_disable_interrupts>
2009ed8: 01 00 00 00 nop
2009edc: a0 10 00 08 mov %o0, %l0
if ( force == TRUE )
2009ee0: 80 8e 60 ff btst 0xff, %i1
2009ee4: 22 80 00 0d be,a 2009f18 <_Thread_Resume+0x48> <== NEVER TAKEN
2009ee8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED
the_thread->suspend_count = 0;
2009eec: c0 26 20 70 clr [ %i0 + 0x70 ]
if ( the_thread->suspend_count > 0 ) {
_ISR_Enable( level );
return;
}
current_state = the_thread->current_state;
2009ef0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
if ( current_state & STATES_SUSPENDED ) {
2009ef4: 80 88 60 02 btst 2, %g1
2009ef8: 02 80 00 06 be 2009f10 <_Thread_Resume+0x40> <== NEVER TAKEN
2009efc: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
2009f00: 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 ) ) {
2009f04: 80 a0 60 00 cmp %g1, 0
2009f08: 02 80 00 0a be 2009f30 <_Thread_Resume+0x60>
2009f0c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
_Context_Switch_necessary = TRUE;
}
}
}
_ISR_Enable( level );
2009f10: 7f ff e2 d6 call 2002a68 <sparc_enable_interrupts>
2009f14: 91 e8 00 10 restore %g0, %l0, %o0
_ISR_Disable( level );
if ( force == TRUE )
the_thread->suspend_count = 0;
else
the_thread->suspend_count--;
2009f18: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
if ( the_thread->suspend_count > 0 ) {
2009f1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2009f20: 02 bf ff f4 be 2009ef0 <_Thread_Resume+0x20> <== NOT EXECUTED
2009f24: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED
_ISR_Enable( level );
2009f28: 7f ff e2 d0 call 2002a68 <sparc_enable_interrupts> <== NOT EXECUTED
2009f2c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
2009f30: c8 06 20 90 ld [ %i0 + 0x90 ], %g4
2009f34: c4 16 20 96 lduh [ %i0 + 0x96 ], %g2
2009f38: c2 11 00 00 lduh [ %g4 ], %g1
if ( _States_Is_ready( current_state ) ) {
_Priority_Add_to_bit_map( &the_thread->Priority_map );
_Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
2009f3c: c6 06 20 8c ld [ %i0 + 0x8c ], %g3
2009f40: 82 10 40 02 or %g1, %g2, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
2009f44: 1b 00 80 8e sethi %hi(0x2023800), %o5
RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map (
Priority_Information *the_priority_map
)
{
*the_priority_map->minor |= the_priority_map->ready_minor;
2009f48: c2 31 00 00 sth %g1, [ %g4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
2009f4c: 82 00 e0 04 add %g3, 4, %g1
_Priority_Major_bit_map |= the_priority_map->ready_major;
2009f50: d8 16 20 94 lduh [ %i0 + 0x94 ], %o4
2009f54: c2 26 00 00 st %g1, [ %i0 ]
2009f58: c4 13 61 08 lduh [ %o5 + 0x108 ], %g2
old_last_node = the_chain->last;
2009f5c: c8 00 e0 08 ld [ %g3 + 8 ], %g4
the_chain->last = the_node;
2009f60: f0 20 e0 08 st %i0, [ %g3 + 8 ]
2009f64: 84 10 80 0c or %g2, %o4, %g2
old_last_node->next = the_node;
the_node->previous = old_last_node;
2009f68: c8 26 20 04 st %g4, [ %i0 + 4 ]
2009f6c: c4 33 61 08 sth %g2, [ %o5 + 0x108 ]
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;
2009f70: f0 21 00 00 st %i0, [ %g4 ]
_ISR_Flash( level );
2009f74: 7f ff e2 bd call 2002a68 <sparc_enable_interrupts>
2009f78: 90 10 00 10 mov %l0, %o0
2009f7c: 7f ff e2 b7 call 2002a58 <sparc_disable_interrupts>
2009f80: 01 00 00 00 nop
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
2009f84: 09 00 80 8e sethi %hi(0x2023800), %g4
2009f88: c4 01 20 e0 ld [ %g4 + 0xe0 ], %g2 ! 20238e0 <_Thread_Heir>
2009f8c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
2009f90: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
2009f94: 80 a0 c0 01 cmp %g3, %g1
2009f98: 1a bf ff de bcc 2009f10 <_Thread_Resume+0x40>
2009f9c: 01 00 00 00 nop
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
2009fa0: 03 00 80 8e sethi %hi(0x2023800), %g1
2009fa4: c4 00 61 14 ld [ %g1 + 0x114 ], %g2 ! 2023914 <_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;
2009fa8: f0 21 20 e0 st %i0, [ %g4 + 0xe0 ]
if ( _Thread_Executing->is_preemptible ||
2009fac: c2 08 a0 76 ldub [ %g2 + 0x76 ], %g1
2009fb0: 80 a0 60 00 cmp %g1, 0
2009fb4: 02 80 00 06 be 2009fcc <_Thread_Resume+0xfc>
2009fb8: 80 a0 e0 00 cmp %g3, 0
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
2009fbc: 84 10 20 01 mov 1, %g2
2009fc0: 03 00 80 8e sethi %hi(0x2023800), %g1
2009fc4: c4 28 61 24 stb %g2, [ %g1 + 0x124 ] ! 2023924 <_Context_Switch_necessary>
2009fc8: 30 bf ff d2 b,a 2009f10 <_Thread_Resume+0x40>
_ISR_Flash( level );
if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
2009fcc: 12 bf ff d1 bne 2009f10 <_Thread_Resume+0x40> <== ALWAYS TAKEN
2009fd0: 84 10 20 01 mov 1, %g2
the_thread->current_priority == 0 )
_Context_Switch_necessary = TRUE;
2009fd4: 10 bf ff fc b 2009fc4 <_Thread_Resume+0xf4> <== NOT EXECUTED
2009fd8: 03 00 80 8e sethi %hi(0x2023800), %g1 <== NOT EXECUTED
02008808 <_Thread_Stack_Allocate>:
size_t _Thread_Stack_Allocate(
Thread_Control *the_thread,
size_t stack_size
)
{
2008808: 9d e3 bf 98 save %sp, -104, %sp
200880c: 03 00 80 59 sethi %hi(0x2016400), %g1
2008810: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 2016630 <rtems_minimum_stack_size>
2008814: 80 a6 40 01 cmp %i1, %g1
2008818: 2a 80 00 02 bcs,a 2008820 <_Thread_Stack_Allocate+0x18>
200881c: 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 ) {
2008820: 03 00 80 5d sethi %hi(0x2017400), %g1
2008824: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201747c <_Configuration_Table>
2008828: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1
200882c: 80 a0 60 00 cmp %g1, 0
2008830: 22 80 00 0a be,a 2008858 <_Thread_Stack_Allocate+0x50> <== ALWAYS TAKEN
2008834: b2 06 60 10 add %i1, 0x10, %i1
stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
2008838: 9f c0 40 00 call %g1 <== NOT EXECUTED
200883c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
if ( !stack_addr )
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
2008840: d0 26 20 d0 st %o0, [ %i0 + 0xd0 ] <== NOT EXECUTED
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
2008844: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
2008848: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
return the_stack_size;
}
200884c: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED
2008850: 81 c7 e0 08 ret <== NOT EXECUTED
2008854: 81 e8 00 00 restore <== 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 );
2008858: 40 00 02 51 call 200919c <_Workspace_Allocate>
200885c: 90 10 00 19 mov %i1, %o0
}
if ( !stack_addr )
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
2008860: d0 26 20 d0 st %o0, [ %i0 + 0xd0 ]
the_stack_size = _Stack_Adjust_size( the_stack_size );
stack_addr = _Workspace_Allocate( the_stack_size );
}
if ( !stack_addr )
2008864: 80 a0 00 08 cmp %g0, %o0
2008868: b0 60 20 00 subx %g0, 0, %i0
the_stack_size = 0;
the_thread->Start.stack = stack_addr;
return the_stack_size;
}
200886c: b0 0e 40 18 and %i1, %i0, %i0
2008870: 81 c7 e0 08 ret
2008874: 81 e8 00 00 restore
02008878 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
2008878: 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 )
200887c: c2 0e 20 c0 ldub [ %i0 + 0xc0 ], %g1
2008880: 80 a0 60 00 cmp %g1, 0
2008884: 02 80 00 09 be 20088a8 <_Thread_Stack_Free+0x30> <== NEVER TAKEN
2008888: 03 00 80 5d sethi %hi(0x2017400), %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 )
200888c: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201747c <_Configuration_Table>
2008890: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1
2008894: 80 a0 60 00 cmp %g1, 0
2008898: 22 80 00 06 be,a 20088b0 <_Thread_Stack_Free+0x38> <== ALWAYS TAKEN
200889c: f0 06 20 c8 ld [ %i0 + 0xc8 ], %i0
(*_Configuration_Table->stack_free_hook)(
20088a0: 9f c0 40 00 call %g1 <== NOT EXECUTED
20088a4: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED
20088a8: 81 c7 e0 08 ret <== NOT EXECUTED
20088ac: 81 e8 00 00 restore <== NOT EXECUTED
the_thread->Start.Initial_stack.area
);
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
20088b0: 40 00 02 34 call 2009180 <_Workspace_Free>
20088b4: 81 e8 00 00 restore
0200895c <_Thread_Tickle_timeslice>:
*
* Output parameters: NONE
*/
void _Thread_Tickle_timeslice( void )
{
200895c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *executing;
executing = _Thread_Executing;
2008960: 03 00 80 5d sethi %hi(0x2017400), %g1
2008964: e0 00 60 a4 ld [ %g1 + 0xa4 ], %l0 ! 20174a4 <_Thread_Executing>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
2008968: c4 0c 20 76 ldub [ %l0 + 0x76 ], %g2
200896c: 80 a0 a0 00 cmp %g2, 0
2008970: 02 80 00 23 be 20089fc <_Thread_Tickle_timeslice+0xa0>
2008974: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
2008978: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
200897c: 80 a0 60 00 cmp %g1, 0
2008980: 12 80 00 1f bne 20089fc <_Thread_Tickle_timeslice+0xa0> <== NEVER TAKEN
2008984: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
2008988: c2 04 20 7c ld [ %l0 + 0x7c ], %g1
200898c: 80 a0 60 01 cmp %g1, 1
2008990: 0a 80 00 07 bcs 20089ac <_Thread_Tickle_timeslice+0x50>
2008994: 80 a0 60 02 cmp %g1, 2
2008998: 28 80 00 10 bleu,a 20089d8 <_Thread_Tickle_timeslice+0x7c><== ALWAYS TAKEN
200899c: c2 04 20 78 ld [ %l0 + 0x78 ], %g1
20089a0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
20089a4: 22 80 00 04 be,a 20089b4 <_Thread_Tickle_timeslice+0x58> <== NOT EXECUTED
20089a8: c2 04 20 78 ld [ %l0 + 0x78 ], %g1 <== NOT EXECUTED
20089ac: 81 c7 e0 08 ret
20089b0: 81 e8 00 00 restore
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
}
break;
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
20089b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20089b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20089bc: 12 bf ff fc bne 20089ac <_Thread_Tickle_timeslice+0x50> <== NOT EXECUTED
20089c0: c2 24 20 78 st %g1, [ %l0 + 0x78 ] <== NOT EXECUTED
(*executing->budget_callout)( executing );
20089c4: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 <== NOT EXECUTED
20089c8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20089cc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20089d0: 81 c7 e0 08 ret <== NOT EXECUTED
20089d4: 81 e8 00 00 restore <== 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 ) {
20089d8: 82 00 7f ff add %g1, -1, %g1
20089dc: 80 a0 60 00 cmp %g1, 0
20089e0: 14 bf ff f3 bg 20089ac <_Thread_Tickle_timeslice+0x50>
20089e4: c2 24 20 78 st %g1, [ %l0 + 0x78 ]
_Thread_Reset_timeslice();
20089e8: 40 00 0e 08 call 200c208 <_Thread_Reset_timeslice>
20089ec: 01 00 00 00 nop
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
20089f0: 03 00 80 5c sethi %hi(0x2017000), %g1
20089f4: c4 00 63 38 ld [ %g1 + 0x338 ], %g2 ! 2017338 <_Thread_Ticks_per_timeslice>
20089f8: c4 24 20 78 st %g2, [ %l0 + 0x78 ]
20089fc: 81 c7 e0 08 ret
2008a00: 81 e8 00 00 restore
02008a04 <_Thread_Yield_processor>:
* ready chain
* select heir
*/
void _Thread_Yield_processor( void )
{
2008a04: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Thread_Control *executing;
Chain_Control *ready;
executing = _Thread_Executing;
2008a08: 03 00 80 5d sethi %hi(0x2017400), %g1
2008a0c: e0 00 60 a4 ld [ %g1 + 0xa4 ], %l0 ! 20174a4 <_Thread_Executing>
ready = executing->ready;
_ISR_Disable( level );
2008a10: 7f ff e4 f5 call 2001de4 <sparc_disable_interrupts>
2008a14: e2 04 20 8c ld [ %l0 + 0x8c ], %l1
2008a18: b0 10 00 08 mov %o0, %i0
if ( !_Chain_Has_only_one_node( ready ) ) {
2008a1c: c4 04 40 00 ld [ %l1 ], %g2
2008a20: c2 04 60 08 ld [ %l1 + 8 ], %g1
2008a24: 80 a0 80 01 cmp %g2, %g1
2008a28: 02 80 00 19 be 2008a8c <_Thread_Yield_processor+0x88>
2008a2c: 82 04 60 04 add %l1, 4, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2008a30: c6 04 00 00 ld [ %l0 ], %g3
previous = the_node->previous;
2008a34: c4 04 20 04 ld [ %l0 + 4 ], %g2
next->previous = previous;
previous->next = next;
2008a38: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
2008a3c: c2 24 00 00 st %g1, [ %l0 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
2008a40: 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;
2008a44: c2 04 60 08 ld [ %l1 + 8 ], %g1
the_chain->last = the_node;
2008a48: e0 24 60 08 st %l0, [ %l1 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
2008a4c: 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;
2008a50: e0 20 40 00 st %l0, [ %g1 ]
_Chain_Extract_unprotected( &executing->Object.Node );
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
2008a54: 7f ff e4 e8 call 2001df4 <sparc_enable_interrupts>
2008a58: 01 00 00 00 nop
2008a5c: 7f ff e4 e2 call 2001de4 <sparc_disable_interrupts>
2008a60: 01 00 00 00 nop
if ( _Thread_Is_heir( executing ) )
2008a64: 07 00 80 5d sethi %hi(0x2017400), %g3
2008a68: c2 00 e0 70 ld [ %g3 + 0x70 ], %g1 ! 2017470 <_Thread_Heir>
2008a6c: 80 a4 00 01 cmp %l0, %g1
2008a70: 22 80 00 0d be,a 2008aa4 <_Thread_Yield_processor+0xa0> <== ALWAYS TAKEN
2008a74: c2 04 40 00 ld [ %l1 ], %g1
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
_Context_Switch_necessary = TRUE;
2008a78: 84 10 20 01 mov 1, %g2
2008a7c: 03 00 80 5d sethi %hi(0x2017400), %g1
2008a80: c4 28 60 b4 stb %g2, [ %g1 + 0xb4 ] ! 20174b4 <_Context_Switch_necessary>
_ISR_Enable( level );
2008a84: 7f ff e4 dc call 2001df4 <sparc_enable_interrupts>
2008a88: 81 e8 00 00 restore
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
_Context_Switch_necessary = TRUE;
}
else if ( !_Thread_Is_heir( executing ) )
2008a8c: 03 00 80 5d sethi %hi(0x2017400), %g1
2008a90: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 ! 2017470 <_Thread_Heir>
2008a94: 80 a4 00 02 cmp %l0, %g2
2008a98: 12 bf ff f9 bne 2008a7c <_Thread_Yield_processor+0x78> <== NEVER TAKEN
2008a9c: 84 10 20 01 mov 1, %g2
2008aa0: 30 bf ff f9 b,a 2008a84 <_Thread_Yield_processor+0x80>
_Chain_Append_unprotected( ready, &executing->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) )
_Thread_Heir = (Thread_Control *) ready->first;
2008aa4: 10 bf ff f5 b 2008a78 <_Thread_Yield_processor+0x74>
2008aa8: c2 20 e0 70 st %g1, [ %g3 + 0x70 ]
02008188 <_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
)
{
2008188: 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;
200818c: 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);
2008190: 82 06 60 3c add %i1, 0x3c, %g1
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2008194: 84 06 60 38 add %i1, 0x38, %g2
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2008198: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
the_chain->permanent_null = NULL;
200819c: c0 26 60 3c clr [ %i1 + 0x3c ]
the_chain->last = _Chain_Head(the_chain);
20081a0: c4 26 60 40 st %g2, [ %i1 + 0x40 ]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
20081a4: ac 10 00 18 mov %i0, %l6
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
20081a8: 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);
20081ac: 83 34 a0 06 srl %l2, 6, %g1
20081b0: 12 80 00 30 bne 2008270 <_Thread_queue_Enqueue_priority+0xe8>
20081b4: ea 06 20 38 ld [ %i0 + 0x38 ], %l5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
20081b8: 85 28 60 04 sll %g1, 4, %g2
20081bc: 83 28 60 02 sll %g1, 2, %g1
20081c0: 82 20 80 01 sub %g2, %g1, %g1
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
20081c4: b0 10 00 01 mov %g1, %i0
20081c8: 82 05 80 01 add %l6, %g1, %g1
20081cc: a6 00 60 04 add %g1, 4, %l3
if ( _Thread_queue_Is_reverse_search( priority ) )
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
20081d0: 7f ff e7 05 call 2001de4 <sparc_disable_interrupts>
20081d4: 01 00 00 00 nop
20081d8: a8 10 00 08 mov %o0, %l4
search_thread = (Thread_Control *) header->first;
20081dc: e0 05 80 18 ld [ %l6 + %i0 ], %l0
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
20081e0: 80 a4 00 13 cmp %l0, %l3
20081e4: 32 80 00 18 bne,a 2008244 <_Thread_queue_Enqueue_priority+0xbc>
20081e8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
20081ec: 10 80 00 81 b 20083f0 <_Thread_queue_Enqueue_priority+0x268>
20081f0: a2 10 3f ff mov -1, %l1
if ( priority <= search_priority )
break;
#if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE )
search_thread = (Thread_Control *) search_thread->Object.Node.next;
if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) )
20081f4: 80 a4 00 13 cmp %l0, %l3
20081f8: 02 80 00 17 be 2008254 <_Thread_queue_Enqueue_priority+0xcc>
20081fc: 90 10 00 14 mov %l4, %o0
break;
search_priority = search_thread->current_priority;
2008200: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority <= search_priority )
2008204: 80 a4 80 11 cmp %l2, %l1
2008208: 28 80 00 14 bleu,a 2008258 <_Thread_queue_Enqueue_priority+0xd0>
200820c: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
break;
#endif
_ISR_Flash( level );
2008210: 7f ff e6 f9 call 2001df4 <sparc_enable_interrupts>
2008214: 90 10 00 14 mov %l4, %o0
2008218: 7f ff e6 f3 call 2001de4 <sparc_disable_interrupts>
200821c: 01 00 00 00 nop
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
2008220: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
2008224: 80 8d 40 01 btst %l5, %g1
2008228: 02 80 00 6b be 20083d4 <_Thread_queue_Enqueue_priority+0x24c><== NEVER TAKEN
200822c: 01 00 00 00 nop
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
2008230: e0 04 00 00 ld [ %l0 ], %l0
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 ) ) {
2008234: 80 a4 00 13 cmp %l0, %l3
2008238: 02 80 00 07 be 2008254 <_Thread_queue_Enqueue_priority+0xcc>
200823c: 90 10 00 14 mov %l4, %o0
search_priority = search_thread->current_priority;
2008240: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority <= search_priority )
2008244: 80 a4 80 11 cmp %l2, %l1
2008248: 38 bf ff eb bgu,a 20081f4 <_Thread_queue_Enqueue_priority+0x6c>
200824c: e0 04 00 00 ld [ %l0 ], %l0
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 ) ) {
2008250: 90 10 00 14 mov %l4, %o0
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
2008254: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
2008258: 80 a6 20 01 cmp %i0, 1
200825c: 02 80 00 47 be 2008378 <_Thread_queue_Enqueue_priority+0x1f0><== ALWAYS TAKEN
2008260: 80 a4 80 11 cmp %l2, %l1
* 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;
2008264: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
return the_thread_queue->sync_state;
}
2008268: 81 c7 e0 08 ret <== NOT EXECUTED
200826c: 81 e8 00 00 restore <== NOT EXECUTED
the_node->previous = previous_node;
previous_node->next = the_node;
search_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
2008270: 85 28 60 04 sll %g1, 4, %g2
2008274: 83 28 60 02 sll %g1, 2, %g1
2008278: 82 20 80 01 sub %g2, %g1, %g1
200827c: 05 00 80 59 sethi %hi(0x2016400), %g2
2008280: a6 06 00 01 add %i0, %g1, %l3
2008284: ae 10 a2 34 or %g2, 0x234, %l7
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
2008288: b0 10 00 13 mov %l3, %i0
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
200828c: c2 0d c0 00 ldub [ %l7 ], %g1
_ISR_Disable( level );
2008290: 7f ff e6 d5 call 2001de4 <sparc_disable_interrupts>
2008294: a2 00 60 01 add %g1, 1, %l1
2008298: a8 10 00 08 mov %o0, %l4
search_thread = (Thread_Control *) header->last;
200829c: e0 06 20 08 ld [ %i0 + 8 ], %l0
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
20082a0: 80 a4 c0 10 cmp %l3, %l0
20082a4: 22 80 00 25 be,a 2008338 <_Thread_queue_Enqueue_priority+0x1b0>
20082a8: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
search_priority = search_thread->current_priority;
20082ac: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority >= search_priority )
20082b0: 80 a4 80 11 cmp %l2, %l1
20082b4: 3a 80 00 21 bcc,a 2008338 <_Thread_queue_Enqueue_priority+0x1b0>
20082b8: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
break;
#if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE )
search_thread = (Thread_Control *) search_thread->Object.Node.previous;
20082bc: e0 04 20 04 ld [ %l0 + 4 ], %l0
if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) )
20082c0: 80 a4 c0 10 cmp %l3, %l0
20082c4: 32 80 00 19 bne,a 2008328 <_Thread_queue_Enqueue_priority+0x1a0>
20082c8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
20082cc: 10 80 00 1b b 2008338 <_Thread_queue_Enqueue_priority+0x1b0>
20082d0: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
break;
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
20082d4: 7f ff e6 c8 call 2001df4 <sparc_enable_interrupts>
20082d8: 90 10 00 14 mov %l4, %o0
20082dc: 7f ff e6 c2 call 2001de4 <sparc_disable_interrupts>
20082e0: 01 00 00 00 nop
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
20082e4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
20082e8: 80 8d 40 01 btst %l5, %g1
20082ec: 02 80 00 3d be 20083e0 <_Thread_queue_Enqueue_priority+0x258><== NEVER TAKEN
20082f0: 01 00 00 00 nop
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
20082f4: e0 04 20 04 ld [ %l0 + 4 ], %l0
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
20082f8: 80 a4 00 13 cmp %l0, %l3
20082fc: 22 80 00 0f be,a 2008338 <_Thread_queue_Enqueue_priority+0x1b0>
2008300: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
search_priority = search_thread->current_priority;
2008304: e2 04 20 14 ld [ %l0 + 0x14 ], %l1
if ( priority >= search_priority )
2008308: 80 a4 80 11 cmp %l2, %l1
200830c: 3a 80 00 0b bcc,a 2008338 <_Thread_queue_Enqueue_priority+0x1b0><== ALWAYS TAKEN
2008310: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
break;
#if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE )
search_thread = (Thread_Control *) search_thread->Object.Node.previous;
2008314: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED
if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) )
2008318: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED
200831c: 22 80 00 07 be,a 2008338 <_Thread_queue_Enqueue_priority+0x1b0><== NOT EXECUTED
2008320: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0 <== NOT EXECUTED
break;
search_priority = search_thread->current_priority;
2008324: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED
if ( priority >= search_priority )
2008328: 80 a4 80 11 cmp %l2, %l1
200832c: 0a bf ff ea bcs 20082d4 <_Thread_queue_Enqueue_priority+0x14c>
2008330: 01 00 00 00 nop
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
2008334: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
2008338: 80 a6 20 01 cmp %i0, 1
200833c: 12 bf ff ca bne 2008264 <_Thread_queue_Enqueue_priority+0xdc><== NEVER TAKEN
2008340: 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 )
2008344: 80 a4 80 11 cmp %l2, %l1
2008348: 02 80 00 18 be 20083a8 <_Thread_queue_Enqueue_priority+0x220>
200834c: c0 25 a0 30 clr [ %l6 + 0x30 ]
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
2008350: c2 04 00 00 ld [ %l0 ], %g1
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
2008354: 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;
2008358: 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;
200835c: ec 26 60 44 st %l6, [ %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;
2008360: 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;
2008364: f2 24 00 00 st %i1, [ %l0 ]
next_node->previous = the_node;
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
2008368: 7f ff e6 a3 call 2001df4 <sparc_enable_interrupts>
200836c: 01 00 00 00 nop
2008370: 81 c7 e0 08 ret
2008374: 81 e8 00 00 restore
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
2008378: 02 80 00 0c be 20083a8 <_Thread_queue_Enqueue_priority+0x220>
200837c: c0 25 a0 30 clr [ %l6 + 0x30 ]
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
2008380: c2 04 20 04 ld [ %l0 + 4 ], %g1
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
2008384: e0 26 40 00 st %l0, [ %i1 ]
the_node->previous = previous_node;
2008388: 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;
200838c: ec 26 60 44 st %l6, [ %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;
2008390: f2 20 40 00 st %i1, [ %g1 ]
search_node->previous = the_node;
2008394: f2 24 20 04 st %i1, [ %l0 + 4 ]
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
2008398: 7f ff e6 97 call 2001df4 <sparc_enable_interrupts>
200839c: 90 10 00 14 mov %l4, %o0
20083a0: 81 c7 e0 08 ret
20083a4: 81 e8 00 00 restore
20083a8: 82 04 20 3c add %l0, 0x3c, %g1
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
20083ac: c4 00 60 04 ld [ %g1 + 4 ], %g2
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
20083b0: c2 26 40 00 st %g1, [ %i1 ]
the_node->previous = previous_node;
20083b4: 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;
20083b8: ec 26 60 44 st %l6, [ %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;
20083bc: f2 20 80 00 st %i1, [ %g2 ]
search_node->previous = the_node;
20083c0: f2 20 60 04 st %i1, [ %g1 + 4 ]
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
20083c4: 7f ff e6 8c call 2001df4 <sparc_enable_interrupts>
20083c8: b0 10 20 01 mov 1, %i0
20083cc: 81 c7 e0 08 ret
20083d0: 81 e8 00 00 restore
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
20083d4: 7f ff e6 88 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20083d8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20083dc: 30 bf ff 7d b,a 20081d0 <_Thread_queue_Enqueue_priority+0x48><== NOT EXECUTED
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
_ISR_Enable( level );
20083e0: 7f ff e6 85 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20083e4: 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;
20083e8: 10 bf ff aa b 2008290 <_Thread_queue_Enqueue_priority+0x108><== NOT EXECUTED
20083ec: c2 0d c0 00 ldub [ %l7 ], %g1 <== NOT EXECUTED
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
20083f0: 10 bf ff 9a b 2008258 <_Thread_queue_Enqueue_priority+0xd0>
20083f4: f0 05 a0 30 ld [ %l6 + 0x30 ], %i0
0200cd08 <_Thread_queue_Extract_fifo>:
void _Thread_queue_Extract_fifo(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200cd08: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
_ISR_Disable( level );
200cd0c: 7f ff d4 36 call 2001de4 <sparc_disable_interrupts>
200cd10: b0 10 00 19 mov %i1, %i0
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200cd14: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
200cd18: 03 00 00 ef sethi %hi(0x3bc00), %g1
200cd1c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200cd20: 80 88 80 01 btst %g2, %g1
200cd24: 02 80 00 19 be 200cd88 <_Thread_queue_Extract_fifo+0x80> <== NEVER TAKEN
200cd28: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200cd2c: c2 06 40 00 ld [ %i1 ], %g1
previous = the_node->previous;
200cd30: 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 ) ) {
200cd34: c6 06 60 50 ld [ %i1 + 0x50 ], %g3
next->previous = previous;
previous->next = next;
200cd38: c2 20 80 00 st %g1, [ %g2 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
200cd3c: c4 20 60 04 st %g2, [ %g1 + 4 ]
200cd40: 80 a0 e0 02 cmp %g3, 2
200cd44: 02 80 00 07 be 200cd60 <_Thread_queue_Extract_fifo+0x58>
200cd48: c0 26 60 44 clr [ %i1 + 0x44 ]
_ISR_Enable( level );
200cd4c: 7f ff d4 2a call 2001df4 <sparc_enable_interrupts>
200cd50: 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 );
200cd54: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
200cd58: 7f ff ea 6f call 2007714 <_Thread_Clear_state>
200cd5c: 81 e8 00 00 restore
200cd60: 82 10 20 03 mov 3, %g1
200cd64: c2 26 60 50 st %g1, [ %i1 + 0x50 ]
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
200cd68: 7f ff d4 23 call 2001df4 <sparc_enable_interrupts>
200cd6c: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_thread->Timer );
200cd70: 7f ff f0 a3 call 2008ffc <_Watchdog_Remove>
200cd74: 90 06 60 48 add %i1, 0x48, %o0
200cd78: 33 04 00 ff sethi %hi(0x1003fc00), %i1
200cd7c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
200cd80: 7f ff ea 65 call 2007714 <_Thread_Clear_state>
200cd84: 81 e8 00 00 restore
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
200cd88: 7f ff d4 1b call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200cd8c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0200bf90 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
bool requeuing
)
{
200bf90: 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 );
200bf94: 7f ff d7 94 call 2001de4 <sparc_disable_interrupts>
200bf98: b0 10 00 19 mov %i1, %i0
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200bf9c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
200bfa0: 03 00 00 ef sethi %hi(0x3bc00), %g1
200bfa4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200bfa8: 80 88 80 01 btst %g2, %g1
200bfac: 02 80 00 23 be 200c038 <_Thread_queue_Extract_priority_helper+0xa8><== NEVER TAKEN
200bfb0: 82 06 60 3c add %i1, 0x3c, %g1
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
200bfb4: c6 06 60 38 ld [ %i1 + 0x38 ], %g3
/*
* The thread was actually waiting on a thread queue so let's remove it.
*/
next_node = the_node->next;
200bfb8: c4 06 40 00 ld [ %i1 ], %g2
previous_node = the_node->previous;
if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
200bfbc: 80 a0 c0 01 cmp %g3, %g1
200bfc0: 02 80 00 2a be 200c068 <_Thread_queue_Extract_priority_helper+0xd8>
200bfc4: 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;
200bfc8: da 06 60 40 ld [ %i1 + 0x40 ], %o5
new_second_node = new_first_node->next;
200bfcc: c8 00 c0 00 ld [ %g3 ], %g4
previous_node->next = new_first_node;
next_node->previous = new_first_node;
200bfd0: 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;
200bfd4: c6 20 40 00 st %g3, [ %g1 ]
next_node->previous = new_first_node;
new_first_node->next = next_node;
200bfd8: c4 20 c0 00 st %g2, [ %g3 ]
new_first_node->previous = previous_node;
200bfdc: c2 20 e0 04 st %g1, [ %g3 + 4 ]
if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
200bfe0: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
200bfe4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
200bfe8: 80 a0 80 01 cmp %g2, %g1
200bfec: 02 80 00 07 be 200c008 <_Thread_queue_Extract_priority_helper+0x78>
200bff0: 82 00 e0 38 add %g3, 0x38, %g1
/* > two threads on 2-n */
new_second_node->previous =
200bff4: c2 21 20 04 st %g1, [ %g4 + 4 ]
_Chain_Head( &new_first_thread->Wait.Block2n );
new_first_thread->Wait.Block2n.first = new_second_node;
200bff8: c8 20 e0 38 st %g4, [ %g3 + 0x38 ]
new_first_thread->Wait.Block2n.last = last_node;
200bffc: da 20 e0 40 st %o5, [ %g3 + 0x40 ]
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
200c000: 82 00 e0 3c add %g3, 0x3c, %g1
200c004: c2 23 40 00 st %g1, [ %o5 ]
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
200c008: 80 8e a0 ff btst 0xff, %i2
200c00c: 12 80 00 0d bne 200c040 <_Thread_queue_Extract_priority_helper+0xb0>
200c010: 01 00 00 00 nop
_ISR_Enable( level );
return;
}
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
200c014: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200c018: 80 a0 60 02 cmp %g1, 2
200c01c: 02 80 00 0b be 200c048 <_Thread_queue_Extract_priority_helper+0xb8><== NEVER TAKEN
200c020: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
200c024: 7f ff d7 74 call 2001df4 <sparc_enable_interrupts>
200c028: 33 04 00 ff sethi %hi(0x1003fc00), %i1
200c02c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
200c030: 7f ff ed b9 call 2007714 <_Thread_Clear_state>
200c034: 81 e8 00 00 restore
Chain_Node *last_node;
the_node = (Chain_Node *) the_thread;
_ISR_Disable( level );
if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_ISR_Enable( level );
200c038: 7f ff d7 6f call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200c03c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
/*
* If we are not supposed to touch timers or the thread's state, return.
*/
if ( requeuing ) {
_ISR_Enable( level );
200c040: 7f ff d7 6d call 2001df4 <sparc_enable_interrupts>
200c044: 91 e8 00 08 restore %g0, %o0, %o0
200c048: c2 26 20 50 st %g1, [ %i0 + 0x50 ] <== NOT EXECUTED
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
_ISR_Enable( level );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
200c04c: 7f ff d7 6a call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200c050: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
200c054: 7f ff f3 ea call 2008ffc <_Watchdog_Remove> <== NOT EXECUTED
200c058: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED
200c05c: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED
200c060: 7f ff ed ad call 2007714 <_Thread_Clear_state> <== NOT EXECUTED
200c064: 81 e8 00 00 restore <== NOT EXECUTED
new_first_thread->Wait.Block2n.last = last_node;
last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
}
} else {
previous_node->next = next_node;
next_node->previous = previous_node;
200c068: 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;
200c06c: 10 bf ff e7 b 200c008 <_Thread_queue_Extract_priority_helper+0x78>
200c070: c4 20 40 00 st %g2, [ %g1 ]
0200c074 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>
void _Thread_queue_Process_timeout(
Thread_Control *the_thread
)
{
200c074: 92 10 00 08 mov %o0, %o1
Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
200c078: d0 02 20 44 ld [ %o0 + 0x44 ], %o0
* 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 &&
200c07c: c6 02 20 30 ld [ %o0 + 0x30 ], %g3
200c080: 80 a0 e0 00 cmp %g3, 0
200c084: 02 80 00 06 be 200c09c <_Thread_queue_Process_timeout+0x28>
200c088: 03 00 80 5d sethi %hi(0x2017400), %g1
200c08c: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_Thread_Executing>
200c090: 80 a2 40 02 cmp %o1, %g2
200c094: 02 80 00 07 be 200c0b0 <_Thread_queue_Process_timeout+0x3c><== ALWAYS TAKEN
200c098: 80 a0 e0 03 cmp %g3, 3
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;
200c09c: c2 02 20 3c ld [ %o0 + 0x3c ], %g1
200c0a0: c2 22 60 34 st %g1, [ %o1 + 0x34 ]
_Thread_queue_Extract( the_thread->Wait.queue, the_thread );
200c0a4: 82 13 c0 00 mov %o7, %g1
200c0a8: 7f ff ff af call 200bf64 <_Thread_queue_Extract>
200c0ac: 9e 10 40 00 mov %g1, %o7
* a timeout is not allowed to occur.
*/
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED &&
_Thread_Is_executing( the_thread ) ) {
if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
200c0b0: 02 80 00 06 be 200c0c8 <_Thread_queue_Process_timeout+0x54><== NEVER TAKEN
200c0b4: 84 10 20 02 mov 2, %g2
the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
200c0b8: c2 02 20 3c ld [ %o0 + 0x3c ], %g1
200c0bc: c2 22 60 34 st %g1, [ %o1 + 0x34 ]
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
200c0c0: 81 c3 e0 08 retl
200c0c4: c4 22 20 30 st %g2, [ %o0 + 0x30 ]
200c0c8: 81 c3 e0 08 retl <== NOT EXECUTED
020084c8 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
20084c8: 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 )
20084cc: 80 a6 20 00 cmp %i0, 0
20084d0: 02 80 00 13 be 200851c <_Thread_queue_Requeue+0x54> <== NEVER TAKEN
20084d4: 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 ) {
20084d8: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
20084dc: 80 a4 20 01 cmp %l0, 1
20084e0: 02 80 00 04 be 20084f0 <_Thread_queue_Requeue+0x28> <== ALWAYS TAKEN
20084e4: 01 00 00 00 nop
20084e8: 81 c7 e0 08 ret <== NOT EXECUTED
20084ec: 81 e8 00 00 restore <== NOT EXECUTED
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
20084f0: 7f ff e6 3d call 2001de4 <sparc_disable_interrupts>
20084f4: 01 00 00 00 nop
20084f8: a2 10 00 08 mov %o0, %l1
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
20084fc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
2008500: 03 00 00 ef sethi %hi(0x3bc00), %g1
2008504: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2008508: 80 88 80 01 btst %g2, %g1
200850c: 12 80 00 06 bne 2008524 <_Thread_queue_Requeue+0x5c> <== ALWAYS TAKEN
2008510: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
}
_ISR_Enable( level );
2008514: 7f ff e6 38 call 2001df4 <sparc_enable_interrupts>
2008518: 90 10 00 11 mov %l1, %o0
200851c: 81 c7 e0 08 ret
2008520: 81 e8 00 00 restore
ISR_Level level_ignored;
_ISR_Disable( level );
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
2008524: 92 10 00 19 mov %i1, %o1
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;
2008528: e0 26 20 30 st %l0, [ %i0 + 0x30 ]
200852c: 40 00 0e 99 call 200bf90 <_Thread_queue_Extract_priority_helper>
2008530: 94 10 20 01 mov 1, %o2
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
2008534: 90 10 00 18 mov %i0, %o0
2008538: 92 10 00 19 mov %i1, %o1
200853c: 7f ff ff 13 call 2008188 <_Thread_queue_Enqueue_priority>
2008540: 94 07 bf f4 add %fp, -12, %o2
2008544: 30 bf ff f4 b,a 2008514 <_Thread_queue_Requeue+0x4c>
02008548 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored
)
{
2008548: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200854c: 90 10 00 18 mov %i0, %o0
2008550: 7f ff fd 98 call 2007bb0 <_Thread_Get>
2008554: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2008558: c2 07 bf f4 ld [ %fp + -12 ], %g1
200855c: 80 a0 60 00 cmp %g1, 0
2008560: 12 80 00 08 bne 2008580 <_Thread_queue_Timeout+0x38> <== NEVER TAKEN
2008564: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
2008568: 40 00 0e c3 call 200c074 <_Thread_queue_Process_timeout>
200856c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
RTEMS_COMPILER_MEMORY_BARRIER();
_Thread_Dispatch_disable_level -= 1;
2008570: 05 00 80 5c sethi %hi(0x2017000), %g2
2008574: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level>
2008578: 82 00 7f ff add %g1, -1, %g1
200857c: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ]
2008580: 81 c7 e0 08 ret
2008584: 81 e8 00 00 restore
02011c4c <_Timer_Server_body>:
* @param[in] ignored is the the task argument that is ignored
*/
Thread _Timer_Server_body(
uint32_t ignored
)
{
2011c4c: 9d e3 bf 88 save %sp, -120, %sp
2011c50: 05 00 80 c3 sethi %hi(0x2030c00), %g2
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
2011c54: 19 00 80 c3 sethi %hi(0x2030c00), %o4
2011c58: c6 03 22 d4 ld [ %o4 + 0x2d4 ], %g3 ! 2030ed4 <_Watchdog_Ticks_since_boot>
2011c5c: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
2011c60: 17 00 80 c3 sethi %hi(0x2030c00), %o3
2011c64: c8 02 e2 14 ld [ %o3 + 0x214 ], %g4 ! 2030e14 <_TOD_Now>
2011c68: 82 00 60 01 inc %g1
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
2011c6c: 1b 00 80 c3 sethi %hi(0x2030c00), %o5
2011c70: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
2011c74: a2 07 bf ec add %fp, -20, %l1
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
2011c78: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2011c7c: a4 07 bf f0 add %fp, -16, %l2
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
2011c80: c0 27 bf f0 clr [ %fp + -16 ]
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
2011c84: c6 23 60 84 st %g3, [ %o5 + 0x84 ]
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
2011c88: c8 20 60 80 st %g4, [ %g1 + 0x80 ]
the_chain->last = _Chain_Head(the_chain);
2011c8c: e2 27 bf f4 st %l1, [ %fp + -12 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2011c90: e4 27 bf ec st %l2, [ %fp + -20 ]
/*
* Initialize the "last time" markers to indicate the timer that
* the server was initiated.
*/
_Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot;
2011c94: b0 13 22 d4 or %o4, 0x2d4, %i0
2011c98: ac 13 60 84 or %o5, 0x84, %l6
_Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
2011c9c: ae 10 60 80 or %g1, 0x80, %l7
2011ca0: b6 12 e2 14 or %o3, 0x214, %i3
2011ca4: a6 10 a1 80 or %g2, 0x180, %l3
/*
* 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();
2011ca8: 7f ff ff c3 call 2011bb4 <_Timer_Server_process_insertions>
2011cac: 01 00 00 00 nop
_Thread_Enable_dispatch();
2011cb0: 40 00 0b ef call 2014c6c <_Thread_Enable_dispatch>
2011cb4: 01 00 00 00 nop
2011cb8: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2011cbc: b8 10 60 78 or %g1, 0x78, %i4 ! 2030c78 <_Timer_Ticks_chain+0x4>
2011cc0: 03 00 80 c4 sethi %hi(0x2031000), %g1
2011cc4: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2011cc8: a8 10 60 e4 or %g1, 0xe4, %l4
2011ccc: ba 10 a0 8c or %g2, 0x8c, %i5
2011cd0: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2011cd4: b4 07 3f fc add %i4, -4, %i2
2011cd8: b2 07 7f fc add %i5, -4, %i1
2011cdc: aa 10 60 a0 or %g1, 0xa0, %l5
2011ce0: c2 04 c0 00 ld [ %l3 ], %g1
2011ce4: 82 00 60 01 inc %g1
2011ce8: c2 24 c0 00 st %g1, [ %l3 ]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( _Timer_Server, STATES_DELAYING );
2011cec: d0 05 00 00 ld [ %l4 ], %o0
2011cf0: 40 00 0e e3 call 201587c <_Thread_Set_state>
2011cf4: 92 10 20 08 mov 8, %o1
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
2011cf8: c2 06 80 00 ld [ %i2 ], %g1
_Timer_Server_reset_ticks_timer();
2011cfc: 80 a0 40 1c cmp %g1, %i4
2011d00: 02 80 00 0a be 2011d28 <_Timer_Server_body+0xdc>
2011d04: 05 00 80 c4 sethi %hi(0x2031000), %g2
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2011d08: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2011d0c: 84 10 a0 e4 or %g2, 0xe4, %g2
2011d10: d2 00 80 00 ld [ %g2 ], %o1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2011d14: 11 00 80 c3 sethi %hi(0x2030c00), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2011d18: c2 22 60 54 st %g1, [ %o1 + 0x54 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2011d1c: 90 12 22 64 or %o0, 0x264, %o0
2011d20: 40 00 11 f2 call 20164e8 <_Watchdog_Insert>
2011d24: 92 02 60 48 add %o1, 0x48, %o1
2011d28: c2 06 40 00 ld [ %i1 ], %g1
_Timer_Server_reset_seconds_timer();
2011d2c: 80 a0 40 1d cmp %g1, %i5
2011d30: 02 80 00 08 be 2011d50 <_Timer_Server_body+0x104>
2011d34: 01 00 00 00 nop
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2011d38: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
2011d3c: 11 00 80 c3 sethi %hi(0x2030c00), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2011d40: c2 25 60 0c st %g1, [ %l5 + 0xc ]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
2011d44: 90 12 22 58 or %o0, 0x258, %o0
2011d48: 40 00 11 e8 call 20164e8 <_Watchdog_Insert>
2011d4c: 92 10 00 15 mov %l5, %o1
_Thread_Enable_dispatch();
2011d50: 40 00 0b c7 call 2014c6c <_Thread_Enable_dispatch>
2011d54: 01 00 00 00 nop
2011d58: c2 04 c0 00 ld [ %l3 ], %g1
2011d5c: 82 00 60 01 inc %g1
2011d60: c2 24 c0 00 st %g1, [ %l3 ]
/*
* 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();
2011d64: d0 05 00 00 ld [ %l4 ], %o0
2011d68: 40 00 12 4b call 2016694 <_Watchdog_Remove>
2011d6c: 90 02 20 48 add %o0, 0x48, %o0
_Timer_Server_stop_seconds_timer();
2011d70: 11 00 80 c3 sethi %hi(0x2030c00), %o0
2011d74: 40 00 12 48 call 2016694 <_Watchdog_Remove>
2011d78: 90 12 20 a0 or %o0, 0xa0, %o0 ! 2030ca0 <_Timer_Seconds_timer>
)
{
Watchdog_Interval snapshot;
Watchdog_Interval ticks;
snapshot = _Watchdog_Ticks_since_boot;
2011d7c: c6 06 00 00 ld [ %i0 ], %g3
if ( snapshot >= _Timer_Server_ticks_last_time )
2011d80: c4 05 80 00 ld [ %l6 ], %g2
ticks = snapshot - _Timer_Server_ticks_last_time;
else
ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
2011d84: 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 )
2011d88: 80 a0 c0 02 cmp %g3, %g2
2011d8c: 0a 80 00 03 bcs 2011d98 <_Timer_Server_body+0x14c> <== NEVER TAKEN
2011d90: 92 00 40 03 add %g1, %g3, %o1
ticks = snapshot - _Timer_Server_ticks_last_time;
2011d94: 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 );
2011d98: 94 10 00 11 mov %l1, %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;
2011d9c: c6 25 80 00 st %g3, [ %l6 ]
_Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
2011da0: 11 00 80 c3 sethi %hi(0x2030c00), %o0
2011da4: 40 00 11 9d call 2016418 <_Watchdog_Adjust_to_chain>
2011da8: 90 12 20 74 or %o0, 0x74, %o0 ! 2030c74 <_Timer_Ticks_chain>
* 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;
if ( snapshot > _Timer_Server_seconds_last_time ) {
2011dac: d4 05 c0 00 ld [ %l7 ], %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;
2011db0: e0 06 c0 00 ld [ %i3 ], %l0
if ( snapshot > _Timer_Server_seconds_last_time ) {
2011db4: 80 a4 00 0a cmp %l0, %o2
2011db8: 18 80 00 1b bgu 2011e24 <_Timer_Server_body+0x1d8>
2011dbc: 92 24 00 0a sub %l0, %o2, %o1
* TOD has been set forward.
*/
ticks = snapshot - _Timer_Server_seconds_last_time;
_Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire );
} else if ( snapshot < _Timer_Server_seconds_last_time ) {
2011dc0: 0a 80 00 1e bcs 2011e38 <_Timer_Server_body+0x1ec>
2011dc4: 94 22 80 10 sub %o2, %l0, %o2
_Timer_Server_process_seconds_chain( &to_fire );
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
2011dc8: 7f ff ff 7b call 2011bb4 <_Timer_Server_process_insertions>
2011dcc: e0 25 c0 00 st %l0, [ %l7 ]
/*
* Enable dispatching to process the set that are ready "to fire."
*/
_Thread_Enable_dispatch();
2011dd0: 40 00 0b a7 call 2014c6c <_Thread_Enable_dispatch>
2011dd4: 01 00 00 00 nop
2011dd8: 30 80 00 0a b,a 2011e00 <_Timer_Server_body+0x1b4>
if ( watch == NULL ) {
_ISR_Enable( level );
break;
}
watch->state = WATCHDOG_INACTIVE;
2011ddc: c0 24 20 08 clr [ %l0 + 8 ]
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
2011de0: c2 27 bf ec st %g1, [ %fp + -20 ]
new_first->previous = _Chain_Head(the_chain);
2011de4: e2 20 60 04 st %l1, [ %g1 + 4 ]
_ISR_Enable( level );
2011de8: 7f ff e5 27 call 200b284 <sparc_enable_interrupts>
2011dec: 01 00 00 00 nop
(*watch->routine)( watch->id, watch->user_data );
2011df0: d2 04 20 24 ld [ %l0 + 0x24 ], %o1
2011df4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2011df8: 9f c0 40 00 call %g1
2011dfc: d0 04 20 20 ld [ %l0 + 0x20 ], %o0
*/
while (1) {
Watchdog_Control *watch;
ISR_Level level;
_ISR_Disable( level );
2011e00: 7f ff e5 1d call 200b274 <sparc_disable_interrupts>
2011e04: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
2011e08: 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))
2011e0c: 80 a4 80 10 cmp %l2, %l0
2011e10: 32 bf ff f3 bne,a 2011ddc <_Timer_Server_body+0x190>
2011e14: c2 04 00 00 ld [ %l0 ], %g1
watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
if ( watch == NULL ) {
_ISR_Enable( level );
2011e18: 7f ff e5 1b call 200b284 <sparc_enable_interrupts>
2011e1c: 01 00 00 00 nop
2011e20: 30 bf ff b0 b,a 2011ce0 <_Timer_Server_body+0x94>
/*
* 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 );
2011e24: 11 00 80 c3 sethi %hi(0x2030c00), %o0
2011e28: 94 10 00 11 mov %l1, %o2
2011e2c: 40 00 11 7b call 2016418 <_Watchdog_Adjust_to_chain>
2011e30: 90 12 20 88 or %o0, 0x88, %o0
2011e34: 30 bf ff e5 b,a 2011dc8 <_Timer_Server_body+0x17c>
/*
* 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 );
2011e38: 11 00 80 c3 sethi %hi(0x2030c00), %o0
2011e3c: 92 10 20 01 mov 1, %o1
2011e40: 40 00 11 46 call 2016358 <_Watchdog_Adjust>
2011e44: 90 12 20 88 or %o0, 0x88, %o0
2011e48: 30 bf ff e0 b,a 2011dc8 <_Timer_Server_body+0x17c>
02011bb4 <_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)
{
2011bb4: 9d e3 bf 98 save %sp, -104, %sp
2011bb8: 03 00 80 c3 sethi %hi(0x2030c00), %g1
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 );
2011bbc: 05 00 80 c3 sethi %hi(0x2030c00), %g2
static void _Timer_Server_process_insertions(void)
{
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
2011bc0: a0 10 60 94 or %g1, 0x94, %l0
if ( the_timer == NULL )
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
2011bc4: 03 00 80 c3 sethi %hi(0x2030c00), %g1
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
_Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
2011bc8: a4 10 a0 88 or %g2, 0x88, %l2
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 );
2011bcc: a2 10 60 74 or %g1, 0x74, %l1
static void _Timer_Server_process_insertions(void)
{
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
2011bd0: 40 00 02 a4 call 2012660 <_Chain_Get>
2011bd4: 90 10 00 10 mov %l0, %o0
if ( the_timer == NULL )
2011bd8: 80 a2 20 00 cmp %o0, 0
2011bdc: 02 80 00 0f be 2011c18 <_Timer_Server_process_insertions+0x64>
2011be0: 01 00 00 00 nop
break;
if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2011be4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2011be8: 80 a0 60 01 cmp %g1, 1
2011bec: 02 80 00 12 be 2011c34 <_Timer_Server_process_insertions+0x80>
2011bf0: 80 a0 60 03 cmp %g1, 3
_Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
} else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2011bf4: 02 80 00 0b be 2011c20 <_Timer_Server_process_insertions+0x6c><== ALWAYS TAKEN
2011bf8: 92 02 20 10 add %o0, 0x10, %o1
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
2011bfc: 7f ff ff ee call 2011bb4 <_Timer_Server_process_insertions><== NOT EXECUTED
2011c00: 01 00 00 00 nop <== NOT EXECUTED
static void _Timer_Server_process_insertions(void)
{
Timer_Control *the_timer;
while ( 1 ) {
the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
2011c04: 40 00 02 97 call 2012660 <_Chain_Get>
2011c08: 90 10 00 10 mov %l0, %o0
if ( the_timer == NULL )
2011c0c: 80 a2 20 00 cmp %o0, 0
2011c10: 32 bf ff f6 bne,a 2011be8 <_Timer_Server_process_insertions+0x34><== NEVER TAKEN
2011c14: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 <== NOT EXECUTED
2011c18: 81 c7 e0 08 ret
2011c1c: 81 e8 00 00 restore
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 );
2011c20: 40 00 12 32 call 20164e8 <_Watchdog_Insert>
2011c24: 90 10 00 12 mov %l2, %o0
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
2011c28: 7f ff ff e3 call 2011bb4 <_Timer_Server_process_insertions>
2011c2c: 01 00 00 00 nop
2011c30: 30 bf ff f5 b,a 2011c04 <_Timer_Server_process_insertions+0x50>
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 );
2011c34: 92 02 20 10 add %o0, 0x10, %o1
2011c38: 40 00 12 2c call 20164e8 <_Watchdog_Insert>
2011c3c: 90 10 00 11 mov %l1, %o0
}
/*
* Insert the timers that have been requested to be inserted.
*/
_Timer_Server_process_insertions();
2011c40: 7f ff ff dd call 2011bb4 <_Timer_Server_process_insertions>
2011c44: 01 00 00 00 nop
2011c48: 30 bf ff ef b,a 2011c04 <_Timer_Server_process_insertions+0x50>
02008aac <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
2008aac: 88 10 00 08 mov %o0, %g4
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
2008ab0: c4 02 60 04 ld [ %o1 + 4 ], %g2
2008ab4: c2 01 20 04 ld [ %g4 + 4 ], %g1
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
uint32_t seconds = add->tv_sec;
2008ab8: d0 02 40 00 ld [ %o1 ], %o0
/* Add the basics */
time->tv_sec += add->tv_sec;
2008abc: c6 01 00 00 ld [ %g4 ], %g3
time->tv_nsec += add->tv_nsec;
2008ac0: 84 00 80 01 add %g2, %g1, %g2
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
2008ac4: 86 00 c0 08 add %g3, %o0, %g3
time->tv_nsec += add->tv_nsec;
2008ac8: c4 21 20 04 st %g2, [ %g4 + 4 ]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2008acc: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1
2008ad0: 82 10 61 ff or %g1, 0x1ff, %g1 ! 3b9ac9ff <RAM_END+0x395ac9ff>
2008ad4: 80 a0 80 01 cmp %g2, %g1
2008ad8: 08 80 00 0d bleu 2008b0c <_Timespec_Add_to+0x60>
2008adc: c6 21 00 00 st %g3, [ %g4 ]
2008ae0: 98 10 00 01 mov %g1, %o4
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
2008ae4: 03 31 19 4d sethi %hi(0xc4653400), %g1
2008ae8: 9a 10 62 00 or %g1, 0x200, %o5 ! c4653600 <RAM_END+0xc2253600>
2008aec: 82 00 80 0d add %g2, %o5, %g1
time->tv_sec++;
2008af0: 86 00 e0 01 inc %g3
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
2008af4: c2 21 20 04 st %g1, [ %g4 + 4 ]
time->tv_sec++;
2008af8: c6 21 00 00 st %g3, [ %g4 ]
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
2008afc: 84 10 00 01 mov %g1, %g2
2008b00: 80 a0 40 0c cmp %g1, %o4
2008b04: 18 bf ff fa bgu 2008aec <_Timespec_Add_to+0x40> <== NEVER TAKEN
2008b08: 90 02 20 01 inc %o0
time->tv_sec++;
seconds++;
}
return seconds;
}
2008b0c: 81 c3 e0 08 retl
0200a700 <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a700: 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;
200a704: c2 06 40 00 ld [ %i1 ], %g1
right += rhs->tv_nsec;
200a708: 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;
200a70c: 91 38 60 1f sra %g1, 0x1f, %o0
200a710: 92 10 00 01 mov %g1, %o1
200a714: 83 30 60 1d srl %g1, 0x1d, %g1
200a718: 87 2a 60 03 sll %o1, 3, %g3
200a71c: 85 2a 20 03 sll %o0, 3, %g2
200a720: 84 10 40 02 or %g1, %g2, %g2
200a724: 83 30 e0 1b srl %g3, 0x1b, %g1
200a728: 99 28 a0 05 sll %g2, 5, %o4
200a72c: 9b 28 e0 05 sll %g3, 5, %o5
200a730: 98 10 40 0c or %g1, %o4, %o4
200a734: 9a a3 40 03 subcc %o5, %g3, %o5
200a738: 83 33 60 1a srl %o5, 0x1a, %g1
200a73c: 98 63 00 02 subx %o4, %g2, %o4
200a740: 97 2b 60 06 sll %o5, 6, %o3
200a744: 95 2b 20 06 sll %o4, 6, %o2
200a748: 96 a2 c0 0d subcc %o3, %o5, %o3
200a74c: 94 10 40 0a or %g1, %o2, %o2
200a750: 94 62 80 0c subx %o2, %o4, %o2
200a754: 96 82 c0 09 addcc %o3, %o1, %o3
200a758: 94 42 80 08 addx %o2, %o0, %o2
200a75c: 83 32 e0 1e srl %o3, 0x1e, %g1
200a760: 85 2a a0 02 sll %o2, 2, %g2
200a764: 84 10 40 02 or %g1, %g2, %g2
200a768: 87 2a e0 02 sll %o3, 2, %g3
200a76c: 96 82 c0 03 addcc %o3, %g3, %o3
200a770: 94 42 80 02 addx %o2, %g2, %o2
200a774: 83 32 e0 1e srl %o3, 0x1e, %g1
200a778: 85 2a a0 02 sll %o2, 2, %g2
200a77c: 84 10 40 02 or %g1, %g2, %g2
200a780: 87 2a e0 02 sll %o3, 2, %g3
200a784: 96 82 c0 03 addcc %o3, %g3, %o3
200a788: 94 42 80 02 addx %o2, %g2, %o2
200a78c: 83 32 e0 1e srl %o3, 0x1e, %g1
200a790: 85 2a a0 02 sll %o2, 2, %g2
200a794: 84 10 40 02 or %g1, %g2, %g2
200a798: 87 2a e0 02 sll %o3, 2, %g3
200a79c: 96 82 c0 03 addcc %o3, %g3, %o3
200a7a0: 94 42 80 02 addx %o2, %g2, %o2
200a7a4: 85 32 e0 17 srl %o3, 0x17, %g2
200a7a8: 83 2a a0 09 sll %o2, 9, %g1
200a7ac: 9b 2a e0 09 sll %o3, 9, %o5
200a7b0: 98 10 80 01 or %g2, %g1, %o4
right += rhs->tv_nsec;
200a7b4: 96 83 40 0f addcc %o5, %o7, %o3
200a7b8: 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;
200a7bc: e4 06 20 04 ld [ %i0 + 4 ], %l2
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
200a7c0: 94 43 00 02 addx %o4, %g2, %o2
if ( right == 0 ) {
200a7c4: 80 92 80 0b orcc %o2, %o3, %g0
200a7c8: 02 80 00 5d be 200a93c <_Timespec_Divide+0x23c> <== NEVER TAKEN
200a7cc: d0 06 00 00 ld [ %i0 ], %o0
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a7d0: 92 10 00 08 mov %o0, %o1
200a7d4: 83 32 60 1d srl %o1, 0x1d, %g1
200a7d8: 9b 2a 60 03 sll %o1, 3, %o5
200a7dc: 91 3a 20 1f sra %o0, 0x1f, %o0
200a7e0: 99 2a 20 03 sll %o0, 3, %o4
200a7e4: 98 10 40 0c or %g1, %o4, %o4
200a7e8: 83 33 60 1b srl %o5, 0x1b, %g1
200a7ec: 85 2b 20 05 sll %o4, 5, %g2
200a7f0: 87 2b 60 05 sll %o5, 5, %g3
200a7f4: 84 10 40 02 or %g1, %g2, %g2
200a7f8: 86 a0 c0 0d subcc %g3, %o5, %g3
200a7fc: 83 30 e0 1a srl %g3, 0x1a, %g1
200a800: 84 60 80 0c subx %g2, %o4, %g2
200a804: 9b 28 e0 06 sll %g3, 6, %o5
200a808: 99 28 a0 06 sll %g2, 6, %o4
200a80c: 9a a3 40 03 subcc %o5, %g3, %o5
200a810: 98 10 40 0c or %g1, %o4, %o4
200a814: 98 63 00 02 subx %o4, %g2, %o4
200a818: 9a 83 40 09 addcc %o5, %o1, %o5
200a81c: 83 33 60 1e srl %o5, 0x1e, %g1
200a820: 98 43 00 08 addx %o4, %o0, %o4
200a824: 87 2b 60 02 sll %o5, 2, %g3
200a828: 85 2b 20 02 sll %o4, 2, %g2
200a82c: 9a 83 40 03 addcc %o5, %g3, %o5
200a830: 84 10 40 02 or %g1, %g2, %g2
200a834: 83 33 60 1e srl %o5, 0x1e, %g1
200a838: 98 43 00 02 addx %o4, %g2, %o4
200a83c: 87 2b 60 02 sll %o5, 2, %g3
200a840: 85 2b 20 02 sll %o4, 2, %g2
200a844: 9a 83 40 03 addcc %o5, %g3, %o5
200a848: 84 10 40 02 or %g1, %g2, %g2
200a84c: 83 33 60 1e srl %o5, 0x1e, %g1
200a850: 98 43 00 02 addx %o4, %g2, %o4
200a854: 87 2b 60 02 sll %o5, 2, %g3
200a858: 85 2b 20 02 sll %o4, 2, %g2
200a85c: 9a 83 40 03 addcc %o5, %g3, %o5
200a860: 84 10 40 02 or %g1, %g2, %g2
200a864: 98 43 00 02 addx %o4, %g2, %o4
200a868: 83 2b 20 09 sll %o4, 9, %g1
200a86c: 89 33 60 17 srl %o5, 0x17, %g4
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
200a870: 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;
200a874: a0 11 00 01 or %g4, %g1, %l0
200a878: 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;
200a87c: a2 84 40 13 addcc %l1, %l3, %l1
200a880: 83 34 60 1e srl %l1, 0x1e, %g1
200a884: 87 2c 60 02 sll %l1, 2, %g3
200a888: a5 3c a0 1f sra %l2, 0x1f, %l2
200a88c: a0 44 00 12 addx %l0, %l2, %l0
200a890: 85 2c 20 02 sll %l0, 2, %g2
200a894: 84 10 40 02 or %g1, %g2, %g2
200a898: 83 30 e0 1b srl %g3, 0x1b, %g1
200a89c: 99 28 a0 05 sll %g2, 5, %o4
200a8a0: 9b 28 e0 05 sll %g3, 5, %o5
200a8a4: 98 10 40 0c or %g1, %o4, %o4
200a8a8: 9a a3 40 03 subcc %o5, %g3, %o5
200a8ac: 98 63 00 02 subx %o4, %g2, %o4
200a8b0: 9a 83 40 11 addcc %o5, %l1, %o5
200a8b4: 83 33 60 1e srl %o5, 0x1e, %g1
200a8b8: 98 43 00 10 addx %o4, %l0, %o4
200a8bc: 87 2b 60 02 sll %o5, 2, %g3
200a8c0: 85 2b 20 02 sll %o4, 2, %g2
200a8c4: 9a 83 40 03 addcc %o5, %g3, %o5
200a8c8: 84 10 40 02 or %g1, %g2, %g2
200a8cc: 83 33 60 1e srl %o5, 0x1e, %g1
200a8d0: 87 2b 60 02 sll %o5, 2, %g3
200a8d4: 98 43 00 02 addx %o4, %g2, %o4
200a8d8: 9a 83 40 03 addcc %o5, %g3, %o5
200a8dc: 85 2b 20 02 sll %o4, 2, %g2
200a8e0: 84 10 40 02 or %g1, %g2, %g2
200a8e4: 83 33 60 1b srl %o5, 0x1b, %g1
200a8e8: 98 43 00 02 addx %o4, %g2, %o4
200a8ec: 99 2b 20 05 sll %o4, 5, %o4
200a8f0: 98 10 40 0c or %g1, %o4, %o4
200a8f4: 93 2b 60 05 sll %o5, 5, %o1
200a8f8: 40 00 33 5b call 2017664 <__udivdi3>
200a8fc: 90 10 00 0c mov %o4, %o0
*ival_percentage = answer / 1000;
200a900: 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;
200a904: a0 10 00 08 mov %o0, %l0
200a908: a2 10 00 09 mov %o1, %l1
*ival_percentage = answer / 1000;
200a90c: 96 10 23 e8 mov 0x3e8, %o3
200a910: 40 00 33 55 call 2017664 <__udivdi3>
200a914: 90 10 00 10 mov %l0, %o0
*fval_percentage = answer % 1000;
200a918: 90 10 00 10 mov %l0, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
200a91c: d2 26 80 00 st %o1, [ %i2 ]
*fval_percentage = answer % 1000;
200a920: 94 10 20 00 clr %o2
200a924: 92 10 00 11 mov %l1, %o1
200a928: 40 00 34 2b call 20179d4 <__umoddi3>
200a92c: 96 10 23 e8 mov 0x3e8, %o3
200a930: d2 26 c0 00 st %o1, [ %i3 ]
200a934: 81 c7 e0 08 ret
200a938: 81 e8 00 00 restore
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
right += rhs->tv_nsec;
if ( right == 0 ) {
*ival_percentage = 0;
200a93c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*fval_percentage = 0;
200a940: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
200a944: 81 c7 e0 08 ret <== NOT EXECUTED
200a948: 81 e8 00 00 restore <== NOT EXECUTED
0200ab48 <_Timespec_Greater_than>:
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec > rhs->tv_sec )
200ab48: c4 02 00 00 ld [ %o0 ], %g2
200ab4c: c2 02 40 00 ld [ %o1 ], %g1
bool _Timespec_Greater_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
200ab50: 86 10 00 08 mov %o0, %g3
if ( lhs->tv_sec > rhs->tv_sec )
200ab54: 80 a0 80 01 cmp %g2, %g1
200ab58: 14 80 00 0a bg 200ab80 <_Timespec_Greater_than+0x38> <== NEVER TAKEN
200ab5c: 90 10 20 01 mov 1, %o0
return TRUE;
if ( lhs->tv_sec < rhs->tv_sec )
200ab60: 80 a0 80 01 cmp %g2, %g1
200ab64: 06 80 00 07 bl 200ab80 <_Timespec_Greater_than+0x38> <== NEVER TAKEN
200ab68: 90 10 20 00 clr %o0
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec > rhs->tv_nsec )
200ab6c: c4 00 e0 04 ld [ %g3 + 4 ], %g2
200ab70: c2 02 60 04 ld [ %o1 + 4 ], %g1
200ab74: 80 a0 80 01 cmp %g2, %g1
200ab78: 04 80 00 04 ble 200ab88 <_Timespec_Greater_than+0x40>
200ab7c: 90 10 20 01 mov 1, %o0
return TRUE;
return FALSE;
}
200ab80: 81 c3 e0 08 retl
200ab84: 01 00 00 00 nop
200ab88: 81 c3 e0 08 retl
200ab8c: 90 10 20 00 clr %o0 ! 0 <PROM_START>
0200ab90 <_Timespec_Less_than>:
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
if ( lhs->tv_sec < rhs->tv_sec )
200ab90: c4 02 00 00 ld [ %o0 ], %g2
200ab94: c2 02 40 00 ld [ %o1 ], %g1
bool _Timespec_Less_than(
const struct timespec *lhs,
const struct timespec *rhs
)
{
200ab98: 86 10 00 08 mov %o0, %g3
if ( lhs->tv_sec < rhs->tv_sec )
200ab9c: 80 a0 80 01 cmp %g2, %g1
200aba0: 06 80 00 0a bl 200abc8 <_Timespec_Less_than+0x38>
200aba4: 90 10 20 01 mov 1, %o0
return TRUE;
if ( lhs->tv_sec > rhs->tv_sec )
200aba8: 80 a0 80 01 cmp %g2, %g1
200abac: 14 80 00 07 bg 200abc8 <_Timespec_Less_than+0x38> <== NEVER TAKEN
200abb0: 90 10 20 00 clr %o0
return FALSE;
/* ASSERT: lhs->tv_sec == rhs->tv_sec */
if ( lhs->tv_nsec < rhs->tv_nsec )
200abb4: c4 00 e0 04 ld [ %g3 + 4 ], %g2
200abb8: c2 02 60 04 ld [ %o1 + 4 ], %g1
200abbc: 80 a0 80 01 cmp %g2, %g1
200abc0: 16 80 00 04 bge 200abd0 <_Timespec_Less_than+0x40>
200abc4: 90 10 20 01 mov 1, %o0
return TRUE;
return FALSE;
}
200abc8: 81 c3 e0 08 retl
200abcc: 01 00 00 00 nop
200abd0: 81 c3 e0 08 retl
200abd4: 90 10 20 00 clr %o0 ! 0 <PROM_START>
0200c2b0 <_User_extensions_Add_API_set>:
*/
void _User_extensions_Add_API_set (
User_extensions_Control *the_extension
)
{
200c2b0: 9d e3 bf 98 save %sp, -104, %sp
_Chain_Append( &_User_extensions_List, &the_extension->Node );
200c2b4: 11 00 80 5d sethi %hi(0x2017400), %o0
200c2b8: 92 10 00 18 mov %i0, %o1
200c2bc: 7f ff e8 1a call 2006324 <_Chain_Append>
200c2c0: 90 12 22 18 or %o0, 0x218, %o0
/*
* If a switch handler is present, append it to the switch chain.
*/
if ( the_extension->Callouts.thread_switch != NULL ) {
200c2c4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200c2c8: 80 a0 60 00 cmp %g1, 0
200c2cc: 02 80 00 06 be 200c2e4 <_User_extensions_Add_API_set+0x34><== NEVER TAKEN
200c2d0: b2 06 20 08 add %i0, 8, %i1
the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
200c2d4: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
_Chain_Append(
200c2d8: 31 00 80 5c sethi %hi(0x2017000), %i0
200c2dc: 7f ff e8 12 call 2006324 <_Chain_Append>
200c2e0: 91 ee 23 e4 restore %i0, 0x3e4, %o0
200c2e4: 81 c7 e0 08 ret <== NOT EXECUTED
200c2e8: 81 e8 00 00 restore <== NOT EXECUTED
02008ca4 <_User_extensions_Fatal>:
void _User_extensions_Fatal (
Internal_errors_Source the_source,
bool is_internal,
uint32_t the_error
)
{
2008ca4: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
2008ca8: 03 00 80 5d sethi %hi(0x2017400), %g1
2008cac: 82 10 62 18 or %g1, 0x218, %g1 ! 2017618 <_User_extensions_List>
2008cb0: e0 00 60 08 ld [ %g1 + 8 ], %l0
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008cb4: 80 a4 00 01 cmp %l0, %g1
2008cb8: 02 80 00 0e be 2008cf0 <_User_extensions_Fatal+0x4c> <== NEVER TAKEN
2008cbc: a2 10 00 01 mov %g1, %l1
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
2008cc0: b2 0e 60 ff and %i1, 0xff, %i1
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.fatal != NULL )
2008cc4: c2 04 20 30 ld [ %l0 + 0x30 ], %g1
2008cc8: 80 a0 60 00 cmp %g1, 0
2008ccc: 02 80 00 05 be 2008ce0 <_User_extensions_Fatal+0x3c>
2008cd0: 90 10 00 18 mov %i0, %o0
(*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
2008cd4: 92 10 00 19 mov %i1, %o1
2008cd8: 9f c0 40 00 call %g1
2008cdc: 94 10 00 1a mov %i2, %o2
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
2008ce0: e0 04 20 04 ld [ %l0 + 4 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008ce4: 80 a4 00 11 cmp %l0, %l1
2008ce8: 32 bf ff f8 bne,a 2008cc8 <_User_extensions_Fatal+0x24>
2008cec: c2 04 20 30 ld [ %l0 + 0x30 ], %g1
2008cf0: 81 c7 e0 08 ret
2008cf4: 81 e8 00 00 restore
02008b6c <_User_extensions_Handler_initialization>:
void _User_extensions_Handler_initialization (
uint32_t number_of_extensions,
User_extensions_Table *initial_extensions
)
{
2008b6c: 9d e3 bf 98 save %sp, -104, %sp
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2008b70: 07 00 80 5d sethi %hi(0x2017400), %g3
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2008b74: 09 00 80 5c sethi %hi(0x2017000), %g4
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2008b78: 84 10 e2 18 or %g3, 0x218, %g2
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2008b7c: 82 11 23 e4 or %g4, 0x3e4, %g1
2008b80: 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;
2008b84: c0 20 a0 04 clr [ %g2 + 4 ]
the_chain->last = _Chain_Head(the_chain);
2008b88: 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;
2008b8c: 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);
2008b90: 84 00 a0 04 add %g2, 4, %g2
2008b94: 82 00 60 04 add %g1, 4, %g1
2008b98: c4 20 e2 18 st %g2, [ %g3 + 0x218 ]
uint32_t i;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
2008b9c: 80 a6 60 00 cmp %i1, 0
2008ba0: 02 80 00 18 be 2008c00 <_User_extensions_Handler_initialization+0x94>
2008ba4: c2 21 23 e4 st %g1, [ %g4 + 0x3e4 ]
extension = (User_extensions_Control *)
2008ba8: 83 2e 20 02 sll %i0, 2, %g1
2008bac: a1 2e 20 04 sll %i0, 4, %l0
2008bb0: a0 24 00 01 sub %l0, %g1, %l0
2008bb4: a0 04 00 18 add %l0, %i0, %l0
2008bb8: a1 2c 20 02 sll %l0, 2, %l0
2008bbc: 40 00 01 7f call 20091b8 <_Workspace_Allocate_or_fatal_error>
2008bc0: 90 10 00 10 mov %l0, %o0
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
2008bc4: 94 10 00 10 mov %l0, %o2
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
2008bc8: a2 10 00 08 mov %o0, %l1
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
2008bcc: 40 00 12 c9 call 200d6f0 <memset>
2008bd0: 92 10 20 00 clr %o1
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
2008bd4: 80 a6 20 00 cmp %i0, 0
2008bd8: 02 80 00 0a be 2008c00 <_User_extensions_Handler_initialization+0x94><== NEVER TAKEN
2008bdc: a0 10 20 00 clr %l0
_User_extensions_Add_set (extension, &initial_extensions[i]);
2008be0: 90 10 00 11 mov %l1, %o0
2008be4: 40 00 0d c2 call 200c2ec <_User_extensions_Add_set>
2008be8: 92 10 00 19 mov %i1, %o1
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
2008bec: a0 04 20 01 inc %l0
_User_extensions_Add_set (extension, &initial_extensions[i]);
extension++;
2008bf0: a2 04 60 34 add %l1, 0x34, %l1
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
2008bf4: 80 a6 00 10 cmp %i0, %l0
2008bf8: 18 bf ff fa bgu 2008be0 <_User_extensions_Handler_initialization+0x74>
2008bfc: b2 06 60 20 add %i1, 0x20, %i1
2008c00: 81 c7 e0 08 ret
2008c04: 81 e8 00 00 restore
0200ad68 <_User_extensions_Remove_set>:
*/
void _User_extensions_Remove_set (
User_extensions_Control *the_extension
)
{
200ad68: 9d e3 bf 98 save %sp, -104, %sp
_Chain_Extract( &the_extension->Node );
200ad6c: 40 00 0b 42 call 200da74 <_Chain_Extract>
200ad70: 90 10 00 18 mov %i0, %o0
/*
* If a switch handler is present, remove it.
*/
if ( the_extension->Callouts.thread_switch != NULL )
200ad74: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ad78: 80 a0 60 00 cmp %g1, 0
200ad7c: 02 80 00 04 be 200ad8c <_User_extensions_Remove_set+0x24> <== ALWAYS TAKEN
200ad80: 01 00 00 00 nop
_Chain_Extract( &the_extension->Switch.Node );
200ad84: 40 00 0b 3c call 200da74 <_Chain_Extract> <== NOT EXECUTED
200ad88: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED
200ad8c: 81 c7 e0 08 ret
200ad90: 81 e8 00 00 restore
02008c08 <_User_extensions_Thread_begin>:
*/
void _User_extensions_Thread_begin (
Thread_Control *executing
)
{
2008c08: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
2008c0c: 03 00 80 5d sethi %hi(0x2017400), %g1
2008c10: e0 00 62 18 ld [ %g1 + 0x218 ], %l0 ! 2017618 <_User_extensions_List>
2008c14: 82 10 62 18 or %g1, 0x218, %g1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
2008c18: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2008c1c: 80 a4 00 11 cmp %l0, %l1
2008c20: 02 80 00 0c be 2008c50 <_User_extensions_Thread_begin+0x48><== NEVER TAKEN
2008c24: 01 00 00 00 nop
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_begin != NULL )
2008c28: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
2008c2c: 80 a0 60 00 cmp %g1, 0
2008c30: 02 80 00 04 be 2008c40 <_User_extensions_Thread_begin+0x38>
2008c34: 90 10 00 18 mov %i0, %o0
(*the_extension->Callouts.thread_begin)( executing );
2008c38: 9f c0 40 00 call %g1
2008c3c: 01 00 00 00 nop
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
2008c40: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2008c44: 80 a4 00 11 cmp %l0, %l1
2008c48: 32 bf ff f9 bne,a 2008c2c <_User_extensions_Thread_begin+0x24>
2008c4c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
2008c50: 81 c7 e0 08 ret
2008c54: 81 e8 00 00 restore
02008cf8 <_User_extensions_Thread_create>:
*/
bool _User_extensions_Thread_create (
Thread_Control *the_thread
)
{
2008cf8: 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 ;
2008cfc: 03 00 80 5d sethi %hi(0x2017400), %g1
2008d00: e0 00 62 18 ld [ %g1 + 0x218 ], %l0 ! 2017618 <_User_extensions_List>
2008d04: 82 10 62 18 or %g1, 0x218, %g1
2008d08: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2008d0c: 80 a4 00 11 cmp %l0, %l1
2008d10: 02 80 00 10 be 2008d50 <_User_extensions_Thread_create+0x58><== NEVER TAKEN
2008d14: 03 00 80 5d sethi %hi(0x2017400), %g1
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)(
2008d18: a4 10 60 a4 or %g1, 0xa4, %l2 ! 20174a4 <_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 ) {
2008d1c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
2008d20: 80 a0 60 00 cmp %g1, 0
2008d24: 02 80 00 07 be 2008d40 <_User_extensions_Thread_create+0x48>
2008d28: 92 10 00 18 mov %i0, %o1
status = (*the_extension->Callouts.thread_create)(
2008d2c: 9f c0 40 00 call %g1
2008d30: d0 04 80 00 ld [ %l2 ], %o0
_Thread_Executing,
the_thread
);
if ( !status )
2008d34: 80 8a 20 ff btst 0xff, %o0
2008d38: 02 80 00 08 be 2008d58 <_User_extensions_Thread_create+0x60><== NEVER TAKEN
2008d3c: 01 00 00 00 nop
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 ) {
2008d40: 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 ) ;
2008d44: 80 a4 00 11 cmp %l0, %l1
2008d48: 32 bf ff f6 bne,a 2008d20 <_User_extensions_Thread_create+0x28>
2008d4c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
return FALSE;
}
}
return TRUE;
}
2008d50: 81 c7 e0 08 ret
2008d54: 91 e8 20 01 restore %g0, 1, %o0
if ( the_extension->Callouts.thread_create != NULL ) {
status = (*the_extension->Callouts.thread_create)(
_Thread_Executing,
the_thread
);
if ( !status )
2008d58: 81 c7 e0 08 ret <== NOT EXECUTED
2008d5c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02008d60 <_User_extensions_Thread_delete>:
*/
void _User_extensions_Thread_delete (
Thread_Control *the_thread
)
{
2008d60: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
2008d64: 03 00 80 5d sethi %hi(0x2017400), %g1
2008d68: 82 10 62 18 or %g1, 0x218, %g1 ! 2017618 <_User_extensions_List>
2008d6c: e0 00 60 08 ld [ %g1 + 8 ], %l0
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008d70: 80 a4 00 01 cmp %l0, %g1
2008d74: 02 80 00 0e be 2008dac <_User_extensions_Thread_delete+0x4c><== NEVER TAKEN
2008d78: a4 10 00 01 mov %g1, %l2
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
(*the_extension->Callouts.thread_delete)(
2008d7c: 03 00 80 5d sethi %hi(0x2017400), %g1
2008d80: a2 10 60 a4 or %g1, 0xa4, %l1 ! 20174a4 <_Thread_Executing>
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_delete != NULL )
2008d84: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
2008d88: 80 a0 60 00 cmp %g1, 0
2008d8c: 02 80 00 04 be 2008d9c <_User_extensions_Thread_delete+0x3c>
2008d90: 92 10 00 18 mov %i0, %o1
(*the_extension->Callouts.thread_delete)(
2008d94: 9f c0 40 00 call %g1
2008d98: d0 04 40 00 ld [ %l1 ], %o0
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
2008d9c: e0 04 20 04 ld [ %l0 + 4 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008da0: 80 a4 00 12 cmp %l0, %l2
2008da4: 32 bf ff f9 bne,a 2008d88 <_User_extensions_Thread_delete+0x28>
2008da8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
2008dac: 81 c7 e0 08 ret
2008db0: 81 e8 00 00 restore
02008c58 <_User_extensions_Thread_exitted>:
*/
void _User_extensions_Thread_exitted (
Thread_Control *executing
)
{
2008c58: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
2008c5c: 03 00 80 5d sethi %hi(0x2017400), %g1
2008c60: 82 10 62 18 or %g1, 0x218, %g1 ! 2017618 <_User_extensions_List>
2008c64: e0 00 60 08 ld [ %g1 + 8 ], %l0
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008c68: 80 a4 00 01 cmp %l0, %g1
2008c6c: 02 80 00 0c be 2008c9c <_User_extensions_Thread_exitted+0x44><== NEVER TAKEN
2008c70: a2 10 00 01 mov %g1, %l1
the_node = the_node->previous ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_exitted != NULL )
2008c74: c2 04 20 2c ld [ %l0 + 0x2c ], %g1
2008c78: 80 a0 60 00 cmp %g1, 0
2008c7c: 02 80 00 04 be 2008c8c <_User_extensions_Thread_exitted+0x34>
2008c80: 90 10 00 18 mov %i0, %o0
(*the_extension->Callouts.thread_exitted)( executing );
2008c84: 9f c0 40 00 call %g1
2008c88: 01 00 00 00 nop
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
the_node = the_node->previous ) {
2008c8c: e0 04 20 04 ld [ %l0 + 4 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.last ;
!_Chain_Is_head( &_User_extensions_List, the_node ) ;
2008c90: 80 a4 00 11 cmp %l0, %l1
2008c94: 32 bf ff f9 bne,a 2008c78 <_User_extensions_Thread_exitted+0x20>
2008c98: c2 04 20 2c ld [ %l0 + 0x2c ], %g1
2008c9c: 81 c7 e0 08 ret
2008ca0: 81 e8 00 00 restore
020099e8 <_User_extensions_Thread_restart>:
*/
void _User_extensions_Thread_restart (
Thread_Control *the_thread
)
{
20099e8: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
20099ec: 03 00 80 6a sethi %hi(0x201a800), %g1
20099f0: e0 00 63 48 ld [ %g1 + 0x348 ], %l0 ! 201ab48 <_User_extensions_List>
20099f4: 82 10 63 48 or %g1, 0x348, %g1
20099f8: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
20099fc: 80 a4 00 11 cmp %l0, %l1
2009a00: 02 80 00 0d be 2009a34 <_User_extensions_Thread_restart+0x4c><== NEVER TAKEN
2009a04: 03 00 80 6a sethi %hi(0x201a800), %g1
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_restart != NULL )
(*the_extension->Callouts.thread_restart)(
2009a08: a4 10 61 d4 or %g1, 0x1d4, %l2 ! 201a9d4 <_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_restart != NULL )
2009a0c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2009a10: 80 a0 60 00 cmp %g1, 0
2009a14: 02 80 00 04 be 2009a24 <_User_extensions_Thread_restart+0x3c>
2009a18: 92 10 00 18 mov %i0, %o1
(*the_extension->Callouts.thread_restart)(
2009a1c: 9f c0 40 00 call %g1
2009a20: d0 04 80 00 ld [ %l2 ], %o0
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
2009a24: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2009a28: 80 a4 00 11 cmp %l0, %l1
2009a2c: 32 bf ff f9 bne,a 2009a10 <_User_extensions_Thread_restart+0x28>
2009a30: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
2009a34: 81 c7 e0 08 ret
2009a38: 81 e8 00 00 restore
02008db4 <_User_extensions_Thread_start>:
*/
void _User_extensions_Thread_start (
Thread_Control *the_thread
)
{
2008db4: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
2008db8: 03 00 80 5d sethi %hi(0x2017400), %g1
2008dbc: e0 00 62 18 ld [ %g1 + 0x218 ], %l0 ! 2017618 <_User_extensions_List>
2008dc0: 82 10 62 18 or %g1, 0x218, %g1
2008dc4: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2008dc8: 80 a4 00 11 cmp %l0, %l1
2008dcc: 02 80 00 0d be 2008e00 <_User_extensions_Thread_start+0x4c><== NEVER TAKEN
2008dd0: 03 00 80 5d sethi %hi(0x2017400), %g1
the_node = the_node->next ) {
the_extension = (User_extensions_Control *) the_node;
if ( the_extension->Callouts.thread_start != NULL )
(*the_extension->Callouts.thread_start)(
2008dd4: a4 10 60 a4 or %g1, 0xa4, %l2 ! 20174a4 <_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_start != NULL )
2008dd8: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
2008ddc: 80 a0 60 00 cmp %g1, 0
2008de0: 02 80 00 04 be 2008df0 <_User_extensions_Thread_start+0x3c>
2008de4: 92 10 00 18 mov %i0, %o1
(*the_extension->Callouts.thread_start)(
2008de8: 9f c0 40 00 call %g1
2008dec: d0 04 80 00 ld [ %l2 ], %o0
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
the_node = the_node->next ) {
2008df0: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
User_extensions_Control *the_extension;
for ( the_node = _User_extensions_List.first ;
!_Chain_Is_tail( &_User_extensions_List, the_node ) ;
2008df4: 80 a4 00 11 cmp %l0, %l1
2008df8: 32 bf ff f9 bne,a 2008ddc <_User_extensions_Thread_start+0x28>
2008dfc: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
2008e00: 81 c7 e0 08 ret
2008e04: 81 e8 00 00 restore
02008e08 <_User_extensions_Thread_switch>:
*/
void _User_extensions_Thread_switch (
Thread_Control *executing,
Thread_Control *heir
)
{
2008e08: 9d e3 bf 98 save %sp, -104, %sp
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
2008e0c: 03 00 80 5c sethi %hi(0x2017000), %g1
2008e10: e0 00 63 e4 ld [ %g1 + 0x3e4 ], %l0 ! 20173e4 <_User_extensions_Switches_list>
2008e14: 82 10 63 e4 or %g1, 0x3e4, %g1
2008e18: a2 00 60 04 add %g1, 4, %l1
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
2008e1c: 80 a4 00 11 cmp %l0, %l1
2008e20: 02 80 00 0a be 2008e48 <_User_extensions_Thread_switch+0x40><== NEVER TAKEN
2008e24: 01 00 00 00 nop
the_node = the_node->next ) {
the_extension_switch = (User_extensions_Switch_control *) the_node;
(*the_extension_switch->thread_switch)( executing, heir );
2008e28: c2 04 20 08 ld [ %l0 + 8 ], %g1
2008e2c: 90 10 00 18 mov %i0, %o0
2008e30: 9f c0 40 00 call %g1
2008e34: 92 10 00 19 mov %i1, %o1
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
the_node = the_node->next ) {
2008e38: e0 04 00 00 ld [ %l0 ], %l0
{
Chain_Node *the_node;
User_extensions_Switch_control *the_extension_switch;
for ( the_node = _User_extensions_Switches_list.first ;
!_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
2008e3c: 80 a4 00 11 cmp %l0, %l1
2008e40: 32 bf ff fb bne,a 2008e2c <_User_extensions_Thread_switch+0x24>
2008e44: c2 04 20 08 ld [ %l0 + 8 ], %g1
2008e48: 81 c7 e0 08 ret
2008e4c: 81 e8 00 00 restore
0200acd4 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200acd4: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
_ISR_Disable( level );
200acd8: 7f ff df 60 call 2002a58 <sparc_disable_interrupts>
200acdc: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
200ace0: 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;
200ace4: a0 06 20 04 add %i0, 4, %l0
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
200ace8: 80 a0 80 10 cmp %g2, %l0
200acec: 02 80 00 1f be 200ad68 <_Watchdog_Adjust+0x94>
200acf0: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200acf4: 12 80 00 1f bne 200ad70 <_Watchdog_Adjust+0x9c>
200acf8: 80 a6 60 01 cmp %i1, 1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200acfc: 80 a6 a0 00 cmp %i2, 0
200ad00: 02 80 00 1a be 200ad68 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200ad04: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
200ad08: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1
200ad0c: 80 a6 80 19 cmp %i2, %i1
200ad10: 1a 80 00 0b bcc 200ad3c <_Watchdog_Adjust+0x68> <== ALWAYS TAKEN
200ad14: a2 10 20 01 mov 1, %l1
_Watchdog_First( header )->delta_interval -= units;
200ad18: 10 80 00 1d b 200ad8c <_Watchdog_Adjust+0xb8> <== NOT EXECUTED
200ad1c: 82 26 40 1a sub %i1, %i2, %g1 <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200ad20: b4 a6 80 19 subcc %i2, %i1, %i2
200ad24: 02 80 00 11 be 200ad68 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200ad28: 01 00 00 00 nop
if ( units < _Watchdog_First( header )->delta_interval ) {
200ad2c: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1
200ad30: 80 a6 40 1a cmp %i1, %i2
200ad34: 18 80 00 16 bgu 200ad8c <_Watchdog_Adjust+0xb8>
200ad38: 82 26 40 1a sub %i1, %i2, %g1
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
200ad3c: e2 20 a0 10 st %l1, [ %g2 + 0x10 ]
_ISR_Enable( level );
200ad40: 7f ff df 4a call 2002a68 <sparc_enable_interrupts>
200ad44: 01 00 00 00 nop
_Watchdog_Tickle( header );
200ad48: 40 00 00 b4 call 200b018 <_Watchdog_Tickle>
200ad4c: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200ad50: 7f ff df 42 call 2002a58 <sparc_disable_interrupts>
200ad54: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
200ad58: c2 06 00 00 ld [ %i0 ], %g1
if ( _Chain_Is_empty( header ) )
200ad5c: 80 a4 00 01 cmp %l0, %g1
200ad60: 12 bf ff f0 bne 200ad20 <_Watchdog_Adjust+0x4c>
200ad64: 84 10 00 01 mov %g1, %g2
}
break;
}
}
_ISR_Enable( level );
200ad68: 7f ff df 40 call 2002a68 <sparc_enable_interrupts>
200ad6c: 91 e8 00 08 restore %g0, %o0, %o0
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
200ad70: 12 bf ff fe bne 200ad68 <_Watchdog_Adjust+0x94> <== NEVER TAKEN
200ad74: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200ad78: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
200ad7c: 82 00 40 1a add %g1, %i2, %g1
200ad80: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
}
break;
}
}
_ISR_Enable( level );
200ad84: 7f ff df 39 call 2002a68 <sparc_enable_interrupts>
200ad88: 91 e8 00 08 restore %g0, %o0, %o0
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
200ad8c: 10 bf ff f7 b 200ad68 <_Watchdog_Adjust+0x94>
200ad90: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
02016418 <_Watchdog_Adjust_to_chain>:
Chain_Control *header,
Watchdog_Interval units_arg,
Chain_Control *to_fire
)
{
2016418: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval units = units_arg;
ISR_Level level;
Chain_Node *node;
if ( !units ) {
201641c: a2 96 60 00 orcc %i1, 0, %l1
2016420: 12 80 00 04 bne 2016430 <_Watchdog_Adjust_to_chain+0x18>
2016424: 01 00 00 00 nop
2016428: 81 c7 e0 08 ret
201642c: 81 e8 00 00 restore
return;
}
_ISR_Disable( level );
2016430: 7f ff d3 91 call 200b274 <sparc_disable_interrupts>
2016434: 01 00 00 00 nop
2016438: a6 10 00 08 mov %o0, %l3
201643c: 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;
2016440: a0 06 20 04 add %i0, 4, %l0
if ( !_Chain_Is_empty( header ) ) {
2016444: 80 a0 80 10 cmp %g2, %l0
2016448: 02 80 00 25 be 20164dc <_Watchdog_Adjust_to_chain+0xc4>
201644c: a4 06 a0 04 add %i2, 4, %l2
2016450: f2 00 a0 10 ld [ %g2 + 0x10 ], %i1
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
2016454: 80 a6 40 11 cmp %i1, %l1
2016458: 18 80 00 20 bgu 20164d8 <_Watchdog_Adjust_to_chain+0xc0>
201645c: 82 26 40 11 sub %i1, %l1, %g1
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 0;
2016460: 10 80 00 15 b 20164b4 <_Watchdog_Adjust_to_chain+0x9c>
2016464: c0 20 a0 10 clr [ %g2 + 0x10 ]
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
the_chain->first = new_first;
2016468: c2 26 00 00 st %g1, [ %i0 ]
new_first->previous = _Chain_Head(the_chain);
201646c: f0 20 60 04 st %i0, [ %g1 + 4 ]
Chain_Node *the_node
)
{
Chain_Node *old_last_node;
the_node->next = _Chain_Tail(the_chain);
2016470: e4 20 80 00 st %l2, [ %g2 ]
old_last_node = the_chain->last;
2016474: c2 06 a0 08 ld [ %i2 + 8 ], %g1
the_chain->last = the_node;
2016478: c4 26 a0 08 st %g2, [ %i2 + 8 ]
old_last_node->next = the_node;
the_node->previous = old_last_node;
201647c: 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;
2016480: c4 20 40 00 st %g2, [ %g1 ]
do {
node = _Chain_Get_unprotected( header );
_Chain_Append_unprotected( to_fire, node );
_ISR_Flash( level );
2016484: 7f ff d3 80 call 200b284 <sparc_enable_interrupts>
2016488: 90 10 00 13 mov %l3, %o0
201648c: 7f ff d3 7a call 200b274 <sparc_disable_interrupts>
2016490: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
2016494: c4 06 00 00 ld [ %i0 ], %g2
} while ( !_Chain_Is_empty( header ) &&
_Watchdog_First( header )->delta_interval == 0 );
2016498: 80 a4 00 02 cmp %l0, %g2
201649c: 02 80 00 10 be 20164dc <_Watchdog_Adjust_to_chain+0xc4>
20164a0: 01 00 00 00 nop
20164a4: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
20164a8: 80 a0 60 00 cmp %g1, 0
20164ac: 32 80 00 07 bne,a 20164c8 <_Watchdog_Adjust_to_chain+0xb0>
20164b0: a2 a4 40 19 subcc %l1, %i1, %l1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
20164b4: 80 a4 00 02 cmp %l0, %g2
20164b8: 32 bf ff ec bne,a 2016468 <_Watchdog_Adjust_to_chain+0x50><== ALWAYS TAKEN
20164bc: c2 00 80 00 ld [ %g2 ], %g1
20164c0: 10 bf ff ec b 2016470 <_Watchdog_Adjust_to_chain+0x58> <== NOT EXECUTED
20164c4: 84 10 20 00 clr %g2 <== NOT EXECUTED
return;
}
_ISR_Disable( level );
if ( !_Chain_Is_empty( header ) ) {
while ( units ) {
20164c8: 02 80 00 05 be 20164dc <_Watchdog_Adjust_to_chain+0xc4> <== ALWAYS TAKEN
20164cc: 01 00 00 00 nop
20164d0: 10 bf ff e1 b 2016454 <_Watchdog_Adjust_to_chain+0x3c> <== NOT EXECUTED
20164d4: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
20164d8: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
break;
}
}
}
_ISR_Enable( level );
20164dc: 7f ff d3 6a call 200b284 <sparc_enable_interrupts>
20164e0: 91 e8 00 13 restore %g0, %l3, %o0
02008e50 <_Watchdog_Insert>:
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
2008e50: 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;
2008e54: 03 00 80 5d sethi %hi(0x2017400), %g1
void _Watchdog_Insert(
Chain_Control *header,
Watchdog_Control *the_watchdog
)
{
2008e58: ac 10 00 18 mov %i0, %l6
Watchdog_Control *after;
uint32_t insert_isr_nest_level;
Watchdog_Interval delta_interval;
insert_isr_nest_level = _ISR_Nest_level;
2008e5c: e6 00 60 80 ld [ %g1 + 0x80 ], %l3
_ISR_Disable( level );
2008e60: 7f ff e3 e1 call 2001de4 <sparc_disable_interrupts>
2008e64: 01 00 00 00 nop
2008e68: 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 ) {
2008e6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
2008e70: 80 a0 60 00 cmp %g1, 0
2008e74: 12 80 00 4a bne 2008f9c <_Watchdog_Insert+0x14c> <== NEVER TAKEN
2008e78: 01 00 00 00 nop
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
2008e7c: 2b 00 80 5d sethi %hi(0x2017400), %l5
2008e80: c2 05 61 30 ld [ %l5 + 0x130 ], %g1 ! 2017530 <_Watchdog_Sync_count>
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
2008e84: 84 10 20 01 mov 1, %g2
_Watchdog_Sync_count++;
2008e88: 82 00 60 01 inc %g1
2008e8c: 2f 00 80 5d sethi %hi(0x2017400), %l7
if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
_ISR_Enable( level );
return;
}
the_watchdog->state = WATCHDOG_BEING_INSERTED;
2008e90: c4 26 60 08 st %g2, [ %i1 + 8 ]
2008e94: a8 15 e0 a0 or %l7, 0xa0, %l4
_Watchdog_Sync_count++;
2008e98: c2 25 61 30 st %g1, [ %l5 + 0x130 ]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
2008e9c: ba 10 00 14 mov %l4, %i5
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
2008ea0: 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 ;
2008ea4: e2 05 80 00 ld [ %l6 ], %l1
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
2008ea8: 80 a4 a0 00 cmp %l2, 0
2008eac: 02 80 00 2b be 2008f58 <_Watchdog_Insert+0x108> <== NEVER TAKEN
2008eb0: 03 00 80 5d sethi %hi(0x2017400), %g1
2008eb4: c2 04 40 00 ld [ %l1 ], %g1
2008eb8: 80 a0 60 00 cmp %g1, 0
2008ebc: 02 80 00 27 be 2008f58 <_Watchdog_Insert+0x108>
2008ec0: 03 00 80 5d sethi %hi(0x2017400), %g1
break;
if ( delta_interval < after->delta_interval ) {
2008ec4: e0 04 60 10 ld [ %l1 + 0x10 ], %l0
2008ec8: 80 a4 80 10 cmp %l2, %l0
2008ecc: 1a 80 00 13 bcc 2008f18 <_Watchdog_Insert+0xc8>
2008ed0: 82 24 00 12 sub %l0, %l2, %g1
after->delta_interval -= delta_interval;
2008ed4: 10 80 00 20 b 2008f54 <_Watchdog_Insert+0x104>
2008ed8: c2 24 60 10 st %g1, [ %l1 + 0x10 ]
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
2008edc: c2 05 00 00 ld [ %l4 ], %g1
2008ee0: 80 a4 c0 01 cmp %l3, %g1
2008ee4: 0a 80 00 30 bcs 2008fa4 <_Watchdog_Insert+0x154>
2008ee8: 01 00 00 00 nop
*/
for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ;
;
after = _Watchdog_Next( after ) ) {
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
2008eec: a4 a4 80 10 subcc %l2, %l0, %l2
2008ef0: 02 80 00 19 be 2008f54 <_Watchdog_Insert+0x104>
2008ef4: e2 04 40 00 ld [ %l1 ], %l1
2008ef8: c2 04 40 00 ld [ %l1 ], %g1
2008efc: 80 a0 60 00 cmp %g1, 0
2008f00: 02 80 00 16 be 2008f58 <_Watchdog_Insert+0x108>
2008f04: 03 00 80 5d sethi %hi(0x2017400), %g1
break;
if ( delta_interval < after->delta_interval ) {
2008f08: e0 04 60 10 ld [ %l1 + 0x10 ], %l0
2008f0c: 80 a4 00 12 cmp %l0, %l2
2008f10: 18 80 00 10 bgu 2008f50 <_Watchdog_Insert+0x100>
2008f14: 82 24 00 12 sub %l0, %l2, %g1
* 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 );
2008f18: 7f ff e3 b7 call 2001df4 <sparc_enable_interrupts>
2008f1c: 90 10 00 18 mov %i0, %o0
2008f20: 7f ff e3 b1 call 2001de4 <sparc_disable_interrupts>
2008f24: 01 00 00 00 nop
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
2008f28: c2 06 60 08 ld [ %i1 + 8 ], %g1
2008f2c: 80 a0 60 01 cmp %g1, 1
2008f30: 02 bf ff eb be 2008edc <_Watchdog_Insert+0x8c> <== ALWAYS TAKEN
2008f34: 01 00 00 00 nop
_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;
2008f38: e6 25 e0 a0 st %l3, [ %l7 + 0xa0 ] <== NOT EXECUTED
_Watchdog_Sync_count--;
2008f3c: c2 05 61 30 ld [ %l5 + 0x130 ], %g1 <== NOT EXECUTED
2008f40: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2008f44: c2 25 61 30 st %g1, [ %l5 + 0x130 ] <== NOT EXECUTED
_ISR_Enable( level );
2008f48: 7f ff e3 ab call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2008f4c: 81 e8 00 00 restore <== NOT EXECUTED
if ( delta_interval == 0 || !_Watchdog_Next( after ) )
break;
if ( delta_interval < after->delta_interval ) {
after->delta_interval -= delta_interval;
2008f50: c2 24 60 10 st %g1, [ %l1 + 0x10 ]
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
2008f54: 03 00 80 5d sethi %hi(0x2017400), %g1
2008f58: c6 00 61 34 ld [ %g1 + 0x134 ], %g3 ! 2017534 <_Watchdog_Ticks_since_boot>
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
_Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
2008f5c: c4 04 60 04 ld [ %l1 + 4 ], %g2
the_watchdog->start_time = _Watchdog_Ticks_since_boot;
2008f60: c6 26 60 14 st %g3, [ %i1 + 0x14 ]
}
}
_Watchdog_Activate( the_watchdog );
the_watchdog->delta_interval = delta_interval;
2008f64: e4 26 60 10 st %l2, [ %i1 + 0x10 ]
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_ACTIVE;
2008f68: 82 10 20 02 mov 2, %g1
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008f6c: c8 00 80 00 ld [ %g2 ], %g4
_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;
2008f70: e6 25 e0 a0 st %l3, [ %l7 + 0xa0 ]
2008f74: c2 26 60 08 st %g1, [ %i1 + 8 ]
_Watchdog_Sync_count--;
2008f78: c2 05 61 30 ld [ %l5 + 0x130 ], %g1
after_node->next = the_node;
2008f7c: f2 20 80 00 st %i1, [ %g2 ]
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008f80: c4 26 60 04 st %g2, [ %i1 + 4 ]
2008f84: 82 00 7f ff add %g1, -1, %g1
before_node = after_node->next;
after_node->next = the_node;
the_node->next = before_node;
before_node->previous = the_node;
2008f88: f2 21 20 04 st %i1, [ %g4 + 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;
2008f8c: c8 26 40 00 st %g4, [ %i1 ]
2008f90: c2 25 61 30 st %g1, [ %l5 + 0x130 ]
_ISR_Enable( level );
2008f94: 7f ff e3 98 call 2001df4 <sparc_enable_interrupts>
2008f98: 81 e8 00 00 restore
* 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 ) {
_ISR_Enable( level );
2008f9c: 7f ff e3 96 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2008fa0: 81 e8 00 00 restore <== NOT EXECUTED
if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
goto exit_insert;
}
if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
_Watchdog_Sync_level = insert_isr_nest_level;
2008fa4: e6 27 40 00 st %l3, [ %i5 ]
the_watchdog->state = WATCHDOG_BEING_INSERTED;
_Watchdog_Sync_count++;
restart:
delta_interval = the_watchdog->initial;
2008fa8: 10 bf ff bf b 2008ea4 <_Watchdog_Insert+0x54>
2008fac: e4 06 60 0c ld [ %i1 + 0xc ], %l2
02008ffc <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
2008ffc: 9d e3 bf 98 save %sp, -104, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
2009000: 7f ff e3 79 call 2001de4 <sparc_disable_interrupts>
2009004: a0 10 00 18 mov %i0, %l0
previous_state = the_watchdog->state;
2009008: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
200900c: 80 a6 20 01 cmp %i0, 1
2009010: 02 80 00 2a be 20090b8 <_Watchdog_Remove+0xbc> <== NEVER TAKEN
2009014: 03 00 80 5d sethi %hi(0x2017400), %g1
2009018: 1a 80 00 09 bcc 200903c <_Watchdog_Remove+0x40>
200901c: 80 a6 20 03 cmp %i0, 3
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
2009020: 03 00 80 5d sethi %hi(0x2017400), %g1
2009024: c4 00 61 34 ld [ %g1 + 0x134 ], %g2 ! 2017534 <_Watchdog_Ticks_since_boot>
2009028: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
_ISR_Enable( level );
200902c: 7f ff e3 72 call 2001df4 <sparc_enable_interrupts>
2009030: 01 00 00 00 nop
return( previous_state );
}
2009034: 81 c7 e0 08 ret
2009038: 81 e8 00 00 restore
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
switch ( previous_state ) {
200903c: 18 bf ff fa bgu 2009024 <_Watchdog_Remove+0x28> <== NEVER TAKEN
2009040: 03 00 80 5d sethi %hi(0x2017400), %g1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
2009044: c8 04 00 00 ld [ %l0 ], %g4
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
2009048: c0 24 20 08 clr [ %l0 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200904c: c2 01 00 00 ld [ %g4 ], %g1
2009050: 80 a0 60 00 cmp %g1, 0
2009054: 02 80 00 07 be 2009070 <_Watchdog_Remove+0x74>
2009058: 03 00 80 5d sethi %hi(0x2017400), %g1
next_watchdog->delta_interval += the_watchdog->delta_interval;
200905c: c2 01 20 10 ld [ %g4 + 0x10 ], %g1
2009060: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
2009064: 82 00 40 02 add %g1, %g2, %g1
2009068: c2 21 20 10 st %g1, [ %g4 + 0x10 ]
if ( _Watchdog_Sync_count )
200906c: 03 00 80 5d sethi %hi(0x2017400), %g1
2009070: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 2017530 <_Watchdog_Sync_count>
2009074: 80 a0 a0 00 cmp %g2, 0
2009078: 22 80 00 07 be,a 2009094 <_Watchdog_Remove+0x98> <== ALWAYS TAKEN
200907c: c2 04 20 04 ld [ %l0 + 4 ], %g1
_Watchdog_Sync_level = _ISR_Nest_level;
2009080: 03 00 80 5d sethi %hi(0x2017400), %g1 <== NOT EXECUTED
2009084: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 ! 2017480 <_ISR_Nest_level><== NOT EXECUTED
2009088: 05 00 80 5d sethi %hi(0x2017400), %g2 <== NOT EXECUTED
200908c: c6 20 a0 a0 st %g3, [ %g2 + 0xa0 ] ! 20174a0 <_Watchdog_Sync_level><== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2009090: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
next->previous = previous;
previous->next = next;
2009094: c8 20 40 00 st %g4, [ %g1 ]
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
next->previous = previous;
2009098: c2 21 20 04 st %g1, [ %g4 + 4 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200909c: 03 00 80 5d sethi %hi(0x2017400), %g1
20090a0: c4 00 61 34 ld [ %g1 + 0x134 ], %g2 ! 2017534 <_Watchdog_Ticks_since_boot>
20090a4: c4 24 20 18 st %g2, [ %l0 + 0x18 ]
_ISR_Enable( level );
20090a8: 7f ff e3 53 call 2001df4 <sparc_enable_interrupts>
20090ac: 01 00 00 00 nop
return( previous_state );
}
20090b0: 81 c7 e0 08 ret
20090b4: 81 e8 00 00 restore
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
20090b8: c4 00 61 34 ld [ %g1 + 0x134 ], %g2 <== NOT EXECUTED
/*
* It is not actually on the chain so just change the state and
* the Insert operation we interrupted will be aborted.
*/
the_watchdog->state = WATCHDOG_INACTIVE;
20090bc: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED
_Watchdog_Sync_level = _ISR_Nest_level;
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
20090c0: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED
_ISR_Enable( level );
20090c4: 7f ff e3 4c call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20090c8: 01 00 00 00 nop <== NOT EXECUTED
return( previous_state );
}
20090cc: 81 c7 e0 08 ret <== NOT EXECUTED
20090d0: 81 e8 00 00 restore <== NOT EXECUTED
020090d4 <_Watchdog_Tickle>:
*/
void _Watchdog_Tickle(
Chain_Control *header
)
{
20090d4: 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 );
20090d8: 7f ff e3 43 call 2001de4 <sparc_disable_interrupts>
20090dc: a4 10 00 18 mov %i0, %l2
20090e0: 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));
20090e4: 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;
20090e8: a6 04 a0 04 add %l2, 4, %l3
if ( _Chain_Is_empty( header ) )
20090ec: 80 a0 80 13 cmp %g2, %l3
20090f0: 02 80 00 0a be 2009118 <_Watchdog_Tickle+0x44>
20090f4: 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) {
20090f8: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
20090fc: 80 a0 60 00 cmp %g1, 0
2009100: 02 80 00 16 be 2009158 <_Watchdog_Tickle+0x84> <== NEVER TAKEN
2009104: a2 10 00 02 mov %g2, %l1
the_watchdog->delta_interval--;
2009108: 82 00 7f ff add %g1, -1, %g1
if ( the_watchdog->delta_interval != 0 )
200910c: 80 a0 60 00 cmp %g1, 0
2009110: 02 80 00 12 be 2009158 <_Watchdog_Tickle+0x84>
2009114: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
leave:
_ISR_Enable(level);
2009118: 7f ff e3 37 call 2001df4 <sparc_enable_interrupts>
200911c: 81 e8 00 00 restore
_ISR_Enable( level );
switch( watchdog_state ) {
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
2009120: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
2009124: 9f c0 40 00 call %g1
2009128: d0 04 60 20 ld [ %l1 + 0x20 ], %o0
case WATCHDOG_REMOVE_IT:
break;
}
_ISR_Disable( level );
200912c: 7f ff e3 2e call 2001de4 <sparc_disable_interrupts>
2009130: 01 00 00 00 nop
2009134: b0 10 00 08 mov %o0, %i0
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
2009138: c2 04 80 00 ld [ %l2 ], %g1
the_watchdog = _Watchdog_First( header );
} while ( !_Chain_Is_empty( header ) &&
(the_watchdog->delta_interval == 0) );
200913c: 80 a4 c0 01 cmp %l3, %g1
2009140: 02 bf ff f6 be 2009118 <_Watchdog_Tickle+0x44>
2009144: a2 10 00 01 mov %g1, %l1
2009148: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200914c: 80 a0 60 00 cmp %g1, 0
2009150: 12 bf ff f2 bne 2009118 <_Watchdog_Tickle+0x44>
2009154: 01 00 00 00 nop
if ( the_watchdog->delta_interval != 0 )
goto leave;
}
do {
watchdog_state = _Watchdog_Remove( the_watchdog );
2009158: 7f ff ff a9 call 2008ffc <_Watchdog_Remove>
200915c: 90 10 00 11 mov %l1, %o0
2009160: a0 10 00 08 mov %o0, %l0
_ISR_Enable( level );
2009164: 7f ff e3 24 call 2001df4 <sparc_enable_interrupts>
2009168: 90 10 00 18 mov %i0, %o0
switch( watchdog_state ) {
200916c: 80 a4 20 02 cmp %l0, 2
2009170: 12 bf ff ef bne 200912c <_Watchdog_Tickle+0x58> <== NEVER TAKEN
2009174: 01 00 00 00 nop
case WATCHDOG_ACTIVE:
(*the_watchdog->routine)(
2009178: 10 bf ff ea b 2009120 <_Watchdog_Tickle+0x4c>
200917c: d2 04 60 24 ld [ %l1 + 0x24 ], %o1
020091ec <_Workspace_Handler_initialization>:
*/
void _Workspace_Handler_initialization(
void *starting_address,
size_t size
)
{
20091ec: 9d e3 bf 98 save %sp, -104, %sp
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
20091f0: 80 a6 20 00 cmp %i0, 0
20091f4: 02 80 00 15 be 2009248 <_Workspace_Handler_initialization+0x5c>
20091f8: 80 8e 20 07 btst 7, %i0
20091fc: 12 80 00 14 bne 200924c <_Workspace_Handler_initialization+0x60><== NEVER TAKEN
2009200: 90 10 20 00 clr %o0
INTERNAL_ERROR_CORE,
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
2009204: 03 00 80 5d sethi %hi(0x2017400), %g1
2009208: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201747c <_Configuration_Table>
200920c: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
2009210: 80 a0 e0 00 cmp %g3, 0
2009214: 32 80 00 11 bne,a 2009258 <_Workspace_Handler_initialization+0x6c><== NEVER TAKEN
2009218: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
memset( starting_address, 0, size );
memory_available = _Heap_Initialize(
200921c: 92 10 00 18 mov %i0, %o1
2009220: 94 10 00 19 mov %i1, %o2
2009224: 11 00 80 5d sethi %hi(0x2017400), %o0
2009228: 96 10 20 08 mov 8, %o3
200922c: 7f ff f5 ab call 20068d8 <_Heap_Initialize>
2009230: 90 12 20 04 or %o0, 4, %o0
starting_address,
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
2009234: 80 a2 20 00 cmp %o0, 0
2009238: 02 80 00 0d be 200926c <_Workspace_Handler_initialization+0x80><== NEVER TAKEN
200923c: 92 10 20 01 mov 1, %o1
2009240: 81 c7 e0 08 ret
2009244: 81 e8 00 00 restore
)
{
uint32_t memory_available;
if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
_Internal_error_Occurred(
2009248: 90 10 20 00 clr %o0
200924c: 92 10 20 01 mov 1, %o1
2009250: 7f ff f6 2f call 2006b0c <_Internal_error_Occurred>
2009254: 94 10 20 02 mov 2, %o2
TRUE,
INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
);
if ( _Configuration_Table->do_zero_of_workspace )
memset( starting_address, 0, size );
2009258: 92 10 20 00 clr %o1 <== NOT EXECUTED
200925c: 40 00 11 25 call 200d6f0 <memset> <== NOT EXECUTED
2009260: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
memory_available = _Heap_Initialize(
2009264: 10 bf ff ef b 2009220 <_Workspace_Handler_initialization+0x34><== NOT EXECUTED
2009268: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
size,
CPU_HEAP_ALIGNMENT
);
if ( memory_available == 0 )
_Internal_error_Occurred(
200926c: 7f ff f6 28 call 2006b0c <_Internal_error_Occurred> <== NOT EXECUTED
2009270: 94 10 20 03 mov 3, %o2 <== NOT EXECUTED
02001f88 <__assert>:
void __assert(
const char *file,
int line,
const char *failedexpr
)
{
2001f88: 96 10 00 0a mov %o2, %o3 <== NOT EXECUTED
__assert_func (file, line, NULL, failedexpr);
2001f8c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2001f90: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2001f94: 7f ff ff eb call 2001f40 <__assert_func> <== NOT EXECUTED
2001f98: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02001f40 <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
2001f40: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
2001f44: 03 00 80 56 sethi %hi(0x2015800), %g1 <== NOT EXECUTED
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
2001f48: 9a 10 00 1a mov %i2, %o5 <== NOT EXECUTED
2001f4c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2001f50: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2001f54: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
2001f58: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2001f5c: 02 80 00 07 be 2001f78 <__assert_func+0x38> <== NOT EXECUTED
2001f60: 98 10 60 20 or %g1, 0x20, %o4 <== NOT EXECUTED
2001f64: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
2001f68: 40 00 04 1b call 2002fd4 <printk> <== NOT EXECUTED
2001f6c: 90 12 20 30 or %o0, 0x30, %o0 ! 2015830 <pollCallbacks.4767+0x320><== NOT EXECUTED
file,
line,
(func) ? ", function: " : "",
(func) ? func : ""
);
rtems_fatal_error_occurred(0);
2001f70: 40 00 0f fd call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2001f74: 90 10 20 00 clr %o0 <== NOT EXECUTED
int line,
const char *func,
const char *failedexpr
)
{
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
2001f78: 03 00 80 55 sethi %hi(0x2015400), %g1 <== NOT EXECUTED
2001f7c: 9a 10 63 d0 or %g1, 0x3d0, %o5 ! 20157d0 <pollCallbacks.4767+0x2c0><== NOT EXECUTED
2001f80: 10 bf ff f9 b 2001f64 <__assert_func+0x24> <== NOT EXECUTED
2001f84: 98 10 00 0d mov %o5, %o4 <== NOT EXECUTED
020180e8 <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
20180e8: 81 c3 e0 08 retl <== NOT EXECUTED
20180ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
020149a4 <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
_fini();
20149a4: 9d e3 bf 98 save %sp, -104, %sp
20149a8: 40 00 06 ef call 2016564 <_fini>
20149ac: 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();
20149b0: 7f ff ff e1 call 2014934 <libc_wrapup>
20149b4: 01 00 00 00 nop
rtems_shutdown_executive(status);
20149b8: 40 00 00 52 call 2014b00 <rtems_shutdown_executive>
20149bc: 90 10 00 18 mov %i0, %o0
20149c0: 30 80 00 00 b,a 20149c0 <_exit+0x1c> <== NOT EXECUTED
02017f58 <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr
)
{
return getpid();
}
2017f58: 81 c3 e0 08 retl <== NOT EXECUTED
2017f5c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
0200ab1c <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
200ab1c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
200ab20: 7f ff ff e6 call 200aab8 <gettimeofday> <== NOT EXECUTED
200ab24: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
020180e0 <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
20180e0: 81 c3 e0 08 retl <== NOT EXECUTED
20180e4: 90 10 20 00 clr %o0 <== NOT EXECUTED
02014904 <_lseek_r>:
int fd,
off_t offset,
int whence
)
{
return lseek( fd, offset, whence );
2014904: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2014908: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
201490c: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2014910: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2014914: 7f ff ff ba call 20147fc <lseek> <== NOT EXECUTED
2014918: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02002b34 <_open_r>:
const char *buf,
int flags,
int mode
)
{
return open( buf, flags, mode );
2002b34: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2002b38: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2002b3c: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2002b40: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2002b44: 7f ff ff 38 call 2002824 <open> <== NOT EXECUTED
2002b48: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02014ab0 <_read_r>:
int fd,
void *buf,
size_t nbytes
)
{
return read( fd, buf, nbytes );
2014ab0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2014ab4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2014ab8: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2014abc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2014ac0: 7f ff ff c1 call 20149c4 <read> <== NOT EXECUTED
2014ac4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02014acc <_realloc_r>:
struct _reent *ignored,
void *ptr,
size_t size
)
{
return realloc( ptr, size );
2014acc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2014ad0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2014ad4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2014ad8: 40 00 00 17 call 2014b34 <realloc> <== NOT EXECUTED
2014adc: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0200a7d8 <calloc>:
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
200a7d8: 9d e3 bf 98 save %sp, -104, %sp
200a7dc: 05 00 80 5c sethi %hi(0x2017000), %g2
200a7e0: a0 10 a2 70 or %g2, 0x270, %l0 ! 2017270 <rtems_malloc_statistics>
200a7e4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
length = nelem * elsize;
200a7e8: 92 10 00 18 mov %i0, %o1
)
{
register char *cptr;
int length;
MSBUMP(calloc_calls, 1);
200a7ec: 82 00 60 01 inc %g1
length = nelem * elsize;
200a7f0: 90 10 00 19 mov %i1, %o0
200a7f4: 40 00 24 25 call 2013888 <.umul>
200a7f8: c2 24 20 14 st %g1, [ %l0 + 0x14 ]
cptr = malloc( length );
200a7fc: 40 00 01 b4 call 200aecc <malloc>
200a800: b2 10 00 08 mov %o0, %i1
if ( cptr )
200a804: b0 92 20 00 orcc %o0, 0, %i0
200a808: 02 80 00 04 be 200a818 <calloc+0x40> <== NEVER TAKEN
200a80c: 94 10 00 19 mov %i1, %o2
memset( cptr, '\0', length );
200a810: 40 00 0b b8 call 200d6f0 <memset>
200a814: 92 10 20 00 clr %o1
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
200a818: c2 04 20 04 ld [ %l0 + 4 ], %g1
200a81c: 82 00 7f ff add %g1, -1, %g1
200a820: c2 24 20 04 st %g1, [ %l0 + 4 ]
return cptr;
}
200a824: 81 c7 e0 08 ret
200a828: 81 e8 00 00 restore
0200a82c <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
200a82c: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
200a830: 03 00 80 59 sethi %hi(0x2016400), %g1
200a834: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops>
200a838: 80 a6 00 02 cmp %i0, %g2
200a83c: 1a 80 00 23 bcc 200a8c8 <close+0x9c> <== NEVER TAKEN
200a840: 03 00 80 5c sethi %hi(0x2017000), %g1
iop = rtems_libio_iop(fd);
200a844: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops>
200a848: 85 2e 20 02 sll %i0, 2, %g2
200a84c: 83 2e 20 04 sll %i0, 4, %g1
200a850: 82 20 40 02 sub %g1, %g2, %g1
200a854: 82 00 40 18 add %g1, %i0, %g1
200a858: 83 28 60 02 sll %g1, 2, %g1
200a85c: b0 00 c0 01 add %g3, %g1, %i0
rtems_libio_check_is_open(iop);
200a860: c4 06 20 0c ld [ %i0 + 0xc ], %g2
200a864: 80 88 a1 00 btst 0x100, %g2
200a868: 02 80 00 18 be 200a8c8 <close+0x9c> <== NEVER TAKEN
200a86c: 01 00 00 00 nop
rc = RTEMS_SUCCESSFUL;
if ( iop->handlers->close_h )
200a870: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
200a874: c2 00 60 04 ld [ %g1 + 4 ], %g1
200a878: 80 a0 60 00 cmp %g1, 0
200a87c: 02 80 00 05 be 200a890 <close+0x64> <== NEVER TAKEN
200a880: a0 10 20 00 clr %l0
rc = (*iop->handlers->close_h)( iop );
200a884: 9f c0 40 00 call %g1
200a888: 90 10 00 18 mov %i0, %o0
200a88c: a0 10 00 08 mov %o0, %l0
rtems_filesystem_freenode( &iop->pathinfo );
200a890: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200a894: 80 a0 60 00 cmp %g1, 0
200a898: 02 80 00 08 be 200a8b8 <close+0x8c> <== NEVER TAKEN
200a89c: 01 00 00 00 nop
200a8a0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
200a8a4: 80 a0 60 00 cmp %g1, 0
200a8a8: 02 80 00 04 be 200a8b8 <close+0x8c> <== ALWAYS TAKEN
200a8ac: 01 00 00 00 nop
200a8b0: 9f c0 40 00 call %g1 <== NOT EXECUTED
200a8b4: 90 06 20 10 add %i0, 0x10, %o0 <== NOT EXECUTED
rtems_libio_free( iop );
200a8b8: 40 00 00 fc call 200aca8 <rtems_libio_free>
200a8bc: 90 10 00 18 mov %i0, %o0
return rc;
}
200a8c0: 81 c7 e0 08 ret
200a8c4: 91 e8 00 10 restore %g0, %l0, %o0
rtems_libio_t *iop;
rtems_status_code rc;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
200a8c8: 40 00 09 5f call 200ce44 <__errno> <== NOT EXECUTED
200a8cc: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED
200a8d0: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
200a8d4: 10 bf ff fb b 200a8c0 <close+0x94> <== NOT EXECUTED
200a8d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
0200c488 <device_close>:
*/
int device_close(
rtems_libio_t *iop
)
{
200c488: 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;
200c48c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
args.iop = iop;
200c490: f0 27 bf ec st %i0, [ %fp + -20 ]
args.flags = 0;
200c494: c0 27 bf f0 clr [ %fp + -16 ]
args.mode = 0;
200c498: c0 27 bf f4 clr [ %fp + -12 ]
status = rtems_io_close(
200c49c: d2 00 60 50 ld [ %g1 + 0x50 ], %o1
200c4a0: d0 00 60 4c ld [ %g1 + 0x4c ], %o0
200c4a4: 94 07 bf ec add %fp, -20, %o2
200c4a8: 40 00 01 47 call 200c9c4 <rtems_io_close>
200c4ac: b0 10 20 00 clr %i0
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
200c4b0: 80 a2 20 00 cmp %o0, 0
200c4b4: 12 80 00 04 bne 200c4c4 <device_close+0x3c> <== NEVER TAKEN
200c4b8: 01 00 00 00 nop
return rtems_deviceio_errno(status);
}
return 0;
}
200c4bc: 81 c7 e0 08 ret
200c4c0: 81 e8 00 00 restore
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status ) {
return rtems_deviceio_errno(status);
200c4c4: 7f ff ff a1 call 200c348 <rtems_deviceio_errno> <== NOT EXECUTED
200c4c8: 01 00 00 00 nop <== NOT EXECUTED
}
return 0;
}
200c4cc: 81 c7 e0 08 ret <== NOT EXECUTED
200c4d0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0200c340 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
200c340: 81 c3 e0 08 retl <== NOT EXECUTED
200c344: 90 10 20 00 clr %o0 <== NOT EXECUTED
0200c37c <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
200c37c: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
the_jnode = iop->file_info;
200c380: 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;
200c384: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED
args.buffer = buffer;
200c388: 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;
200c38c: 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(
200c390: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 <== NOT EXECUTED
200c394: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 <== NOT EXECUTED
200c398: 40 00 01 a1 call 200ca1c <rtems_io_control> <== NOT EXECUTED
200c39c: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
200c3a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200c3a4: 12 80 00 05 bne 200c3b8 <device_ioctl+0x3c> <== NOT EXECUTED
200c3a8: 01 00 00 00 nop <== NOT EXECUTED
return rtems_deviceio_errno(status);
return args.ioctl_return;
200c3ac: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
}
200c3b0: 81 c7 e0 08 ret <== NOT EXECUTED
200c3b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
200c3b8: 7f ff ff e4 call 200c348 <rtems_deviceio_errno> <== NOT EXECUTED
200c3bc: 01 00 00 00 nop <== NOT EXECUTED
return args.ioctl_return;
}
200c3c0: 81 c7 e0 08 ret <== NOT EXECUTED
200c3c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0200c338 <device_lseek>:
off_t offset,
int whence
)
{
return offset;
}
200c338: 81 c3 e0 08 retl <== NOT EXECUTED
200c33c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
0200c4d4 <device_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
200c4d4: 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;
200c4d8: 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;
200c4dc: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
args.iop = iop;
200c4e0: f0 27 bf ec st %i0, [ %fp + -20 ]
args.flags = iop->flags;
200c4e4: c2 27 bf f0 st %g1, [ %fp + -16 ]
args.mode = mode;
200c4e8: f6 27 bf f4 st %i3, [ %fp + -12 ]
status = rtems_io_open(
200c4ec: d2 00 a0 50 ld [ %g2 + 0x50 ], %o1
200c4f0: d0 00 a0 4c ld [ %g2 + 0x4c ], %o0
200c4f4: 94 07 bf ec add %fp, -20, %o2
200c4f8: 40 00 01 5f call 200ca74 <rtems_io_open>
200c4fc: b0 10 20 00 clr %i0
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
200c500: 80 a2 20 00 cmp %o0, 0
200c504: 12 80 00 04 bne 200c514 <device_open+0x40> <== NEVER TAKEN
200c508: 01 00 00 00 nop
return rtems_deviceio_errno(status);
return 0;
}
200c50c: 81 c7 e0 08 ret
200c510: 81 e8 00 00 restore
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
200c514: 7f ff ff 8d call 200c348 <rtems_deviceio_errno> <== NOT EXECUTED
200c518: 01 00 00 00 nop <== NOT EXECUTED
return 0;
}
200c51c: 81 c7 e0 08 ret <== NOT EXECUTED
200c520: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0200c428 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
200c428: 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;
200c42c: 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;
200c430: 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;
200c434: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
200c438: 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;
200c43c: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
200c440: f4 27 bf ec st %i2, [ %fp + -20 ] <== NOT EXECUTED
args.flags = iop->flags;
200c444: 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;
200c448: 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;
200c44c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
status = rtems_io_read(
200c450: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 <== NOT EXECUTED
200c454: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 <== NOT EXECUTED
200c458: 40 00 01 9d call 200cacc <rtems_io_read> <== NOT EXECUTED
200c45c: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
200c460: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200c464: 12 80 00 05 bne 200c478 <device_read+0x50> <== NOT EXECUTED
200c468: 01 00 00 00 nop <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
200c46c: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED
}
200c470: 81 c7 e0 08 ret <== NOT EXECUTED
200c474: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
200c478: 7f ff ff b4 call 200c348 <rtems_deviceio_errno> <== NOT EXECUTED
200c47c: 01 00 00 00 nop <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
200c480: 81 c7 e0 08 ret <== NOT EXECUTED
200c484: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0200c3c8 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
200c3c8: 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;
200c3cc: 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;
200c3d0: 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;
200c3d4: c6 06 20 2c ld [ %i0 + 0x2c ], %g3
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
200c3d8: 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;
200c3dc: c2 27 bf e4 st %g1, [ %fp + -28 ]
args.buffer = (void *) buffer;
args.count = count;
200c3e0: f4 27 bf ec st %i2, [ %fp + -20 ]
args.flags = iop->flags;
200c3e4: 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;
200c3e8: 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;
200c3ec: c0 27 bf f4 clr [ %fp + -12 ]
status = rtems_io_write(
200c3f0: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1
200c3f4: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0
200c3f8: 40 00 01 cb call 200cb24 <rtems_io_write>
200c3fc: 94 07 bf e0 add %fp, -32, %o2
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
200c400: 80 a2 20 00 cmp %o0, 0
200c404: 12 80 00 05 bne 200c418 <device_write+0x50> <== NEVER TAKEN
200c408: 01 00 00 00 nop
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
200c40c: d0 07 bf f4 ld [ %fp + -12 ], %o0
}
200c410: 81 c7 e0 08 ret
200c414: 91 e8 00 08 restore %g0, %o0, %o0
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
200c418: 7f ff ff cc call 200c348 <rtems_deviceio_errno> <== NOT EXECUTED
200c41c: 01 00 00 00 nop <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
200c420: 81 c7 e0 08 ret <== NOT EXECUTED
200c424: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02003ebc <drainOutput>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
2003ebc: 9d e3 bf 98 save %sp, -104, %sp
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2003ec0: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
2003ec4: 80 a0 60 00 cmp %g1, 0
2003ec8: 12 80 00 04 bne 2003ed8 <drainOutput+0x1c> <== NEVER TAKEN
2003ecc: 01 00 00 00 nop
2003ed0: 81 c7 e0 08 ret
2003ed4: 81 e8 00 00 restore
rtems_interrupt_disable (level);
2003ed8: 7f ff f7 c3 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
2003edc: 01 00 00 00 nop <== NOT EXECUTED
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
2003ee0: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
2003ee4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2003ee8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2003eec: 02 80 00 14 be 2003f3c <drainOutput+0x80> <== NOT EXECUTED
2003ef0: 01 00 00 00 nop <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
2003ef4: a0 10 20 02 mov 2, %l0 ! 2 <PROM_START+0x2> <== NOT EXECUTED
2003ef8: e0 26 20 94 st %l0, [ %i0 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable (level);
2003efc: 7f ff f7 be call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2003f00: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
2003f04: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
2003f08: 92 10 20 00 clr %o1 <== NOT EXECUTED
2003f0c: 40 00 06 55 call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
2003f10: 94 10 20 00 clr %o2 <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2003f14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003f18: 12 80 00 0b bne 2003f44 <drainOutput+0x88> <== NOT EXECUTED
2003f1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
2003f20: 7f ff f7 b1 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
2003f24: 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) {
2003f28: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED
2003f2c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2003f30: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2003f34: 32 bf ff f2 bne,a 2003efc <drainOutput+0x40> <== NOT EXECUTED
2003f38: 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);
2003f3c: 7f ff f7 ae call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2003f40: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
2003f44: 40 00 08 08 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
02003904 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
2003904: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
2003908: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
200390c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
2003910: 02 80 00 0d be 2003944 <echo+0x40> <== NOT EXECUTED
2003914: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED
2003918: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
200391c: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2016af0 <__ctype_ptr><== NOT EXECUTED
2003920: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED
2003924: c2 08 80 08 ldub [ %g2 + %o0 ], %g1 <== NOT EXECUTED
2003928: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
200392c: 02 80 00 06 be 2003944 <echo+0x40> <== NOT EXECUTED
2003930: 80 a2 20 09 cmp %o0, 9 <== NOT EXECUTED
2003934: 02 80 00 04 be 2003944 <echo+0x40> <== NOT EXECUTED
2003938: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED
200393c: 12 80 00 06 bne 2003954 <echo+0x50> <== NOT EXECUTED
2003940: 82 1e 20 40 xor %i0, 0x40, %g1 <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
}
else {
oproc (c, tty);
2003944: 7f ff ff 8f call 2003780 <oproc> <== NOT EXECUTED
2003948: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200394c: 81 c7 e0 08 ret <== NOT EXECUTED
2003950: 81 e8 00 00 restore <== 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] = '^';
2003954: 84 10 20 5e mov 0x5e, %g2 <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
2003958: 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] = '^';
200395c: c4 2f bf f0 stb %g2, [ %fp + -16 ] <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
2003960: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED
2003964: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2003968: 7f ff ff 38 call 2003648 <rtems_termios_puts> <== NOT EXECUTED
200396c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
tty->column += 2;
2003970: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
2003974: 82 00 60 02 add %g1, 2, %g1 <== NOT EXECUTED
2003978: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
200397c: 81 c7 e0 08 ret <== NOT EXECUTED
2003980: 81 e8 00 00 restore <== NOT EXECUTED
02003984 <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)
{
2003984: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
if (tty->ccount == 0)
2003988: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 <== NOT EXECUTED
200398c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2003990: 02 80 00 80 be 2003b90 <erase+0x20c> <== NOT EXECUTED
2003994: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
return;
if (lineFlag) {
2003998: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
200399c: 12 80 00 28 bne 2003a3c <erase+0xb8> <== NOT EXECUTED
20039a0: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
20039a4: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
20039a8: 05 00 80 56 sethi %hi(0x2015800), %g2 <== NOT EXECUTED
20039ac: a4 10 62 f0 or %g1, 0x2f0, %l2 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
20039b0: a6 10 a0 a8 or %g2, 0xa8, %l3 <== NOT EXECUTED
20039b4: 03 00 80 56 sethi %hi(0x2015800), %g1 <== NOT EXECUTED
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
20039b8: a2 10 60 a0 or %g1, 0xa0, %l1 ! 20158a0 <pollCallbacks.4767+0x390><== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
20039bc: da 04 20 1c ld [ %l0 + 0x1c ], %o5 <== NOT EXECUTED
20039c0: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
20039c4: c6 24 20 20 st %g3, [ %l0 + 0x20 ] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
20039c8: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED
20039cc: 02 80 00 13 be 2003a18 <erase+0x94> <== NOT EXECUTED
20039d0: c2 0b 40 03 ldub [ %o5 + %g3 ], %g1 <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
20039d4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20039d8: 12 80 00 05 bne 20039ec <erase+0x68> <== NOT EXECUTED
20039dc: b0 08 60 ff and %g1, 0xff, %i0 <== NOT EXECUTED
20039e0: 80 89 20 10 btst 0x10, %g4 <== NOT EXECUTED
20039e4: 22 80 00 6d be,a 2003b98 <erase+0x214> <== NOT EXECUTED
20039e8: f0 0c 20 43 ldub [ %l0 + 0x43 ], %i0 <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
}
else if (c == '\t') {
20039ec: 80 a6 20 09 cmp %i0, 9 <== NOT EXECUTED
20039f0: 02 80 00 3f be 2003aec <erase+0x168> <== NOT EXECUTED
20039f4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
20039f8: c2 04 80 00 ld [ %l2 ], %g1 <== NOT EXECUTED
20039fc: c4 08 40 18 ldub [ %g1 + %i0 ], %g2 <== NOT EXECUTED
2003a00: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED
2003a04: 02 80 00 2f be 2003ac0 <erase+0x13c> <== NOT EXECUTED
2003a08: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
2003a0c: 80 89 22 00 btst 0x200, %g4 <== NOT EXECUTED
2003a10: 12 80 00 1a bne 2003a78 <erase+0xf4> <== NOT EXECUTED
2003a14: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
2003a18: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2003a1c: 02 80 00 5d be 2003b90 <erase+0x20c> <== NOT EXECUTED
2003a20: 01 00 00 00 nop <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
2003a24: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED
2003a28: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2003a2c: 02 80 00 59 be 2003b90 <erase+0x20c> <== NOT EXECUTED
2003a30: 01 00 00 00 nop <== NOT EXECUTED
2003a34: 10 bf ff e2 b 20039bc <erase+0x38> <== NOT EXECUTED
2003a38: c8 04 20 3c ld [ %l0 + 0x3c ], %g4 <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
2003a3c: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED
2003a40: 02 80 00 53 be 2003b8c <erase+0x208> <== NOT EXECUTED
2003a44: 80 89 20 10 btst 0x10, %g4 <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
2003a48: 12 bf ff d8 bne 20039a8 <erase+0x24> <== NOT EXECUTED
2003a4c: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
2003a50: 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;
2003a54: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
2003a58: 7f ff ff ab call 2003904 <echo> <== NOT EXECUTED
2003a5c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
2003a60: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
2003a64: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2003a68: 02 80 00 4a be 2003b90 <erase+0x20c> <== NOT EXECUTED
2003a6c: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
echo ('\n', tty);
2003a70: 7f ff ff a5 call 2003904 <echo> <== NOT EXECUTED
2003a74: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
2003a78: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
2003a7c: 7f ff fe f3 call 2003648 <rtems_termios_puts> <== NOT EXECUTED
2003a80: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if (tty->column)
2003a84: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
2003a88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2003a8c: 22 80 00 05 be,a 2003aa0 <erase+0x11c> <== NOT EXECUTED
2003a90: c2 04 80 00 ld [ %l2 ], %g1 <== NOT EXECUTED
tty->column--;
2003a94: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2003a98: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
2003a9c: c2 04 80 00 ld [ %l2 ], %g1 <== NOT EXECUTED
2003aa0: c4 08 40 18 ldub [ %g1 + %i0 ], %g2 <== NOT EXECUTED
2003aa4: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED
2003aa8: 02 80 00 06 be 2003ac0 <erase+0x13c> <== NOT EXECUTED
2003aac: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
2003ab0: c8 04 20 3c ld [ %l0 + 0x3c ], %g4 <== NOT EXECUTED
2003ab4: 80 89 22 00 btst 0x200, %g4 <== NOT EXECUTED
2003ab8: 02 bf ff d9 be 2003a1c <erase+0x98> <== NOT EXECUTED
2003abc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
2003ac0: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
2003ac4: 90 12 20 a8 or %o0, 0xa8, %o0 <== NOT EXECUTED
2003ac8: 7f ff fe e0 call 2003648 <rtems_termios_puts> <== NOT EXECUTED
2003acc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
if (tty->column)
2003ad0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
2003ad4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2003ad8: 02 bf ff d1 be 2003a1c <erase+0x98> <== NOT EXECUTED
2003adc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
tty->column--;
2003ae0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2003ae4: 10 bf ff ce b 2003a1c <erase+0x98> <== NOT EXECUTED
2003ae8: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2003aec: 02 80 00 16 be 2003b44 <erase+0x1c0> <== NOT EXECUTED
2003af0: f0 04 20 2c ld [ %l0 + 0x2c ], %i0 <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
2003af4: d8 04 80 00 ld [ %l2 ], %o4 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
2003af8: 88 09 22 00 and %g4, 0x200, %g4 <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
2003afc: 10 80 00 07 b 2003b18 <erase+0x194> <== NOT EXECUTED
2003b00: 84 10 20 00 clr %g2 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
2003b04: 32 80 00 02 bne,a 2003b0c <erase+0x188> <== NOT EXECUTED
2003b08: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2003b0c: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
2003b10: 22 80 00 0e be,a 2003b48 <erase+0x1c4> <== NOT EXECUTED
2003b14: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
c = tty->cbuf[i++];
2003b18: c2 0b 40 02 ldub [ %o5 + %g2 ], %g1 <== NOT EXECUTED
if (c == '\t') {
2003b1c: 80 a0 60 09 cmp %g1, 9 <== NOT EXECUTED
2003b20: 02 80 00 18 be 2003b80 <erase+0x1fc> <== NOT EXECUTED
2003b24: 84 00 a0 01 inc %g2 <== NOT EXECUTED
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
2003b28: c2 0b 00 01 ldub [ %o4 + %g1 ], %g1 <== NOT EXECUTED
2003b2c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2003b30: 12 bf ff f5 bne 2003b04 <erase+0x180> <== NOT EXECUTED
2003b34: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2003b38: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
2003b3c: 12 bf ff f7 bne 2003b18 <erase+0x194> <== NOT EXECUTED
2003b40: b0 06 20 01 inc %i0 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2003b44: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
2003b48: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
2003b4c: 04 bf ff b4 ble 2003a1c <erase+0x98> <== NOT EXECUTED
2003b50: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
2003b54: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2003b58: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2003b5c: 7f ff fe bb call 2003648 <rtems_termios_puts> <== NOT EXECUTED
2003b60: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
tty->column--;
2003b64: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
2003b68: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2003b6c: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
2003b70: 14 bf ff f9 bg 2003b54 <erase+0x1d0> <== NOT EXECUTED
2003b74: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
2003b78: 10 bf ff a9 b 2003a1c <erase+0x98> <== NOT EXECUTED
2003b7c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
2003b80: 82 16 20 07 or %i0, 7, %g1 <== NOT EXECUTED
2003b84: 10 bf ff e2 b 2003b0c <erase+0x188> <== NOT EXECUTED
2003b88: b0 00 60 01 add %g1, 1, %i0 <== NOT EXECUTED
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
tty->ccount = 0;
2003b8c: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
2003b90: 81 c7 e0 08 ret <== NOT EXECUTED
2003b94: 81 e8 00 00 restore <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
2003b98: 7f ff ff 5b call 2003904 <echo> <== NOT EXECUTED
2003b9c: 93 e8 00 10 restore %g0, %l0, %o1 <== NOT EXECUTED
0200a8f0 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
200a8f0: 9d e3 bf 98 save %sp, -104, %sp
200a8f4: 05 00 80 5c sethi %hi(0x2017000), %g2
200a8f8: 84 10 a2 70 or %g2, 0x270, %g2 ! 2017270 <rtems_malloc_statistics>
200a8fc: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
200a900: b2 10 00 18 mov %i0, %i1
200a904: 82 00 60 01 inc %g1
if ( !ptr )
200a908: 80 a6 20 00 cmp %i0, 0
200a90c: 02 80 00 15 be 200a960 <free+0x70>
200a910: 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()) &&
200a914: 03 00 80 5d sethi %hi(0x2017400), %g1
200a918: c4 00 61 84 ld [ %g1 + 0x184 ], %g2 ! 2017584 <_System_state_Current>
200a91c: 80 a0 a0 03 cmp %g2, 3
200a920: 02 80 00 17 be 200a97c <free+0x8c> <== ALWAYS TAKEN
200a924: 03 00 80 5b sethi %hi(0x2016c00), %g1
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
200a928: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 2016fa4 <rtems_malloc_statistics_helpers>
200a92c: 80 a0 60 00 cmp %g1, 0
200a930: 02 80 00 06 be 200a948 <free+0x58> <== ALWAYS TAKEN
200a934: 37 00 80 5c sethi %hi(0x2017000), %i3
(*rtems_malloc_statistics_helpers->at_free)(ptr);
200a938: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
200a93c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200a940: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) {
200a944: 37 00 80 5c sethi %hi(0x2017000), %i3 <== NOT EXECUTED
200a948: 92 10 00 19 mov %i1, %o1
200a94c: 40 00 05 25 call 200bde0 <_Protected_heap_Free>
200a950: 90 16 e2 18 or %i3, 0x218, %o0
200a954: 80 8a 20 ff btst 0xff, %o0
200a958: 02 80 00 04 be 200a968 <free+0x78> <== NEVER TAKEN
200a95c: 82 16 e2 18 or %i3, 0x218, %g1
200a960: 81 c7 e0 08 ret
200a964: 81 e8 00 00 restore
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
200a968: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED
200a96c: f4 00 60 18 ld [ %g1 + 0x18 ], %i2 <== NOT EXECUTED
200a970: 31 00 80 57 sethi %hi(0x2015c00), %i0 <== NOT EXECUTED
200a974: 7f ff e1 98 call 2002fd4 <printk> <== NOT EXECUTED
200a978: 91 ee 20 20 restore %i0, 0x20, %o0 <== NOT EXECUTED
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
200a97c: 40 00 01 2d call 200ae30 <malloc_is_system_state_OK>
200a980: 01 00 00 00 nop
200a984: 80 8a 20 ff btst 0xff, %o0
200a988: 12 bf ff e8 bne 200a928 <free+0x38> <== ALWAYS TAKEN
200a98c: 03 00 80 5b sethi %hi(0x2016c00), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
200a990: 40 00 01 3b call 200ae7c <malloc_deferred_free> <== NOT EXECUTED
200a994: 81 e8 00 00 restore <== NOT EXECUTED
02014688 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
2014688: 9d e3 bf 98 save %sp, -104, %sp
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
201468c: 92 96 60 00 orcc %i1, 0, %o1
2014690: 02 80 00 3f be 201478c <fstat+0x104> <== NEVER TAKEN
2014694: 03 00 80 59 sethi %hi(0x2016400), %g1
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
2014698: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops>
201469c: 80 a6 00 02 cmp %i0, %g2
20146a0: 1a 80 00 2f bcc 201475c <fstat+0xd4> <== NEVER TAKEN
20146a4: 03 00 80 5c sethi %hi(0x2017000), %g1
20146a8: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops>
20146ac: 85 2e 20 02 sll %i0, 2, %g2
20146b0: 83 2e 20 04 sll %i0, 4, %g1
20146b4: 82 20 40 02 sub %g1, %g2, %g1
20146b8: 82 00 40 18 add %g1, %i0, %g1
20146bc: 83 28 60 02 sll %g1, 2, %g1
20146c0: 86 00 c0 01 add %g3, %g1, %g3
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
20146c4: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
20146c8: 80 88 a1 00 btst 0x100, %g2
20146cc: 02 80 00 24 be 201475c <fstat+0xd4> <== NEVER TAKEN
20146d0: 01 00 00 00 nop
if ( !iop->handlers )
20146d4: c2 00 e0 30 ld [ %g3 + 0x30 ], %g1
20146d8: 80 a0 60 00 cmp %g1, 0
20146dc: 02 80 00 20 be 201475c <fstat+0xd4> <== NEVER TAKEN
20146e0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
20146e4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20146e8: 80 a0 60 00 cmp %g1, 0
20146ec: 02 80 00 22 be 2014774 <fstat+0xec> <== NEVER TAKEN
20146f0: 01 00 00 00 nop
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
20146f4: c0 22 40 00 clr [ %o1 ]
20146f8: c0 22 60 04 clr [ %o1 + 4 ]
20146fc: c0 22 60 08 clr [ %o1 + 8 ]
2014700: c0 22 60 0c clr [ %o1 + 0xc ]
2014704: c0 22 60 10 clr [ %o1 + 0x10 ]
2014708: c0 22 60 14 clr [ %o1 + 0x14 ]
201470c: c0 22 60 18 clr [ %o1 + 0x18 ]
2014710: c0 22 60 1c clr [ %o1 + 0x1c ]
2014714: c0 22 60 20 clr [ %o1 + 0x20 ]
2014718: c0 22 60 24 clr [ %o1 + 0x24 ]
201471c: c0 22 60 28 clr [ %o1 + 0x28 ]
2014720: c0 22 60 2c clr [ %o1 + 0x2c ]
2014724: c0 22 60 30 clr [ %o1 + 0x30 ]
2014728: c0 22 60 34 clr [ %o1 + 0x34 ]
201472c: c0 22 60 38 clr [ %o1 + 0x38 ]
2014730: c0 22 60 3c clr [ %o1 + 0x3c ]
2014734: c0 22 60 40 clr [ %o1 + 0x40 ]
2014738: c0 22 60 44 clr [ %o1 + 0x44 ]
201473c: c0 22 60 48 clr [ %o1 + 0x48 ]
2014740: c0 22 60 4c clr [ %o1 + 0x4c ]
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
2014744: c2 00 e0 30 ld [ %g3 + 0x30 ], %g1
2014748: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
201474c: 9f c0 80 00 call %g2
2014750: 90 00 e0 10 add %g3, 0x10, %o0
}
2014754: 81 c7 e0 08 ret
2014758: 91 e8 00 08 restore %g0, %o0, %o0
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
201475c: 7f ff e1 ba call 200ce44 <__errno> <== NOT EXECUTED
2014760: 01 00 00 00 nop <== NOT EXECUTED
2014764: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
2014768: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201476c: 10 bf ff fa b 2014754 <fstat+0xcc> <== NOT EXECUTED
2014770: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
if ( !iop->handlers->fstat_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2014774: 7f ff e1 b4 call 200ce44 <__errno> <== NOT EXECUTED
2014778: 01 00 00 00 nop <== NOT EXECUTED
201477c: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
2014780: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014784: 10 bf ff f4 b 2014754 <fstat+0xcc> <== NOT EXECUTED
2014788: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
201478c: 7f ff e1 ae call 200ce44 <__errno> <== NOT EXECUTED
2014790: 01 00 00 00 nop <== NOT EXECUTED
2014794: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
2014798: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201479c: 10 bf ff ee b 2014754 <fstat+0xcc> <== NOT EXECUTED
20147a0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
0200a99c <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
200a99c: 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 );
200a9a0: 03 00 80 59 sethi %hi(0x2016400), %g1 <== NOT EXECUTED
200a9a4: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops><== NOT EXECUTED
200a9a8: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED
200a9ac: 1a 80 00 2b bcc 200aa58 <ftruncate+0xbc> <== NOT EXECUTED
200a9b0: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
iop = rtems_libio_iop( fd );
200a9b4: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops><== NOT EXECUTED
200a9b8: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
200a9bc: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
200a9c0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
200a9c4: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
200a9c8: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
200a9cc: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
200a9d0: c4 06 20 0c ld [ %i0 + 0xc ], %g2 <== NOT EXECUTED
200a9d4: 80 88 a1 00 btst 0x100, %g2 <== NOT EXECUTED
200a9d8: 02 80 00 20 be 200aa58 <ftruncate+0xbc> <== NOT EXECUTED
200a9dc: 01 00 00 00 nop <== NOT EXECUTED
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
200a9e0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
200a9e4: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED
200a9e8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
200a9ec: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
200a9f0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED
200a9f4: c2 27 bf f0 st %g1, [ %fp + -16 ] <== NOT EXECUTED
200a9f8: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 <== NOT EXECUTED
if ( !loc.ops->node_type_h )
200a9fc: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200aa00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200aa04: 02 80 00 21 be 200aa88 <ftruncate+0xec> <== NOT EXECUTED
200aa08: c4 27 bf f4 st %g2, [ %fp + -12 ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
200aa0c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200aa10: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
200aa14: 80 a2 20 01 cmp %o0, 1 <== NOT EXECUTED
200aa18: 02 80 00 22 be 200aaa0 <ftruncate+0x104> <== NOT EXECUTED
200aa1c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
200aa20: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200aa24: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
200aa28: 02 80 00 12 be 200aa70 <ftruncate+0xd4> <== NOT EXECUTED
200aa2c: 01 00 00 00 nop <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
200aa30: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
200aa34: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 <== NOT EXECUTED
200aa38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200aa3c: 02 80 00 13 be 200aa88 <ftruncate+0xec> <== NOT EXECUTED
200aa40: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->ftruncate_h)( iop, length );
200aa44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200aa48: 9f c0 40 00 call %g1 <== NOT EXECUTED
200aa4c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
200aa50: 81 c7 e0 08 ret <== NOT EXECUTED
200aa54: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
200aa58: 40 00 08 fb call 200ce44 <__errno> <== NOT EXECUTED
200aa5c: 01 00 00 00 nop <== NOT EXECUTED
200aa60: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
200aa64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200aa68: 10 bf ff fa b 200aa50 <ftruncate+0xb4> <== NOT EXECUTED
200aa6c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
200aa70: 40 00 08 f5 call 200ce44 <__errno> <== NOT EXECUTED
200aa74: 01 00 00 00 nop <== NOT EXECUTED
200aa78: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
200aa7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200aa80: 10 bf ff f4 b 200aa50 <ftruncate+0xb4> <== NOT EXECUTED
200aa84: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
200aa88: 40 00 08 ef call 200ce44 <__errno> <== NOT EXECUTED
200aa8c: 01 00 00 00 nop <== NOT EXECUTED
200aa90: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
200aa94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200aa98: 10 bf ff ee b 200aa50 <ftruncate+0xb4> <== NOT EXECUTED
200aa9c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
loc = iop->pathinfo;
if ( !loc.ops->node_type_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
200aaa0: 40 00 08 e9 call 200ce44 <__errno> <== NOT EXECUTED
200aaa4: 01 00 00 00 nop <== NOT EXECUTED
200aaa8: 82 10 20 15 mov 0x15, %g1 ! 15 <PROM_START+0x15> <== NOT EXECUTED
200aaac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200aab0: 10 bf ff e8 b 200aa50 <ftruncate+0xb4> <== NOT EXECUTED
200aab4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02017f50 <getpid>:
*/
pid_t getpid( void )
{
return _Objects_Local_node;
}
2017f50: 81 c3 e0 08 retl <== NOT EXECUTED
2017f54: 90 10 20 01 mov 1, %o0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
0200aab8 <gettimeofday>:
int gettimeofday(
struct timeval *tp,
void * __tz
)
{
200aab8: 9d e3 bf 90 save %sp, -112, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
200aabc: 80 a6 20 00 cmp %i0, 0
200aac0: 02 80 00 11 be 200ab04 <gettimeofday+0x4c> <== NEVER TAKEN
200aac4: 01 00 00 00 nop
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
200aac8: 7f ff dc c7 call 2001de4 <sparc_disable_interrupts>
200aacc: 01 00 00 00 nop
200aad0: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
200aad4: 7f ff ef 37 call 20067b0 <_TOD_Get>
200aad8: 90 07 bf f0 add %fp, -16, %o0
_ISR_Enable(level);
200aadc: 7f ff dc c6 call 2001df4 <sparc_enable_interrupts>
200aae0: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
200aae4: d0 07 bf f4 ld [ %fp + -12 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
200aae8: c2 07 bf f0 ld [ %fp + -16 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
200aaec: 92 10 23 e8 mov 0x3e8, %o1
200aaf0: 40 00 23 a0 call 2013970 <.udiv>
200aaf4: c2 26 00 00 st %g1, [ %i0 ]
200aaf8: 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;
}
200aafc: 81 c7 e0 08 ret
200ab00: 91 e8 20 00 restore %g0, 0, %o0
void * __tz
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
errno = EFAULT;
200ab04: 40 00 08 d0 call 200ce44 <__errno> <== NOT EXECUTED
200ab08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200ab0c: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
200ab10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200ab14: 81 c7 e0 08 ret <== NOT EXECUTED
200ab18: 81 e8 00 00 restore <== NOT EXECUTED
02003ba4 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
2003ba4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
2003ba8: c6 06 60 30 ld [ %i1 + 0x30 ], %g3 <== NOT EXECUTED
2003bac: 80 88 e0 20 btst 0x20, %g3 <== NOT EXECUTED
2003bb0: 02 80 00 03 be 2003bbc <iproc+0x18> <== NOT EXECUTED
2003bb4: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED
c &= 0x7f;
2003bb8: a0 0e 20 7f and %i0, 0x7f, %l0 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
2003bbc: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED
2003bc0: 02 80 00 0b be 2003bec <iproc+0x48> <== NOT EXECUTED
2003bc4: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
c = tolower (c);
2003bc8: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
2003bcc: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2016af0 <__ctype_ptr><== NOT EXECUTED
2003bd0: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
2003bd4: c2 08 80 08 ldub [ %g2 + %o0 ], %g1 <== NOT EXECUTED
2003bd8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2003bdc: 32 80 00 02 bne,a 2003be4 <iproc+0x40> <== NOT EXECUTED
2003be0: 90 02 20 20 add %o0, 0x20, %o0 <== NOT EXECUTED
2003be4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
if (c == '\r') {
2003be8: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
2003bec: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED
2003bf0: 02 80 00 41 be 2003cf4 <iproc+0x150> <== NOT EXECUTED
2003bf4: 80 a0 60 0a cmp %g1, 0xa <== 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)) {
2003bf8: 02 80 00 14 be 2003c48 <iproc+0xa4> <== NOT EXECUTED
2003bfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
2003c00: 32 80 00 16 bne,a 2003c58 <iproc+0xb4> <== NOT EXECUTED
2003c04: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
2003c08: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED
2003c0c: 05 00 80 5a sethi %hi(0x2016800), %g2 <== NOT EXECUTED
2003c10: c2 00 a2 94 ld [ %g2 + 0x294 ], %g1 ! 2016a94 <rtems_termios_cbufsize><== NOT EXECUTED
2003c14: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
2003c18: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
2003c1c: 16 80 00 09 bge 2003c40 <iproc+0x9c> <== NOT EXECUTED
2003c20: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
2003c24: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
2003c28: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
2003c2c: 12 80 00 3b bne 2003d18 <iproc+0x174> <== NOT EXECUTED
2003c30: 84 00 e0 01 add %g3, 1, %g2 <== NOT EXECUTED
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
2003c34: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
2003c38: e0 28 40 03 stb %l0, [ %g1 + %g3 ] <== NOT EXECUTED
2003c3c: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
2003c40: 81 c7 e0 08 ret <== NOT EXECUTED
2003c44: 81 e8 00 00 restore <== 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)) {
2003c48: 80 88 e0 40 btst 0x40, %g3 <== NOT EXECUTED
2003c4c: 32 80 00 02 bne,a 2003c54 <iproc+0xb0> <== NOT EXECUTED
2003c50: a0 10 20 0d mov 0xd, %l0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
2003c54: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED
2003c58: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED
2003c5c: 22 bf ff ec be,a 2003c0c <iproc+0x68> <== NOT EXECUTED
2003c60: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
2003c64: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1 <== NOT EXECUTED
2003c68: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
2003c6c: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED
2003c70: 22 80 00 34 be,a 2003d40 <iproc+0x19c> <== NOT EXECUTED
2003c74: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
2003c78: c2 0e 60 44 ldub [ %i1 + 0x44 ], %g1 <== NOT EXECUTED
2003c7c: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED
2003c80: 22 80 00 41 be,a 2003d84 <iproc+0x1e0> <== NOT EXECUTED
2003c84: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
2003c88: c2 0e 60 45 ldub [ %i1 + 0x45 ], %g1 <== NOT EXECUTED
2003c8c: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED
2003c90: 02 bf ff ec be 2003c40 <iproc+0x9c> <== NOT EXECUTED
2003c94: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
2003c98: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED
2003c9c: 02 80 00 2e be 2003d54 <iproc+0x1b0> <== NOT EXECUTED
2003ca0: 80 88 a0 48 btst 0x48, %g2 <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL))
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
return 1;
}
else if ((c == tty->termios.c_cc[VEOL])
2003ca4: c2 0e 60 4c ldub [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2003ca8: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED
2003cac: 02 80 00 07 be 2003cc8 <iproc+0x124> <== NOT EXECUTED
2003cb0: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED
2003cb4: c2 0e 60 51 ldub [ %i1 + 0x51 ], %g1 <== NOT EXECUTED
2003cb8: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED
2003cbc: 32 bf ff d4 bne,a 2003c0c <iproc+0x68> <== NOT EXECUTED
2003cc0: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
2003cc4: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED
2003cc8: 22 80 00 05 be,a 2003cdc <iproc+0x138> <== NOT EXECUTED
2003ccc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
2003cd0: 7f ff ff 0d call 2003904 <echo> <== NOT EXECUTED
2003cd4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
2003cd8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2003cdc: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
2003ce0: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED
2003ce4: e0 28 80 01 stb %l0, [ %g2 + %g1 ] <== NOT EXECUTED
2003ce8: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED
2003cec: 81 c7 e0 08 ret <== NOT EXECUTED
2003cf0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
2003cf4: 80 88 e0 80 btst 0x80, %g3 <== NOT EXECUTED
2003cf8: 02 80 00 04 be 2003d08 <iproc+0x164> <== NOT EXECUTED
2003cfc: 80 88 e1 00 btst 0x100, %g3 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
2003d00: 81 c7 e0 08 ret <== NOT EXECUTED
2003d04: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
2003d08: 32 bf ff d3 bne,a 2003c54 <iproc+0xb0> <== NOT EXECUTED
2003d0c: 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)) {
2003d10: 10 bf ff d2 b 2003c58 <iproc+0xb4> <== NOT EXECUTED
2003d14: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
2003d18: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED
2003d1c: 7f ff fe fa call 2003904 <echo> <== NOT EXECUTED
2003d20: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003d24: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
2003d28: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
2003d2c: 84 00 e0 01 add %g3, 1, %g2 <== NOT EXECUTED
2003d30: e0 28 40 03 stb %l0, [ %g1 + %g3 ] <== NOT EXECUTED
2003d34: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
2003d38: 81 c7 e0 08 ret <== NOT EXECUTED
2003d3c: 91 e8 20 00 restore %g0, 0, %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]) {
erase (tty, 0);
2003d40: 92 10 20 00 clr %o1 <== NOT EXECUTED
2003d44: 7f ff ff 10 call 2003984 <erase> <== NOT EXECUTED
2003d48: b0 10 20 00 clr %i0 <== NOT EXECUTED
2003d4c: 81 c7 e0 08 ret <== NOT EXECUTED
2003d50: 81 e8 00 00 restore <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
}
else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
2003d54: 22 80 00 05 be,a 2003d68 <iproc+0x1c4> <== NOT EXECUTED
2003d58: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
2003d5c: 7f ff fe ea call 2003904 <echo> <== NOT EXECUTED
2003d60: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
2003d64: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2003d68: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 <== NOT EXECUTED
2003d6c: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
2003d70: c4 28 c0 01 stb %g2, [ %g3 + %g1 ] <== NOT EXECUTED
2003d74: 82 00 60 01 inc %g1 <== NOT EXECUTED
2003d78: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
2003d7c: 81 c7 e0 08 ret <== NOT EXECUTED
2003d80: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
2003d84: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2003d88: 7f ff fe ff call 2003984 <erase> <== NOT EXECUTED
2003d8c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2003d90: 81 c7 e0 08 ret <== NOT EXECUTED
2003d94: 81 e8 00 00 restore <== NOT EXECUTED
020147bc <isatty>:
#include <sys/stat.h>
int isatty(
int fd
)
{
20147bc: 9d e3 bf 48 save %sp, -184, %sp
struct stat buf;
if (fstat (fd, &buf) < 0)
20147c0: 90 10 00 18 mov %i0, %o0
20147c4: 92 07 bf a8 add %fp, -88, %o1
20147c8: 7f ff ff b0 call 2014688 <fstat>
20147cc: b0 10 20 00 clr %i0
20147d0: 80 a2 20 00 cmp %o0, 0
20147d4: 06 80 00 08 bl 20147f4 <isatty+0x38> <== NEVER TAKEN
20147d8: c2 17 bf b4 lduh [ %fp + -76 ], %g1
20147dc: 05 00 00 3c sethi %hi(0xf000), %g2
20147e0: 07 00 00 08 sethi %hi(0x2000), %g3
20147e4: 82 08 40 02 and %g1, %g2, %g1
20147e8: 82 18 40 03 xor %g1, %g3, %g1
20147ec: 80 a0 00 01 cmp %g0, %g1
20147f0: b0 60 3f ff subx %g0, -1, %i0
if (S_ISCHR (buf.st_mode))
return 1;
return 0;
}
20147f4: 81 c7 e0 08 ret
20147f8: 81 e8 00 00 restore
020180d8 <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
20180d8: 81 c3 e0 08 retl <== NOT EXECUTED
20180dc: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
02002608 <libc_create_hook>:
*/
bool libc_create_hook(
rtems_tcb *current_task,
rtems_tcb *creating_task
)
{
2002608: 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));
200260c: 90 10 24 00 mov 0x400, %o0
2002610: 40 00 1a e3 call 200919c <_Workspace_Allocate>
2002614: b0 10 20 00 clr %i0
#endif
if (ptr) {
2002618: a0 92 20 00 orcc %o0, 0, %l0
200261c: 02 80 00 63 be 20027a8 <libc_create_hook+0x1a0> <== NEVER TAKEN
2002620: 90 04 22 ec add %l0, 0x2ec, %o0
_REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */
2002624: c0 24 00 00 clr [ %l0 ]
2002628: c0 24 20 10 clr [ %l0 + 0x10 ]
200262c: c0 24 20 14 clr [ %l0 + 0x14 ]
2002630: 82 04 23 48 add %l0, 0x348, %g1
2002634: d0 24 20 04 st %o0, [ %l0 + 4 ]
2002638: c2 24 20 08 st %g1, [ %l0 + 8 ]
200263c: 84 04 23 a4 add %l0, 0x3a4, %g2
2002640: c4 24 20 0c st %g2, [ %l0 + 0xc ]
2002644: 82 04 20 14 add %l0, 0x14, %g1
2002648: c0 28 60 18 clrb [ %g1 + 0x18 ]
200264c: c0 20 60 04 clr [ %g1 + 4 ]
2002650: c0 20 60 08 clr [ %g1 + 8 ]
2002654: c0 20 60 0c clr [ %g1 + 0xc ]
2002658: c0 20 60 10 clr [ %g1 + 0x10 ]
200265c: c0 20 60 14 clr [ %g1 + 0x14 ]
2002660: c0 24 20 30 clr [ %l0 + 0x30 ]
2002664: c0 24 20 38 clr [ %l0 + 0x38 ]
2002668: c0 24 20 3c clr [ %l0 + 0x3c ]
200266c: c0 24 20 40 clr [ %l0 + 0x40 ]
2002670: c0 24 20 44 clr [ %l0 + 0x44 ]
2002674: c0 24 20 48 clr [ %l0 + 0x48 ]
2002678: c0 24 20 4c clr [ %l0 + 0x4c ]
200267c: c0 24 20 50 clr [ %l0 + 0x50 ]
2002680: c0 24 20 54 clr [ %l0 + 0x54 ]
2002684: c0 24 20 58 clr [ %l0 + 0x58 ]
2002688: c0 24 20 5c clr [ %l0 + 0x5c ]
200268c: c0 2c 20 60 clrb [ %l0 + 0x60 ]
2002690: c0 24 20 7c clr [ %l0 + 0x7c ]
2002694: 03 00 80 56 sethi %hi(0x2015800), %g1
2002698: 82 10 60 68 or %g1, 0x68, %g1 ! 2015868 <pollCallbacks.4767+0x358>
200269c: c2 24 20 34 st %g1, [ %l0 + 0x34 ]
20026a0: 84 04 20 7c add %l0, 0x7c, %g2
20026a4: c0 20 a0 04 clr [ %g2 + 4 ]
20026a8: c0 20 a0 08 clr [ %g2 + 8 ]
20026ac: c0 20 a0 0c clr [ %g2 + 0xc ]
20026b0: c0 20 a0 10 clr [ %g2 + 0x10 ]
20026b4: c0 20 a0 14 clr [ %g2 + 0x14 ]
20026b8: c0 20 a0 18 clr [ %g2 + 0x18 ]
20026bc: c0 20 a0 1c clr [ %g2 + 0x1c ]
20026c0: c0 20 a0 20 clr [ %g2 + 0x20 ]
20026c4: 03 00 00 0c sethi %hi(0x3000), %g1
20026c8: 84 10 20 00 clr %g2
20026cc: 82 10 63 0e or %g1, 0x30e, %g1
20026d0: 86 10 20 01 mov 1, %g3
20026d4: c2 34 20 b0 sth %g1, [ %l0 + 0xb0 ]
20026d8: c4 3c 20 a8 std %g2, [ %l0 + 0xa8 ]
20026dc: 03 00 00 04 sethi %hi(0x1000), %g1
20026e0: 05 3f ff ea sethi %hi(0xffffa800), %g2
20026e4: 82 10 62 34 or %g1, 0x234, %g1
20026e8: 84 10 a3 cd or %g2, 0x3cd, %g2
20026ec: c2 34 20 b4 sth %g1, [ %l0 + 0xb4 ]
20026f0: c4 34 20 b2 sth %g2, [ %l0 + 0xb2 ]
20026f4: 03 3f ff f7 sethi %hi(0xffffdc00), %g1
20026f8: 05 3f ff f9 sethi %hi(0xffffe400), %g2
20026fc: 82 10 62 ec or %g1, 0x2ec, %g1
2002700: 84 10 a2 6d or %g2, 0x26d, %g2
2002704: c2 34 20 b8 sth %g1, [ %l0 + 0xb8 ]
2002708: c4 34 20 b6 sth %g2, [ %l0 + 0xb6 ]
200270c: 82 10 20 0b mov 0xb, %g1
2002710: 84 10 20 05 mov 5, %g2
2002714: c2 34 20 bc sth %g1, [ %l0 + 0xbc ]
2002718: c4 34 20 ba sth %g2, [ %l0 + 0xba ]
200271c: c0 24 20 a0 clr [ %l0 + 0xa0 ]
2002720: c0 24 20 c0 clr [ %l0 + 0xc0 ]
2002724: c0 24 20 c4 clr [ %l0 + 0xc4 ]
2002728: c0 24 20 c8 clr [ %l0 + 0xc8 ]
200272c: c0 24 20 cc clr [ %l0 + 0xcc ]
2002730: c0 24 20 d0 clr [ %l0 + 0xd0 ]
2002734: c0 24 20 d4 clr [ %l0 + 0xd4 ]
2002738: c0 24 20 fc clr [ %l0 + 0xfc ]
200273c: c0 24 21 00 clr [ %l0 + 0x100 ]
2002740: c0 24 21 04 clr [ %l0 + 0x104 ]
2002744: c0 24 21 08 clr [ %l0 + 0x108 ]
2002748: c0 24 21 0c clr [ %l0 + 0x10c ]
200274c: c0 24 21 10 clr [ %l0 + 0x110 ]
2002750: c0 24 21 14 clr [ %l0 + 0x114 ]
2002754: c0 24 21 18 clr [ %l0 + 0x118 ]
2002758: c0 24 21 1c clr [ %l0 + 0x11c ]
200275c: c0 24 21 20 clr [ %l0 + 0x120 ]
2002760: c0 2c 20 d8 clrb [ %l0 + 0xd8 ]
2002764: c0 2c 20 e0 clrb [ %l0 + 0xe0 ]
2002768: c0 24 20 f8 clr [ %l0 + 0xf8 ]
200276c: c0 24 21 48 clr [ %l0 + 0x148 ]
2002770: c0 24 21 4c clr [ %l0 + 0x14c ]
2002774: c0 24 21 50 clr [ %l0 + 0x150 ]
2002778: c0 24 21 54 clr [ %l0 + 0x154 ]
200277c: c0 24 22 d4 clr [ %l0 + 0x2d4 ]
2002780: c0 24 21 d4 clr [ %l0 + 0x1d4 ]
2002784: 92 10 20 00 clr %o1
2002788: c0 24 22 dc clr [ %l0 + 0x2dc ]
200278c: c0 24 22 e0 clr [ %l0 + 0x2e0 ]
2002790: c0 24 22 e4 clr [ %l0 + 0x2e4 ]
2002794: c0 24 22 e8 clr [ %l0 + 0x2e8 ]
2002798: 94 10 21 14 mov 0x114, %o2
200279c: 40 00 2b d5 call 200d6f0 <memset>
20027a0: b0 10 20 01 mov 1, %i0
creating_task->libc_reent = ptr;
20027a4: e0 26 61 64 st %l0, [ %i1 + 0x164 ]
return true;
}
else
return false;
}
20027a8: 81 c7 e0 08 ret
20027ac: 81 e8 00 00 restore
02002548 <libc_delete_hook>:
rtems_extension libc_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
2002548: 9d e3 bf 98 save %sp, -104, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
200254c: 80 a6 00 19 cmp %i0, %i1
2002550: 02 80 00 16 be 20025a8 <libc_delete_hook+0x60>
2002554: 03 00 80 5a sethi %hi(0x2016800), %g1
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
2002558: e0 06 61 64 ld [ %i1 + 0x164 ], %l0
}
if (ptr && ptr != &libc_global_reent) {
200255c: 80 a4 20 00 cmp %l0, 0
2002560: 02 80 00 0b be 200258c <libc_delete_hook+0x44> <== NEVER TAKEN
2002564: 03 00 80 59 sethi %hi(0x2016400), %g1
2002568: 82 10 62 90 or %g1, 0x290, %g1 ! 2016690 <libc_global_reent>
200256c: 80 a4 00 01 cmp %l0, %g1
2002570: 02 80 00 07 be 200258c <libc_delete_hook+0x44>
2002574: 13 00 80 09 sethi %hi(0x2002400), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
2002578: 90 10 00 10 mov %l0, %o0
200257c: 40 00 2b fe call 200d574 <_fwalk>
2002580: 92 12 61 b0 or %o1, 0x1b0, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
2002584: 40 00 1a ff call 2009180 <_Workspace_Free>
2002588: 90 10 00 10 mov %l0, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
200258c: 80 a6 00 19 cmp %i0, %i1
2002590: 12 80 00 04 bne 20025a0 <libc_delete_hook+0x58>
2002594: c0 26 61 64 clr [ %i1 + 0x164 ]
_REENT = 0;
2002598: 03 00 80 5a sethi %hi(0x2016800), %g1
200259c: c0 20 62 f8 clr [ %g1 + 0x2f8 ] ! 2016af8 <_impure_ptr>
20025a0: 81 c7 e0 08 ret
20025a4: 81 e8 00 00 restore
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
20025a8: 10 bf ff ed b 200255c <libc_delete_hook+0x14>
20025ac: e0 00 62 f8 ld [ %g1 + 0x2f8 ], %l0
02014934 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
2014934: 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()))
2014938: 03 00 80 5d sethi %hi(0x2017400), %g1
201493c: c4 00 61 84 ld [ %g1 + 0x184 ], %g2 ! 2017584 <_System_state_Current>
2014940: 80 a0 a0 03 cmp %g2, 3
2014944: 02 80 00 04 be 2014954 <libc_wrapup+0x20> <== ALWAYS TAKEN
2014948: 21 00 80 5a sethi %hi(0x2016800), %l0
201494c: 81 c7 e0 08 ret <== NOT EXECUTED
2014950: 81 e8 00 00 restore <== NOT EXECUTED
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != &libc_global_reent) {
2014954: c4 04 22 f8 ld [ %l0 + 0x2f8 ], %g2
2014958: 03 00 80 59 sethi %hi(0x2016400), %g1
201495c: b0 10 62 90 or %g1, 0x290, %i0 ! 2016690 <libc_global_reent>
2014960: 80 a0 80 18 cmp %g2, %i0
2014964: 02 80 00 06 be 201497c <libc_wrapup+0x48>
2014968: c2 04 22 f8 ld [ %l0 + 0x2f8 ], %g1
_wrapup_reent(&libc_global_reent);
201496c: 40 00 01 ce call 20150a4 <_wrapup_reent>
2014970: 90 10 00 18 mov %i0, %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;
2014974: f0 24 22 f8 st %i0, [ %l0 + 0x2f8 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
2014978: c2 04 22 f8 ld [ %l0 + 0x2f8 ], %g1
201497c: 7f ff e1 8a call 200cfa4 <fclose>
2014980: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
2014984: c2 04 22 f8 ld [ %l0 + 0x2f8 ], %g1
2014988: 7f ff e1 87 call 200cfa4 <fclose>
201498c: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
2014990: c2 04 22 f8 ld [ %l0 + 0x2f8 ], %g1
2014994: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2014998: 7f ff e1 83 call 200cfa4 <fclose>
201499c: 81 e8 00 00 restore
020147fc <lseek>:
off_t lseek(
int fd,
off_t offset,
int whence
)
{
20147fc: 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 );
2014800: 03 00 80 59 sethi %hi(0x2016400), %g1 <== NOT EXECUTED
2014804: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops><== NOT EXECUTED
off_t lseek(
int fd,
off_t offset,
int whence
)
{
2014808: 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 );
201480c: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED
2014810: 1a 80 00 31 bcc 20148d4 <lseek+0xd8> <== NOT EXECUTED
2014814: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
iop = rtems_libio_iop( fd );
2014818: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
201481c: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops><== NOT EXECUTED
2014820: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
2014824: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
2014828: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
201482c: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
2014830: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
2014834: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
2014838: c4 06 20 0c ld [ %i0 + 0xc ], %g2 <== NOT EXECUTED
201483c: 80 88 a1 00 btst 0x100, %g2 <== NOT EXECUTED
2014840: 02 80 00 25 be 20148d4 <lseek+0xd8> <== NOT EXECUTED
2014844: 01 00 00 00 nop <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
2014848: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED
201484c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED
2014850: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2014854: 02 80 00 26 be 20148ec <lseek+0xf0> <== NOT EXECUTED
2014858: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
201485c: 02 80 00 1b be 20148c8 <lseek+0xcc> <== NOT EXECUTED
2014860: f4 06 20 08 ld [ %i0 + 8 ], %i2 <== NOT EXECUTED
2014864: 80 a2 a0 02 cmp %o2, 2 <== NOT EXECUTED
2014868: 02 80 00 0d be 201489c <lseek+0xa0> <== NOT EXECUTED
201486c: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED
2014870: 12 80 00 0f bne 20148ac <lseek+0xb0> <== NOT EXECUTED
2014874: 01 00 00 00 nop <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
2014878: f2 26 20 08 st %i1, [ %i0 + 8 ] <== NOT EXECUTED
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
201487c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED
2014880: 9f c0 40 00 call %g1 <== NOT EXECUTED
2014884: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( status == (off_t) -1 )
2014888: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
201488c: 22 80 00 02 be,a 2014894 <lseek+0x98> <== NOT EXECUTED
2014890: f4 26 20 08 st %i2, [ %i0 + 8 ] <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
2014894: 81 c7 e0 08 ret <== NOT EXECUTED
2014898: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
201489c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
20148a0: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
20148a4: 10 bf ff f6 b 201487c <lseek+0x80> <== NOT EXECUTED
20148a8: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
20148ac: 7f ff e1 66 call 200ce44 <__errno> <== NOT EXECUTED
20148b0: 01 00 00 00 nop <== NOT EXECUTED
20148b4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
20148b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20148bc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
20148c0: 81 c7 e0 08 ret <== NOT EXECUTED
20148c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
20148c8: 82 06 40 1a add %i1, %i2, %g1 <== NOT EXECUTED
20148cc: 10 bf ff ec b 201487c <lseek+0x80> <== NOT EXECUTED
20148d0: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
20148d4: 7f ff e1 5c call 200ce44 <__errno> <== NOT EXECUTED
20148d8: 01 00 00 00 nop <== NOT EXECUTED
20148dc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
20148e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20148e4: 10 bf ff ec b 2014894 <lseek+0x98> <== NOT EXECUTED
20148e8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
20148ec: 7f ff e1 56 call 200ce44 <__errno> <== NOT EXECUTED
20148f0: 01 00 00 00 nop <== NOT EXECUTED
20148f4: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
20148f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20148fc: 10 bf ff e6 b 2014894 <lseek+0x98> <== NOT EXECUTED
2014900: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
0200aecc <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
200aecc: 9d e3 bf 98 save %sp, -104, %sp
200aed0: 05 00 80 5c sethi %hi(0x2017000), %g2
200aed4: 84 10 a2 70 or %g2, 0x270, %g2 ! 2017270 <rtems_malloc_statistics>
200aed8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200aedc: a2 10 00 18 mov %i0, %l1
200aee0: 82 00 60 01 inc %g1
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
200aee4: 7f ff ff ed call 200ae98 <malloc_deferred_frees_process>
200aee8: c2 20 a0 04 st %g1, [ %g2 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
200aeec: 80 a6 20 00 cmp %i0, 0
200aef0: 02 80 00 23 be 200af7c <malloc+0xb0> <== NEVER TAKEN
200aef4: 03 00 80 5d sethi %hi(0x2017400), %g1
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
200aef8: c4 00 61 84 ld [ %g1 + 0x184 ], %g2 ! 2017584 <_System_state_Current>
200aefc: 80 a0 a0 03 cmp %g2, 3
200af00: 02 80 00 1a be 200af68 <malloc+0x9c>
200af04: 11 00 80 5c sethi %hi(0x2017000), %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 );
200af08: 92 10 00 11 mov %l1, %o1
200af0c: 40 00 03 a9 call 200bdb0 <_Protected_heap_Allocate>
200af10: 90 12 22 18 or %o0, 0x218, %o0
if ( !return_this ) {
200af14: b0 92 20 00 orcc %o0, 0, %i0
200af18: 02 80 00 1b be 200af84 <malloc+0xb8> <== NEVER TAKEN
200af1c: a0 10 00 18 mov %i0, %l0
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
200af20: 03 00 80 5b sethi %hi(0x2016c00), %g1
200af24: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 2016fac <rtems_malloc_dirty_helper>
200af28: 80 a0 60 00 cmp %g1, 0
200af2c: 02 80 00 04 be 200af3c <malloc+0x70> <== ALWAYS TAKEN
200af30: 92 10 00 11 mov %l1, %o1
(*rtems_malloc_dirty_helper)( return_this, size );
200af34: 9f c0 40 00 call %g1 <== NOT EXECUTED
200af38: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
200af3c: 03 00 80 5b sethi %hi(0x2016c00), %g1
200af40: c2 00 63 a4 ld [ %g1 + 0x3a4 ], %g1 ! 2016fa4 <rtems_malloc_statistics_helpers>
200af44: 80 a0 60 00 cmp %g1, 0
200af48: 02 80 00 06 be 200af60 <malloc+0x94> <== ALWAYS TAKEN
200af4c: b0 10 00 10 mov %l0, %i0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
200af50: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
200af54: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
200af58: 9f c0 40 00 call %g1 <== NOT EXECUTED
200af5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
200af60: 81 c7 e0 08 ret
200af64: 81 e8 00 00 restore
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
200af68: 7f ff ff b2 call 200ae30 <malloc_is_system_state_OK>
200af6c: 01 00 00 00 nop
200af70: 80 8a 20 ff btst 0xff, %o0
200af74: 12 bf ff e5 bne 200af08 <malloc+0x3c> <== ALWAYS TAKEN
200af78: 11 00 80 5c sethi %hi(0x2017000), %o0
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
200af7c: 81 c7 e0 08 ret <== NOT EXECUTED
200af80: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
200af84: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED
200af88: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 2016fa8 <rtems_malloc_sbrk_helpers><== NOT EXECUTED
200af8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200af90: 02 80 00 08 be 200afb0 <malloc+0xe4> <== NOT EXECUTED
200af94: 01 00 00 00 nop <== NOT EXECUTED
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
200af98: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
200af9c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200afa0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if ( !return_this ) {
200afa4: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED
200afa8: 12 bf ff df bne 200af24 <malloc+0x58> <== NOT EXECUTED
200afac: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED
errno = ENOMEM;
200afb0: 40 00 07 a5 call 200ce44 <__errno> <== NOT EXECUTED
200afb4: 01 00 00 00 nop <== NOT EXECUTED
200afb8: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200afbc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200afc0: 81 c7 e0 08 ret <== NOT EXECUTED
200afc4: 81 e8 00 00 restore <== NOT EXECUTED
0200ae7c <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
200ae7c: 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 );
200ae80: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED
200ae84: 90 12 22 9c or %o0, 0x29c, %o0 ! 201769c <RTEMS_Malloc_GC_list><== NOT EXECUTED
200ae88: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
200ae8c: 7f ff ed 26 call 2006324 <_Chain_Append> <== NOT EXECUTED
200ae90: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0200ae98 <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
200ae98: 9d e3 bf 98 save %sp, -104, %sp
200ae9c: 03 00 80 5d sethi %hi(0x2017400), %g1
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
200aea0: 10 80 00 04 b 200aeb0 <malloc_deferred_frees_process+0x18>
200aea4: a0 10 62 9c or %g1, 0x29c, %l0 ! 201769c <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);
200aea8: 7f ff fe 92 call 200a8f0 <free> <== NOT EXECUTED
200aeac: 01 00 00 00 nop <== NOT EXECUTED
200aeb0: 40 00 02 52 call 200b7f8 <_Chain_Get>
200aeb4: 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)
200aeb8: 80 a2 20 00 cmp %o0, 0
200aebc: 12 bf ff fb bne 200aea8 <malloc_deferred_frees_process+0x10><== NEVER TAKEN
200aec0: 01 00 00 00 nop
free(to_be_freed);
}
200aec4: 81 c7 e0 08 ret
200aec8: 81 e8 00 00 restore
0200ae30 <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 )
200ae30: 03 00 80 5c sethi %hi(0x2017000), %g1
200ae34: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20173e0 <_Thread_Dispatch_disable_level>
200ae38: 80 a0 a0 00 cmp %g2, 0
200ae3c: 12 80 00 07 bne 200ae58 <malloc_is_system_state_OK+0x28> <== NEVER TAKEN
200ae40: 90 10 20 00 clr %o0
return false;
if ( _ISR_Nest_level > 0 )
200ae44: 03 00 80 5d sethi %hi(0x2017400), %g1
200ae48: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2017480 <_ISR_Nest_level>
200ae4c: 80 a0 00 02 cmp %g0, %g2
200ae50: 82 60 3f ff subx %g0, -1, %g1
200ae54: 90 10 00 01 mov %g1, %o0
return false;
return true;
}
200ae58: 81 c3 e0 08 retl
02002364 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
2002364: 9d e3 bf 80 save %sp, -128, %sp
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT) {
2002368: 03 00 00 3c sethi %hi(0xf000), %g1
200236c: b3 2e 60 10 sll %i1, 0x10, %i1
2002370: b3 36 60 10 srl %i1, 0x10, %i1
2002374: 84 0e 40 01 and %i1, %g1, %g2
2002378: 03 00 00 10 sethi %hi(0x4000), %g1
200237c: 80 a0 80 01 cmp %g2, %g1
2002380: 02 80 00 17 be 20023dc <mknod+0x78>
2002384: 03 00 00 04 sethi %hi(0x1000), %g1
2002388: 04 80 00 0f ble 20023c4 <mknod+0x60> <== ALWAYS TAKEN
200238c: 80 a0 80 01 cmp %g2, %g1
2002390: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
2002394: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2002398: 02 80 00 10 be 20023d8 <mknod+0x74> <== NOT EXECUTED
200239c: 03 00 00 20 sethi %hi(0x8000), %g1 <== NOT EXECUTED
20023a0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20023a4: 02 80 00 0e be 20023dc <mknod+0x78> <== NOT EXECUTED
20023a8: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
20023ac: 40 00 2a a6 call 200ce44 <__errno> <== NOT EXECUTED
20023b0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20023b4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20023b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20023bc: 81 c7 e0 08 ret <== NOT EXECUTED
20023c0: 81 e8 00 00 restore <== NOT EXECUTED
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT) {
20023c4: 02 80 00 05 be 20023d8 <mknod+0x74> <== NEVER TAKEN
20023c8: 03 00 00 08 sethi %hi(0x2000), %g1
20023cc: 80 a0 80 01 cmp %g2, %g1
20023d0: 12 bf ff f7 bne 20023ac <mknod+0x48> <== NEVER TAKEN
20023d4: 01 00 00 00 nop
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( S_ISFIFO(mode) )
20023d8: 03 00 00 04 sethi %hi(0x1000), %g1
20023dc: 80 a0 80 01 cmp %g2, %g1
20023e0: 02 80 00 18 be 2002440 <mknod+0xdc> <== NEVER TAKEN
20023e4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
20023e8: c2 4e 00 00 ldsb [ %i0 ], %g1
20023ec: 80 a0 60 2f cmp %g1, 0x2f
20023f0: 02 80 00 1a be 2002458 <mknod+0xf4> <== ALWAYS TAKEN
20023f4: 80 a0 60 5c cmp %g1, 0x5c
20023f8: 02 80 00 18 be 2002458 <mknod+0xf4> <== NOT EXECUTED
20023fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002400: 02 80 00 17 be 200245c <mknod+0xf8> <== NOT EXECUTED
2002404: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
2002408: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 ! 2016aa4 <rtems_current_user_env><== NOT EXECUTED
200240c: 88 10 20 00 clr %g4 <== NOT EXECUTED
2002410: c2 00 e0 04 ld [ %g3 + 4 ], %g1 <== NOT EXECUTED
2002414: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED
2002418: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED
200241c: c4 27 bf e8 st %g2, [ %fp + -24 ] <== NOT EXECUTED
2002420: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 <== NOT EXECUTED
2002424: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED
if ( !temp_loc.ops->evalformake_h ) {
2002428: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED
}
if ( S_ISFIFO(mode) )
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
200242c: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 <== NOT EXECUTED
if ( !temp_loc.ops->evalformake_h ) {
2002430: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
2002434: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002438: 12 80 00 17 bne 2002494 <mknod+0x130> <== NOT EXECUTED
200243c: c4 27 bf f0 st %g2, [ %fp + -16 ] <== NOT EXECUTED
if ( result != 0 )
return -1;
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
2002440: 40 00 2a 81 call 200ce44 <__errno> <== NOT EXECUTED
2002444: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2002448: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
200244c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2002450: 81 c7 e0 08 ret <== NOT EXECUTED
2002454: 81 e8 00 00 restore <== NOT EXECUTED
}
if ( S_ISFIFO(mode) )
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
2002458: 03 00 80 5a sethi %hi(0x2016800), %g1
200245c: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 ! 2016aa4 <rtems_current_user_env>
2002460: 88 10 20 01 mov 1, %g4
2002464: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1
2002468: c2 27 bf e4 st %g1, [ %fp + -28 ]
200246c: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2
2002470: c4 27 bf e8 st %g2, [ %fp + -24 ]
2002474: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
2002478: c2 27 bf ec st %g1, [ %fp + -20 ]
if ( !temp_loc.ops->evalformake_h ) {
200247c: c2 07 bf ec ld [ %fp + -20 ], %g1
}
if ( S_ISFIFO(mode) )
rtems_set_errno_and_return_minus_one( ENOTSUP );
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
2002480: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2
if ( !temp_loc.ops->evalformake_h ) {
2002484: c2 00 60 04 ld [ %g1 + 4 ], %g1
2002488: 80 a0 60 00 cmp %g1, 0
200248c: 02 bf ff ed be 2002440 <mknod+0xdc> <== NEVER TAKEN
2002490: c4 27 bf f0 st %g2, [ %fp + -16 ]
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
2002494: 90 06 00 04 add %i0, %g4, %o0
2002498: a0 07 bf e4 add %fp, -28, %l0
200249c: 94 07 bf f4 add %fp, -12, %o2
20024a0: 92 10 00 10 mov %l0, %o1
20024a4: 9f c0 40 00 call %g1
20024a8: b0 10 3f ff mov -1, %i0
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
20024ac: 80 a2 20 00 cmp %o0, 0
20024b0: 12 bf ff c3 bne 20023bc <mknod+0x58> <== NEVER TAKEN
20024b4: c2 07 bf ec ld [ %fp + -20 ], %g1
return -1;
if ( !temp_loc.ops->mknod_h ) {
20024b8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
20024bc: 80 a0 a0 00 cmp %g2, 0
20024c0: 02 80 00 13 be 200250c <mknod+0x1a8> <== NEVER TAKEN
20024c4: d0 07 bf f4 ld [ %fp + -12 ], %o0
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
20024c8: 92 10 00 19 mov %i1, %o1
20024cc: 94 10 00 1a mov %i2, %o2
20024d0: 96 10 00 1b mov %i3, %o3
20024d4: 9f c0 80 00 call %g2
20024d8: 98 10 00 10 mov %l0, %o4
rtems_filesystem_freenode( &temp_loc );
20024dc: c2 07 bf ec ld [ %fp + -20 ], %g1
20024e0: 80 a0 60 00 cmp %g1, 0
20024e4: 02 bf ff b6 be 20023bc <mknod+0x58> <== NEVER TAKEN
20024e8: b0 10 00 08 mov %o0, %i0
20024ec: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20024f0: 80 a0 60 00 cmp %g1, 0
20024f4: 02 80 00 04 be 2002504 <mknod+0x1a0> <== ALWAYS TAKEN
20024f8: 01 00 00 00 nop
20024fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002500: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return result;
}
2002504: 81 c7 e0 08 ret
2002508: 81 e8 00 00 restore
);
if ( result != 0 )
return -1;
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
200250c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2002510: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002514: 02 bf ff cb be 2002440 <mknod+0xdc> <== NOT EXECUTED
2002518: 01 00 00 00 nop <== NOT EXECUTED
200251c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002520: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2002524: 30 bf ff c7 b,a 2002440 <mknod+0xdc> <== NOT EXECUTED
0200b010 <mount>:
const rtems_filesystem_operations_table *fs_ops,
rtems_filesystem_options_t options,
const char *device,
const char *mount_point
)
{
200b010: 9d e3 bf 88 save %sp, -120, %sp
/*
* Is there a file system operations table?
*/
if ( fs_ops == NULL ) {
200b014: 80 a6 60 00 cmp %i1, 0
200b018: 02 80 00 a1 be 200b29c <mount+0x28c> <== NEVER TAKEN
200b01c: a4 10 00 18 mov %i0, %l2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
200b020: 80 a6 a0 01 cmp %i2, 1
200b024: 18 80 00 9e bgu 200b29c <mount+0x28c> <== NEVER TAKEN
200b028: 01 00 00 00 nop
errno = EINVAL;
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
200b02c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
200b030: 80 a0 60 00 cmp %g1, 0
200b034: 02 80 00 35 be 200b108 <mount+0xf8> <== NEVER TAKEN
200b038: 80 a6 e0 00 cmp %i3, 0
/*
* Allocate a mount table entry
*/
size = sizeof(rtems_filesystem_mount_table_entry_t);
if ( device )
200b03c: 02 80 00 05 be 200b050 <mount+0x40> <== ALWAYS TAKEN
200b040: 90 10 20 64 mov 0x64, %o0
size += strlen( device ) + 1;
200b044: 40 00 0c a2 call 200e2cc <strlen> <== NOT EXECUTED
200b048: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200b04c: 90 02 20 65 add %o0, 0x65, %o0 <== NOT EXECUTED
temp_mt_entry = malloc( size );
200b050: 7f ff ff 9f call 200aecc <malloc>
200b054: 01 00 00 00 nop
if ( !temp_mt_entry ) {
200b058: a0 92 20 00 orcc %o0, 0, %l0
200b05c: 02 80 00 96 be 200b2b4 <mount+0x2a4> <== NEVER TAKEN
200b060: a2 10 00 10 mov %l0, %l1
errno = ENOMEM;
return -1;
}
temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry;
temp_mt_entry->options = options;
200b064: f4 24 20 28 st %i2, [ %l0 + 0x28 ]
if ( device ) {
200b068: 80 a6 e0 00 cmp %i3, 0
200b06c: 02 80 00 4b be 200b198 <mount+0x188> <== ALWAYS TAKEN
200b070: e0 24 20 24 st %l0, [ %l0 + 0x24 ]
temp_mt_entry->dev =
200b074: 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 );
200b078: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
200b07c: 40 00 0c 72 call 200e244 <strcpy> <== NOT EXECUTED
200b080: 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 ) {
200b084: 80 a7 20 00 cmp %i4, 0
200b088: 02 80 00 29 be 200b12c <mount+0x11c> <== ALWAYS TAKEN
200b08c: 90 10 00 1c mov %i4, %o0
if ( rtems_filesystem_evaluate_path(
200b090: b6 07 bf e8 add %fp, -24, %i3 <== NOT EXECUTED
200b094: 92 10 20 07 mov 7, %o1 <== NOT EXECUTED
200b098: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
200b09c: 7f ff db f1 call 2002060 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
200b0a0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
200b0a4: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
200b0a8: 02 80 00 1c be 200b118 <mount+0x108> <== NOT EXECUTED
200b0ac: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
200b0b0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200b0b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200b0b8: 02 80 00 6d be 200b26c <mount+0x25c> <== NOT EXECUTED
200b0bc: 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 ) {
200b0c0: 9f c0 40 00 call %g1 <== NOT EXECUTED
200b0c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200b0c8: 80 a2 20 01 cmp %o0, 1 <== NOT EXECUTED
200b0cc: 02 80 00 35 be 200b1a0 <mount+0x190> <== NOT EXECUTED
200b0d0: 03 00 80 5d sethi %hi(0x2017400), %g1 <== NOT EXECUTED
errno = ENOTDIR;
200b0d4: 40 00 07 5c call 200ce44 <__errno> <== NOT EXECUTED
200b0d8: 01 00 00 00 nop <== NOT EXECUTED
200b0dc: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
200b0e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
200b0e4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
200b0e8: 7f ff fe 02 call 200a8f0 <free> <== NOT EXECUTED
200b0ec: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
200b0f0: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
200b0f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200b0f8: 32 80 00 62 bne,a 200b280 <mount+0x270> <== NOT EXECUTED
200b0fc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
return -1;
}
200b100: 81 c7 e0 08 ret <== NOT EXECUTED
200b104: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
return -1;
}
/* Do they support being mounted at all ? */
if ( !fs_ops->fsmount_me_h ) {
errno = ENOTSUP;
200b108: 40 00 07 4f call 200ce44 <__errno> <== NOT EXECUTED
200b10c: a2 10 20 00 clr %l1 <== NOT EXECUTED
200b110: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
200b114: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
200b118: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
200b11c: 7f ff fd f5 call 200a8f0 <free> <== NOT EXECUTED
200b120: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200b124: 81 c7 e0 08 ret <== NOT EXECUTED
200b128: 81 e8 00 00 restore <== 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;
200b12c: c0 24 20 18 clr [ %l0 + 0x18 ]
temp_mt_entry->mt_fs_root.handlers = NULL;
200b130: c0 24 20 1c clr [ %l0 + 0x1c ]
temp_mt_entry->mt_fs_root.ops = NULL;
200b134: c0 24 20 20 clr [ %l0 + 0x20 ]
temp_mt_entry->mt_point_node.node_access = NULL;
200b138: c0 24 20 08 clr [ %l0 + 8 ]
temp_mt_entry->mt_point_node.handlers = NULL;
200b13c: c0 24 20 0c clr [ %l0 + 0xc ]
temp_mt_entry->mt_point_node.ops = NULL;
200b140: c0 24 20 10 clr [ %l0 + 0x10 ]
temp_mt_entry->mt_point_node.mt_entry = NULL;
200b144: c0 24 20 14 clr [ %l0 + 0x14 ]
200b148: b8 10 20 00 clr %i4
}
if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) {
200b14c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
200b150: 9f c0 40 00 call %g1
200b154: 90 10 00 10 mov %l0, %o0
200b158: 80 a2 20 00 cmp %o0, 0
200b15c: 02 80 00 35 be 200b230 <mount+0x220> <== ALWAYS TAKEN
200b160: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* try to undo the mount operation */
if ( loc.ops->unmount_h ) {
200b164: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 <== NOT EXECUTED
200b168: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200b16c: 02 80 00 04 be 200b17c <mount+0x16c> <== NOT EXECUTED
200b170: 01 00 00 00 nop <== NOT EXECUTED
loc.ops->unmount_h( temp_mt_entry );
200b174: 9f c0 40 00 call %g1 <== NOT EXECUTED
200b178: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
200b17c: 7f ff fd dd call 200a8f0 <free> <== NOT EXECUTED
200b180: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if ( loc_to_free )
200b184: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
200b188: 32 bf ff db bne,a 200b0f4 <mount+0xe4> <== NOT EXECUTED
200b18c: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
200b190: 81 c7 e0 08 ret <== NOT EXECUTED
200b194: 91 e8 3f ff restore %g0, -1, %o0 <== 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;
200b198: 10 bf ff bb b 200b084 <mount+0x74>
200b19c: c0 24 20 60 clr [ %l0 + 0x60 ]
/*
* For each mount table entry
*/
for ( the_node = rtems_filesystem_mount_table_control.first;
200b1a0: c4 00 62 a8 ld [ %g1 + 0x2a8 ], %g2 <== NOT EXECUTED
200b1a4: 82 10 62 a8 or %g1, 0x2a8, %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
200b1a8: 88 00 60 04 add %g1, 4, %g4 <== NOT EXECUTED
!rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node );
200b1ac: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
200b1b0: 02 80 00 0e be 200b1e8 <mount+0x1d8> <== NOT EXECUTED
200b1b4: c6 07 bf e8 ld [ %fp + -24 ], %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 )
200b1b8: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 <== NOT EXECUTED
200b1bc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
200b1c0: 32 80 00 07 bne,a 200b1dc <mount+0x1cc> <== NOT EXECUTED
200b1c4: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
200b1c8: 30 80 00 24 b,a 200b258 <mount+0x248> <== NOT EXECUTED
200b1cc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
200b1d0: 02 80 00 22 be 200b258 <mount+0x248> <== NOT EXECUTED
200b1d4: 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 ) {
200b1d8: 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 );
200b1dc: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
200b1e0: 32 bf ff fb bne,a 200b1cc <mount+0x1bc> <== NOT EXECUTED
200b1e4: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 <== 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;
200b1e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== 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;
200b1ec: c6 24 20 08 st %g3, [ %l0 + 8 ] <== NOT EXECUTED
temp_mt_entry->mt_point_node.handlers = loc.handlers;
200b1f0: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
temp_mt_entry->mt_point_node.ops = loc.ops;
temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry;
200b1f4: c6 07 bf f4 ld [ %fp + -12 ], %g3 <== 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 ){
200b1f8: c8 00 60 20 ld [ %g1 + 0x20 ], %g4 <== 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;
200b1fc: 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;
200b200: c6 24 20 14 st %g3, [ %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 ){
200b204: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
200b208: 02 80 00 19 be 200b26c <mount+0x25c> <== NOT EXECUTED
200b20c: c2 24 20 10 st %g1, [ %l0 + 0x10 ] <== NOT EXECUTED
errno = ENOTSUP;
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( temp_mt_entry ) ) {
200b210: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
200b214: 9f c1 00 00 call %g4 <== NOT EXECUTED
200b218: b8 10 00 1b mov %i3, %i4 <== NOT EXECUTED
200b21c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200b220: 22 bf ff cc be,a 200b150 <mount+0x140> <== NOT EXECUTED
200b224: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( temp_mt_entry );
200b228: 10 bf ff b0 b 200b0e8 <mount+0xd8> <== NOT EXECUTED
200b22c: 90 10 00 10 mov %l0, %o0 <== 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 );
200b230: 11 00 80 5d sethi %hi(0x2017400), %o0
200b234: 92 10 00 10 mov %l0, %o1
200b238: 7f ff ec 3b call 2006324 <_Chain_Append>
200b23c: 90 12 22 a8 or %o0, 0x2a8, %o0
*/
rtems_chain_append( &rtems_filesystem_mount_table_control,
&temp_mt_entry->Node );
if ( mt_entry )
200b240: 80 a4 a0 00 cmp %l2, 0
200b244: 02 bf ff b8 be 200b124 <mount+0x114> <== NEVER TAKEN
200b248: b0 10 20 00 clr %i0
*mt_entry = temp_mt_entry;
200b24c: e0 24 80 00 st %l0, [ %l2 ]
200b250: 81 c7 e0 08 ret
200b254: 81 e8 00 00 restore
/*
* You can only mount one file system onto a single mount point.
*/
if ( Is_node_fs_root( &loc ) ){
errno = EBUSY;
200b258: 40 00 06 fb call 200ce44 <__errno> <== NOT EXECUTED
200b25c: 01 00 00 00 nop <== NOT EXECUTED
200b260: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
200b264: 10 bf ff a0 b 200b0e4 <mount+0xd4> <== NOT EXECUTED
200b268: c2 22 00 00 st %g1, [ %o0 ] <== 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;
200b26c: 40 00 06 f6 call 200ce44 <__errno> <== NOT EXECUTED
200b270: 01 00 00 00 nop <== NOT EXECUTED
200b274: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
200b278: 10 bf ff 9b b 200b0e4 <mount+0xd4> <== NOT EXECUTED
200b27c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
cleanup_and_bail:
free( temp_mt_entry );
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
200b280: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200b284: 02 bf ff a8 be 200b124 <mount+0x114> <== NOT EXECUTED
200b288: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200b28c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200b290: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
200b294: 81 c7 e0 08 ret <== NOT EXECUTED
200b298: 81 e8 00 00 restore <== NOT EXECUTED
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
options != RTEMS_FILESYSTEM_READ_WRITE ) {
errno = EINVAL;
200b29c: 40 00 06 ea call 200ce44 <__errno> <== NOT EXECUTED
200b2a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200b2a4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200b2a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200b2ac: 81 c7 e0 08 ret <== NOT EXECUTED
200b2b0: 81 e8 00 00 restore <== NOT EXECUTED
if ( device )
size += strlen( device ) + 1;
temp_mt_entry = malloc( size );
if ( !temp_mt_entry ) {
errno = ENOMEM;
200b2b4: 40 00 06 e4 call 200ce44 <__errno> <== NOT EXECUTED
200b2b8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200b2bc: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
200b2c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200b2c4: 81 c7 e0 08 ret <== NOT EXECUTED
200b2c8: 81 e8 00 00 restore <== NOT EXECUTED
020025b0 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
20025b0: 9d e3 bf 98 save %sp, -104, %sp
switch ( fileno(fp) ) {
20025b4: 40 00 2b 05 call 200d1c8 <fileno>
20025b8: 90 10 00 18 mov %i0, %o0
20025bc: 80 a2 20 02 cmp %o0, 2
20025c0: 28 80 00 06 bleu,a 20025d8 <newlib_free_buffers+0x28> <== ALWAYS TAKEN
20025c4: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
20025c8: 40 00 2a 77 call 200cfa4 <fclose> <== NOT EXECUTED
20025cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
20025d0: 81 c7 e0 08 ret
20025d4: 91 e8 20 00 restore %g0, 0, %o0
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
20025d8: 80 88 60 80 btst 0x80, %g1
20025dc: 02 bf ff fd be 20025d0 <newlib_free_buffers+0x20>
20025e0: 01 00 00 00 nop
free( fp->_bf._base );
20025e4: 40 00 20 c3 call 200a8f0 <free>
20025e8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
fp->_flags &= ~__SMBF;
20025ec: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
fp->_bf._base = fp->_p = (unsigned char *) NULL;
20025f0: c0 26 20 10 clr [ %i0 + 0x10 ]
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
20025f4: 82 08 7f 7f and %g1, -129, %g1
fp->_bf._base = fp->_p = (unsigned char *) NULL;
20025f8: c0 26 00 00 clr [ %i0 ]
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
20025fc: c2 36 20 0c sth %g1, [ %i0 + 0xc ]
break;
default:
fclose(fp);
}
return 0;
}
2002600: 81 c7 e0 08 ret
2002604: 91 e8 20 00 restore %g0, 0, %o0
0200281c <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor,
void *pargp
)
{
200281c: 9d e3 bf 98 save %sp, -104, %sp
rtems_device_driver status;
if ( !initialized ) {
2002820: 05 00 80 6a sethi %hi(0x201a800), %g2
2002824: c2 48 a3 8c ldsb [ %g2 + 0x38c ], %g1 ! 201ab8c <initialized>
2002828: 80 a0 60 00 cmp %g1, 0
200282c: 02 80 00 04 be 200283c <null_initialize+0x20>
2002830: 82 10 20 01 mov 1, %g1
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
2002834: 81 c7 e0 08 ret
2002838: 91 e8 20 00 restore %g0, 0, %o0
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
status = rtems_io_register_name(
200283c: 11 00 80 61 sethi %hi(0x2018400), %o0
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
2002840: c2 28 a3 8c stb %g1, [ %g2 + 0x38c ]
status = rtems_io_register_name(
2002844: 90 12 22 28 or %o0, 0x228, %o0
2002848: 92 10 00 18 mov %i0, %o1
200284c: 40 00 00 4e call 2002984 <rtems_io_register_name>
2002850: 94 10 20 00 clr %o2
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
2002854: 80 a2 20 00 cmp %o0, 0
2002858: 12 80 00 05 bne 200286c <null_initialize+0x50> <== NEVER TAKEN
200285c: 03 00 80 6b sethi %hi(0x201ac00), %g1
rtems_fatal_error_occurred(status);
NULL_major = major;
2002860: f0 20 62 08 st %i0, [ %g1 + 0x208 ] ! 201ae08 <NULL_major>
}
return RTEMS_SUCCESSFUL;
}
2002864: 81 c7 e0 08 ret
2002868: 91 e8 20 00 restore %g0, 0, %o0
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
200286c: 40 00 11 0e call 2006ca4 <rtems_fatal_error_occurred> <== NOT EXECUTED
020027f8 <null_write>:
void *pargp
)
{
rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp;
if ( rw_args )
20027f8: 80 a2 a0 00 cmp %o2, 0
20027fc: 02 80 00 04 be 200280c <null_write+0x14> <== ALWAYS TAKEN
2002800: 01 00 00 00 nop
rw_args->bytes_moved = rw_args->count;
2002804: c2 02 a0 0c ld [ %o2 + 0xc ], %g1 <== NOT EXECUTED
2002808: c2 22 a0 14 st %g1, [ %o2 + 0x14 ] <== NOT EXECUTED
return NULL_SUCCESSFUL;
}
200280c: 81 c3 e0 08 retl
2002810: 90 10 20 00 clr %o0
02002824 <open>:
int open(
const char *pathname,
int flags,
...
)
{
2002824: 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);
2002828: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
200282c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2002830: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2002834: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
2002838: 82 06 60 01 add %i1, 1, %g1
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
200283c: 80 88 60 02 btst 2, %g1
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
2002840: 82 08 60 01 and %g1, 1, %g1
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
2002844: 02 80 00 03 be 2002850 <open+0x2c>
2002848: a1 28 60 02 sll %g1, 2, %l0
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
200284c: a0 14 20 02 or %l0, 2, %l0
va_start(ap, flags);
mode = va_arg( ap, int );
2002850: 82 07 a0 50 add %fp, 0x50, %g1
2002854: f4 07 a0 4c ld [ %fp + 0x4c ], %i2
2002858: 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();
200285c: 40 00 21 2a call 200ad04 <rtems_libio_allocate>
2002860: b8 10 20 17 mov 0x17, %i4
if ( iop == 0 ) {
2002864: ba 92 20 00 orcc %o0, 0, %i5
2002868: 02 80 00 3b be 2002954 <open+0x130>
200286c: 92 10 00 10 mov %l0, %o1
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
2002870: b6 07 bf e4 add %fp, -28, %i3
2002874: 90 10 00 18 mov %i0, %o0
2002878: 94 10 00 1b mov %i3, %o2
200287c: 7f ff fd f9 call 2002060 <rtems_filesystem_evaluate_path>
2002880: 96 10 20 01 mov 1, %o3
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
2002884: 80 a2 3f ff cmp %o0, -1
2002888: 02 80 00 4d be 20029bc <open+0x198> <== NEVER TAKEN
200288c: 82 0e 6a 00 and %i1, 0xa00, %g1
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
2002890: b8 10 20 11 mov 0x11, %i4
2002894: 80 a0 6a 00 cmp %g1, 0xa00
2002898: 02 80 00 69 be 2002a3c <open+0x218> <== NEVER TAKEN
200289c: a0 10 00 1b mov %i3, %l0
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
20028a0: c2 07 bf e8 ld [ %fp + -24 ], %g1
iop->file_info = loc.node_access;
20028a4: c4 07 bf e4 ld [ %fp + -28 ], %g2
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
20028a8: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
iop->file_info = loc.node_access;
20028ac: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
iop->flags |= rtems_libio_fcntl_flags( flags );
20028b0: e0 07 60 0c ld [ %i5 + 0xc ], %l0
20028b4: 40 00 21 52 call 200adfc <rtems_libio_fcntl_flags>
20028b8: 90 10 00 19 mov %i1, %o0
iop->pathinfo = loc;
20028bc: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ( !iop->handlers->open_h ) {
20028c0: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
20028c4: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
20028c8: c2 07 bf e8 ld [ %fp + -24 ], %g1
if ( !iop->handlers->open_h ) {
20028cc: c4 00 80 00 ld [ %g2 ], %g2
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
20028d0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
20028d4: c2 07 bf ec ld [ %fp + -20 ], %g1
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
20028d8: 90 12 00 10 or %o0, %l0, %o0
iop->pathinfo = loc;
20028dc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
20028e0: c2 07 bf f0 ld [ %fp + -16 ], %g1
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
20028e4: d0 27 60 0c st %o0, [ %i5 + 0xc ]
iop->pathinfo = loc;
if ( !iop->handlers->open_h ) {
20028e8: 80 a0 a0 00 cmp %g2, 0
20028ec: 02 80 00 52 be 2002a34 <open+0x210> <== NEVER TAKEN
20028f0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
20028f4: 92 10 00 18 mov %i0, %o1
20028f8: 96 10 00 1a mov %i2, %o3
20028fc: 90 10 00 1d mov %i5, %o0
2002900: 94 10 00 19 mov %i1, %o2
2002904: 9f c0 80 00 call %g2
2002908: a0 10 00 1b mov %i3, %l0
if ( rc )
200290c: 80 a2 20 00 cmp %o0, 0
2002910: 02 80 00 16 be 2002968 <open+0x144> <== ALWAYS TAKEN
2002914: b8 10 00 08 mov %o0, %i4
done:
va_end(ap);
if ( rc ) {
if ( iop )
rtems_libio_free( iop );
2002918: 40 00 20 e4 call 200aca8 <rtems_libio_free> <== NOT EXECUTED
200291c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if ( loc_to_free )
2002920: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2002924: 02 80 00 0c be 2002954 <open+0x130> <== NOT EXECUTED
2002928: 01 00 00 00 nop <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
200292c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED
2002930: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002934: 02 80 00 08 be 2002954 <open+0x130> <== NOT EXECUTED
2002938: 01 00 00 00 nop <== NOT EXECUTED
200293c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2002940: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002944: 02 80 00 04 be 2002954 <open+0x130> <== NOT EXECUTED
2002948: 01 00 00 00 nop <== NOT EXECUTED
200294c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002950: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( rc );
2002954: 40 00 29 3c call 200ce44 <__errno>
2002958: b0 10 3f ff mov -1, %i0
200295c: f8 22 00 00 st %i4, [ %o0 ]
2002960: 81 c7 e0 08 ret
2002964: 81 e8 00 00 restore
2002968: 03 00 80 5c sethi %hi(0x2017000), %g1
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
200296c: 80 8e 64 00 btst 0x400, %i1
2002970: 12 80 00 40 bne 2002a70 <open+0x24c> <== NEVER TAKEN
2002974: a0 10 62 0c or %g1, 0x20c, %l0
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
2002978: c6 04 00 00 ld [ %l0 ], %g3
200297c: 86 27 40 03 sub %i5, %g3, %g3
2002980: 87 38 e0 02 sra %g3, 2, %g3
2002984: 89 28 e0 02 sll %g3, 2, %g4
2002988: 85 28 e0 06 sll %g3, 6, %g2
200298c: 84 20 80 04 sub %g2, %g4, %g2
2002990: 83 28 a0 06 sll %g2, 6, %g1
2002994: 82 20 40 02 sub %g1, %g2, %g1
2002998: 89 28 60 0c sll %g1, 0xc, %g4
200299c: 82 00 40 04 add %g1, %g4, %g1
20029a0: 82 00 40 03 add %g1, %g3, %g1
20029a4: 83 28 60 04 sll %g1, 4, %g1
20029a8: 82 20 40 03 sub %g1, %g3, %g1
20029ac: 83 28 60 02 sll %g1, 2, %g1
20029b0: b0 20 c0 01 sub %g3, %g1, %i0
}
20029b4: 81 c7 e0 08 ret
20029b8: 81 e8 00 00 restore
status = rtems_filesystem_evaluate_path(
pathname, eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
20029bc: 40 00 29 22 call 200ce44 <__errno> <== NOT EXECUTED
20029c0: 01 00 00 00 nop <== NOT EXECUTED
20029c4: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
20029c8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
20029cc: 12 80 00 20 bne 2002a4c <open+0x228> <== NOT EXECUTED
20029d0: 80 8e 62 00 btst 0x200, %i1 <== 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) ) {
20029d4: b8 10 20 02 mov 2, %i4 <== NOT EXECUTED
20029d8: 02 80 00 19 be 2002a3c <open+0x218> <== NOT EXECUTED
20029dc: 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 );
20029e0: 13 3f ff e0 sethi %hi(0xffff8000), %o1 <== NOT EXECUTED
20029e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20029e8: 92 16 80 09 or %i2, %o1, %o1 <== NOT EXECUTED
20029ec: 94 10 20 00 clr %o2 <== NOT EXECUTED
20029f0: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
20029f4: 96 10 20 00 clr %o3 <== NOT EXECUTED
20029f8: 7f ff fe 5b call 2002364 <mknod> <== NOT EXECUTED
20029fc: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
if ( rc ) {
2002a00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2002a04: 12 80 00 12 bne 2002a4c <open+0x228> <== NOT EXECUTED
2002a08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = errno;
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true );
2002a0c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2002a10: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2002a14: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
2002a18: 7f ff fd 92 call 2002060 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
2002a1c: b8 10 20 0d mov 0xd, %i4 <== NOT EXECUTED
if ( status != 0 ) { /* The file did not exist */
2002a20: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2002a24: 12 80 00 06 bne 2002a3c <open+0x218> <== NOT EXECUTED
2002a28: 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;
2002a2c: 10 bf ff 9e b 20028a4 <open+0x80> <== NOT EXECUTED
2002a30: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
2002a34: a0 10 00 1b mov %i3, %l0 <== NOT EXECUTED
2002a38: b8 10 20 86 mov 0x86, %i4 <== NOT EXECUTED
done:
va_end(ap);
if ( rc ) {
if ( iop )
2002a3c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2002a40: 02 bf ff b9 be 2002924 <open+0x100> <== NOT EXECUTED
2002a44: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2002a48: 30 bf ff b4 b,a 2002918 <open+0xf4> <== NOT EXECUTED
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
2002a4c: 40 00 28 fe call 200ce44 <__errno> <== NOT EXECUTED
2002a50: 01 00 00 00 nop <== NOT EXECUTED
2002a54: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED
2002a58: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
*/
done:
va_end(ap);
if ( rc ) {
2002a5c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2002a60: 02 bf ff c6 be 2002978 <open+0x154> <== NOT EXECUTED
2002a64: a0 10 62 0c or %g1, 0x20c, %l0 <== NOT EXECUTED
2002a68: 10 bf ff f5 b 2002a3c <open+0x218> <== NOT EXECUTED
2002a6c: a0 10 20 00 clr %l0 <== NOT EXECUTED
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
2002a70: c4 00 62 0c ld [ %g1 + 0x20c ], %g2 <== NOT EXECUTED
2002a74: 92 10 20 00 clr %o1 <== NOT EXECUTED
2002a78: 84 27 40 02 sub %i5, %g2, %g2 <== NOT EXECUTED
2002a7c: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED
2002a80: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
2002a84: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED
2002a88: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
2002a8c: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED
2002a90: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
2002a94: 87 2a 20 0c sll %o0, 0xc, %g3 <== NOT EXECUTED
2002a98: 90 02 00 03 add %o0, %g3, %o0 <== NOT EXECUTED
2002a9c: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED
2002aa0: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED
2002aa4: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
2002aa8: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
2002aac: 40 00 1f bc call 200a99c <ftruncate> <== NOT EXECUTED
2002ab0: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED
if ( rc ) {
2002ab4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2002ab8: 22 bf ff b1 be,a 200297c <open+0x158> <== NOT EXECUTED
2002abc: c6 04 00 00 ld [ %l0 ], %g3 <== NOT EXECUTED
if(errno) rc = errno;
2002ac0: 40 00 28 e1 call 200ce44 <__errno> <== NOT EXECUTED
2002ac4: 01 00 00 00 nop <== NOT EXECUTED
2002ac8: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2002acc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002ad0: 12 80 00 15 bne 2002b24 <open+0x300> <== NOT EXECUTED
2002ad4: 01 00 00 00 nop <== NOT EXECUTED
close( iop - rtems_libio_iops );
2002ad8: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED
2002adc: 84 27 40 02 sub %i5, %g2, %g2 <== NOT EXECUTED
2002ae0: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED
2002ae4: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
2002ae8: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED
2002aec: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
2002af0: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED
2002af4: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
2002af8: 87 2a 20 0c sll %o0, 0xc, %g3 <== NOT EXECUTED
2002afc: ba 10 20 00 clr %i5 <== NOT EXECUTED
2002b00: 90 02 00 03 add %o0, %g3, %o0 <== NOT EXECUTED
2002b04: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED
2002b08: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED
2002b0c: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
2002b10: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
2002b14: 40 00 1f 46 call 200a82c <close> <== NOT EXECUTED
2002b18: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED
2002b1c: 10 bf ff d0 b 2002a5c <open+0x238> <== NOT EXECUTED
2002b20: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
2002b24: 40 00 28 c8 call 200ce44 <__errno> <== NOT EXECUTED
2002b28: 01 00 00 00 nop <== NOT EXECUTED
2002b2c: 10 bf ff eb b 2002ad8 <open+0x2b4> <== NOT EXECUTED
2002b30: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED
020027b0 <open_dev_console>:
/*
* This is a replaceable stub
*/
void open_dev_console(void)
{
20027b0: 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) {
20027b4: 21 00 80 55 sethi %hi(0x2015400), %l0
20027b8: 92 10 20 00 clr %o1
20027bc: 90 14 20 e0 or %l0, 0xe0, %o0
20027c0: 40 00 00 19 call 2002824 <open>
20027c4: 94 10 20 00 clr %o2
20027c8: 80 a2 3f ff cmp %o0, -1
20027cc: 02 80 00 0e be 2002804 <open_dev_console+0x54>
20027d0: 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)
20027d4: 92 10 20 01 mov 1, %o1
20027d8: 40 00 00 13 call 2002824 <open>
20027dc: 94 10 20 00 clr %o2
20027e0: 80 a2 3f ff cmp %o0, -1
20027e4: 02 80 00 0c be 2002814 <open_dev_console+0x64> <== NEVER TAKEN
20027e8: 92 10 20 01 mov 1, %o1
rtems_fatal_error_occurred( error_code | '1' );
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
20027ec: 90 14 20 e0 or %l0, 0xe0, %o0
20027f0: 40 00 00 0d call 2002824 <open>
20027f4: 94 10 20 00 clr %o2
20027f8: 80 a2 3f ff cmp %o0, -1
20027fc: 02 80 00 04 be 200280c <open_dev_console+0x5c> <== NEVER TAKEN
2002800: 11 14 d5 11 sethi %hi(0x53544400), %o0
2002804: 81 c7 e0 08 ret
2002808: 81 e8 00 00 restore
rtems_fatal_error_occurred( error_code | '2' );
200280c: 40 00 0d d6 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2002810: 90 12 20 32 or %o0, 0x32, %o0 <== NOT EXECUTED
/*
* 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)
rtems_fatal_error_occurred( error_code | '1' );
2002814: 11 14 d5 11 sethi %hi(0x53544400), %o0 <== NOT EXECUTED
2002818: 40 00 0d d3 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
200281c: 90 12 20 31 or %o0, 0x31, %o0 ! 53544431 <RAM_END+0x51144431><== NOT EXECUTED
02003780 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
2003780: 9d e3 bf 98 save %sp, -104, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
2003784: c6 06 60 34 ld [ %i1 + 0x34 ], %g3
2003788: 80 88 e0 01 btst 1, %g3
200378c: 02 80 00 10 be 20037cc <oproc+0x4c> <== NEVER TAKEN
2003790: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
2003794: b0 0e 20 ff and %i0, 0xff, %i0
2003798: 80 a6 20 09 cmp %i0, 9
200379c: 22 80 00 28 be,a 200383c <oproc+0xbc>
20037a0: c8 06 60 28 ld [ %i1 + 0x28 ], %g4
20037a4: 18 80 00 10 bgu 20037e4 <oproc+0x64> <== ALWAYS TAKEN
20037a8: 80 a6 20 0a cmp %i0, 0xa
20037ac: 80 a6 20 08 cmp %i0, 8 <== NOT EXECUTED
20037b0: 12 80 00 11 bne 20037f4 <oproc+0x74> <== NOT EXECUTED
20037b4: 80 88 e0 02 btst 2, %g3 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
20037b8: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
20037bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20037c0: 04 80 00 03 ble 20037cc <oproc+0x4c> <== NOT EXECUTED
20037c4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
tty->column--;
20037c8: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
20037cc: 94 10 00 19 mov %i1, %o2
20037d0: 90 07 a0 44 add %fp, 0x44, %o0
20037d4: 7f ff ff 9d call 2003648 <rtems_termios_puts>
20037d8: 92 10 20 01 mov 1, %o1
20037dc: 81 c7 e0 08 ret
20037e0: 81 e8 00 00 restore
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
20037e4: 02 80 00 24 be 2003874 <oproc+0xf4>
20037e8: 80 a6 20 0d cmp %i0, 0xd
20037ec: 02 80 00 2f be 20038a8 <oproc+0x128> <== NEVER TAKEN
20037f0: 80 88 e0 02 btst 2, %g3
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
20037f4: 02 80 00 08 be 2003814 <oproc+0x94> <== ALWAYS TAKEN
20037f8: 07 00 80 5a sethi %hi(0x2016800), %g3
c = toupper(c);
20037fc: c4 00 e2 f0 ld [ %g3 + 0x2f0 ], %g2 ! 2016af0 <__ctype_ptr><== NOT EXECUTED
2003800: c2 08 80 18 ldub [ %g2 + %i0 ], %g1 <== NOT EXECUTED
2003804: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2003808: 32 80 00 02 bne,a 2003810 <oproc+0x90> <== NOT EXECUTED
200380c: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
2003810: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
2003814: c2 00 e2 f0 ld [ %g3 + 0x2f0 ], %g1
2003818: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2
200381c: c6 08 40 02 ldub [ %g1 + %g2 ], %g3
2003820: 80 88 e0 20 btst 0x20, %g3
2003824: 12 bf ff eb bne 20037d0 <oproc+0x50> <== NEVER TAKEN
2003828: 94 10 00 19 mov %i1, %o2
tty->column++;
200382c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2003830: 82 00 60 01 inc %g1
2003834: 10 bf ff e7 b 20037d0 <oproc+0x50>
2003838: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
200383c: 05 00 00 06 sethi %hi(0x1800), %g2
2003840: 82 08 c0 02 and %g3, %g2, %g1
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
2003844: 86 09 20 07 and %g4, 7, %g3
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
2003848: 80 a0 40 02 cmp %g1, %g2
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
200384c: 82 10 20 08 mov 8, %g1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
2003850: 02 80 00 25 be 20038e4 <oproc+0x164> <== ALWAYS TAKEN
2003854: 92 20 40 03 sub %g1, %g3, %o1
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
2003858: 82 02 40 04 add %o1, %g4, %g1 <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
200385c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
2003860: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!iscntrl(c))
tty->column++;
break;
}
}
rtems_termios_puts (&c, 1, tty);
2003864: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED
2003868: 7f ff ff 78 call 2003648 <rtems_termios_puts> <== NOT EXECUTED
200386c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2003870: 30 80 00 23 b,a 20038fc <oproc+0x17c> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
2003874: 80 88 e0 20 btst 0x20, %g3
2003878: 32 80 00 02 bne,a 2003880 <oproc+0x100> <== NEVER TAKEN
200387c: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
2003880: 80 88 e0 04 btst 4, %g3
2003884: 02 bf ff d3 be 20037d0 <oproc+0x50> <== NEVER TAKEN
2003888: 94 10 00 19 mov %i1, %o2
rtems_termios_puts ("\r", 1, tty);
200388c: 11 00 80 56 sethi %hi(0x2015800), %o0
2003890: 92 10 20 01 mov 1, %o1
2003894: 90 12 20 88 or %o0, 0x88, %o0
2003898: 7f ff ff 6c call 2003648 <rtems_termios_puts>
200389c: 94 10 00 19 mov %i1, %o2
tty->column = 0;
20038a0: 10 bf ff cb b 20037cc <oproc+0x4c>
20038a4: c0 26 60 28 clr [ %i1 + 0x28 ]
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
20038a8: 80 88 e0 10 btst 0x10, %g3 <== NOT EXECUTED
20038ac: 02 80 00 06 be 20038c4 <oproc+0x144> <== NOT EXECUTED
20038b0: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED
20038b4: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
20038b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20038bc: 02 bf ff c8 be 20037dc <oproc+0x5c> <== NOT EXECUTED
20038c0: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
20038c4: 22 bf ff c2 be,a 20037cc <oproc+0x4c> <== NOT EXECUTED
20038c8: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
20038cc: 82 10 20 0a mov 0xa, %g1 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
20038d0: 80 88 e0 20 btst 0x20, %g3 <== NOT EXECUTED
20038d4: 02 bf ff be be 20037cc <oproc+0x4c> <== NOT EXECUTED
20038d8: c2 2f a0 44 stb %g1, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
20038dc: 10 bf ff bc b 20037cc <oproc+0x4c> <== NOT EXECUTED
20038e0: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
20038e4: 82 02 40 04 add %o1, %g4, %g1
rtems_termios_puts ( " ", i, tty);
20038e8: 94 10 00 19 mov %i1, %o2
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
20038ec: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
rtems_termios_puts ( " ", i, tty);
20038f0: 11 00 80 56 sethi %hi(0x2015800), %o0
20038f4: 7f ff ff 55 call 2003648 <rtems_termios_puts>
20038f8: 90 12 20 90 or %o0, 0x90, %o0 ! 2015890 <pollCallbacks.4767+0x380>
20038fc: 81 c7 e0 08 ret
2003900: 81 e8 00 00 restore
02004804 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2004804: 03 00 80 73 sethi %hi(0x201cc00), %g1
2004808: 82 10 62 a8 or %g1, 0x2a8, %g1 ! 201cea8 <rtems_malloc_statistics>
200480c: c4 00 60 08 ld [ %g1 + 8 ], %g2
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2004810: 86 02 7f ff add %o1, -1, %g3
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2004814: 84 00 a0 01 inc %g2
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2004818: 80 88 c0 09 btst %g3, %o1
200481c: 12 80 00 08 bne 200483c <posix_memalign+0x38> <== NEVER TAKEN
2004820: c4 20 60 08 st %g2, [ %g1 + 8 ]
2004824: 80 a2 60 03 cmp %o1, 3
2004828: 08 80 00 05 bleu 200483c <posix_memalign+0x38>
200482c: 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 );
2004830: 82 13 c0 00 mov %o7, %g1
2004834: 40 00 01 8b call 2004e60 <rtems_memalign>
2004838: 9e 10 40 00 mov %g1, %o7
}
200483c: 81 c3 e0 08 retl
2004840: 90 10 20 16 mov 0x16, %o0
020149c4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
20149c4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20149c8: 03 00 80 59 sethi %hi(0x2016400), %g1 <== NOT EXECUTED
20149cc: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops><== NOT EXECUTED
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
20149d0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20149d4: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED
20149d8: 1a 80 00 24 bcc 2014a68 <read+0xa4> <== NOT EXECUTED
20149dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
iop = rtems_libio_iop( fd );
20149e0: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
20149e4: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops><== NOT EXECUTED
20149e8: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED
20149ec: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED
20149f0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
20149f4: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
20149f8: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
20149fc: b0 00 c0 01 add %g3, %g1, %i0 <== NOT EXECUTED
rtems_libio_check_is_open( iop );
2014a00: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
2014a04: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
2014a08: 02 80 00 18 be 2014a68 <read+0xa4> <== NOT EXECUTED
2014a0c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_libio_check_buffer( buffer );
2014a10: 02 80 00 22 be 2014a98 <read+0xd4> <== NOT EXECUTED
2014a14: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
rtems_libio_check_count( count );
2014a18: 02 80 00 12 be 2014a60 <read+0x9c> <== NOT EXECUTED
2014a1c: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2014a20: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2014a24: 02 80 00 11 be 2014a68 <read+0xa4> <== NOT EXECUTED
2014a28: 01 00 00 00 nop <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
2014a2c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
2014a30: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
2014a34: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2014a38: 02 80 00 12 be 2014a80 <read+0xbc> <== NOT EXECUTED
2014a3c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->read_h)( iop, buffer, count );
2014a40: 9f c0 40 00 call %g1 <== NOT EXECUTED
2014a44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( rc > 0 )
2014a48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2014a4c: 04 80 00 05 ble 2014a60 <read+0x9c> <== NOT EXECUTED
2014a50: 01 00 00 00 nop <== NOT EXECUTED
iop->offset += rc;
2014a54: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2014a58: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED
2014a5c: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
return rc;
}
2014a60: 81 c7 e0 08 ret <== NOT EXECUTED
2014a64: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
2014a68: 7f ff e0 f7 call 200ce44 <__errno> <== NOT EXECUTED
2014a6c: 01 00 00 00 nop <== NOT EXECUTED
2014a70: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
2014a74: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014a78: 10 bf ff fa b 2014a60 <read+0x9c> <== NOT EXECUTED
2014a7c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2014a80: 7f ff e0 f1 call 200ce44 <__errno> <== NOT EXECUTED
2014a84: 01 00 00 00 nop <== NOT EXECUTED
2014a88: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
2014a8c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014a90: 10 bf ff f4 b 2014a60 <read+0x9c> <== NOT EXECUTED
2014a94: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
2014a98: 7f ff e0 eb call 200ce44 <__errno> <== NOT EXECUTED
2014a9c: 01 00 00 00 nop <== NOT EXECUTED
2014aa0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2014aa4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014aa8: 10 bf ff ee b 2014a60 <read+0x9c> <== NOT EXECUTED
2014aac: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02014b34 <realloc>:
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
2014b34: 9d e3 bf 90 save %sp, -112, %sp
2014b38: 03 00 80 5c sethi %hi(0x2017000), %g1
2014b3c: a2 10 62 70 or %g1, 0x270, %l1 ! 2017270 <rtems_malloc_statistics>
2014b40: c4 04 60 10 ld [ %l1 + 0x10 ], %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
2014b44: 03 00 80 5d sethi %hi(0x2017400), %g1
2014b48: c6 00 61 84 ld [ %g1 + 0x184 ], %g3 ! 2017584 <_System_state_Current>
{
size_t old_size;
char *new_area;
size_t resize;
MSBUMP(realloc_calls, 1);
2014b4c: 84 00 a0 01 inc %g2
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
2014b50: 80 a0 e0 03 cmp %g3, 3
2014b54: 02 80 00 3b be 2014c40 <realloc+0x10c> <== ALWAYS TAKEN
2014b58: c4 24 60 10 st %g2, [ %l1 + 0x10 ]
}
/*
* Continue with realloc().
*/
if ( !ptr )
2014b5c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2014b60: 02 80 00 13 be 2014bac <realloc+0x78> <== NEVER TAKEN
2014b64: 80 a6 60 00 cmp %i1, 0
return malloc( size );
if ( !size ) {
2014b68: 02 80 00 2b be 2014c14 <realloc+0xe0> <== NEVER TAKEN
2014b6c: 21 00 80 5c sethi %hi(0x2017000), %l0
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
2014b70: 92 10 00 18 mov %i0, %o1
2014b74: 90 14 22 18 or %l0, 0x218, %o0
2014b78: 40 00 00 78 call 2014d58 <_Protected_heap_Get_block_size>
2014b7c: 94 07 bf f4 add %fp, -12, %o2
2014b80: 80 8a 20 ff btst 0xff, %o0
2014b84: 02 80 00 29 be 2014c28 <realloc+0xf4>
2014b88: 90 14 22 18 or %l0, 0x218, %o0
#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 ) ) {
2014b8c: 92 10 00 18 mov %i0, %o1
2014b90: 40 00 00 7f call 2014d8c <_Protected_heap_Resize_block>
2014b94: 94 10 00 19 mov %i1, %o2
2014b98: 80 8a 20 ff btst 0xff, %o0
2014b9c: 02 80 00 08 be 2014bbc <realloc+0x88>
2014ba0: 01 00 00 00 nop
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
2014ba4: 81 c7 e0 08 ret
2014ba8: 81 e8 00 00 restore
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
2014bac: 7f ff d8 c8 call 200aecc <malloc> <== NOT EXECUTED
2014bb0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2014bb4: 81 c7 e0 08 ret <== NOT EXECUTED
2014bb8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
2014bbc: 7f ff d8 c4 call 200aecc <malloc>
2014bc0: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
2014bc4: c2 04 60 04 ld [ %l1 + 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 );
2014bc8: a0 10 00 08 mov %o0, %l0
MSBUMP(malloc_calls, -1); /* subtract off the malloc */
2014bcc: 82 00 7f ff add %g1, -1, %g1
if ( !new_area ) {
2014bd0: 80 a2 20 00 cmp %o0, 0
2014bd4: 02 80 00 24 be 2014c64 <realloc+0x130> <== NEVER TAKEN
2014bd8: c2 24 60 04 st %g1, [ %l1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
2014bdc: c2 07 bf f4 ld [ %fp + -12 ], %g1
2014be0: 80 a6 40 01 cmp %i1, %g1
2014be4: 08 80 00 03 bleu 2014bf0 <realloc+0xbc> <== NEVER TAKEN
2014be8: 90 10 00 19 mov %i1, %o0
2014bec: 90 10 00 01 mov %g1, %o0
2014bf0: 94 10 00 08 mov %o0, %o2
2014bf4: 92 10 00 18 mov %i0, %o1
2014bf8: 7f ff e2 85 call 200d60c <memcpy>
2014bfc: 90 10 00 10 mov %l0, %o0
free( ptr );
2014c00: 90 10 00 18 mov %i0, %o0
2014c04: 7f ff d7 3b call 200a8f0 <free>
2014c08: b0 10 00 10 mov %l0, %i0
2014c0c: 81 c7 e0 08 ret
2014c10: 81 e8 00 00 restore
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
2014c14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2014c18: 7f ff d7 36 call 200a8f0 <free> <== NOT EXECUTED
2014c1c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2014c20: 81 c7 e0 08 ret <== NOT EXECUTED
2014c24: 81 e8 00 00 restore <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
2014c28: 7f ff e0 87 call 200ce44 <__errno>
2014c2c: b0 10 20 00 clr %i0
2014c30: 82 10 20 16 mov 0x16, %g1
2014c34: c2 22 00 00 st %g1, [ %o0 ]
2014c38: 81 c7 e0 08 ret
2014c3c: 81 e8 00 00 restore
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
2014c40: 03 00 80 5c sethi %hi(0x2017000), %g1
2014c44: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20173e0 <_Thread_Dispatch_disable_level>
2014c48: 80 a0 a0 00 cmp %g2, 0
2014c4c: 12 80 00 06 bne 2014c64 <realloc+0x130> <== NEVER TAKEN
2014c50: 03 00 80 5d sethi %hi(0x2017400), %g1
return (void *) 0;
if (_ISR_Nest_level > 0)
2014c54: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2017480 <_ISR_Nest_level>
2014c58: 80 a0 a0 00 cmp %g2, 0
2014c5c: 02 bf ff c1 be 2014b60 <realloc+0x2c> <== ALWAYS TAKEN
2014c60: 80 a6 20 00 cmp %i0, 0
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
2014c64: 81 c7 e0 08 ret <== NOT EXECUTED
2014c68: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200c740 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
200c740: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
200c744: 90 10 00 18 mov %i0, %o0
200c748: 92 10 00 19 mov %i1, %o1
200c74c: 40 00 00 07 call 200c768 <rtems_assoc_ptr_by_remote>
200c750: b0 10 20 00 clr %i0
if (nap)
200c754: 80 a2 20 00 cmp %o0, 0
200c758: 32 80 00 02 bne,a 200c760 <rtems_assoc_local_by_remote+0x20><== ALWAYS TAKEN
200c75c: f0 02 20 04 ld [ %o0 + 4 ], %i0
return nap->local_value;
return 0;
}
200c760: 81 c7 e0 08 ret
200c764: 81 e8 00 00 restore
0200c6e8 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
200c6e8: 9d e3 bf 98 save %sp, -104, %sp
200c6ec: a2 10 20 01 mov 1, %l1
200c6f0: a4 10 00 18 mov %i0, %l2
200c6f4: a0 10 20 00 clr %l0
200c6f8: 10 80 00 05 b 200c70c <rtems_assoc_local_by_remote_bitfield+0x24>
200c6fc: b0 10 20 00 clr %i0
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
200c700: 80 a4 20 20 cmp %l0, 0x20
200c704: 02 80 00 0d be 200c738 <rtems_assoc_local_by_remote_bitfield+0x50>
200c708: a3 2c 60 01 sll %l1, 1, %l1
if (b & remote_value)
200c70c: 80 8c 40 19 btst %l1, %i1
200c710: 22 bf ff fc be,a 200c700 <rtems_assoc_local_by_remote_bitfield+0x18><== ALWAYS TAKEN
200c714: a0 04 20 01 inc %l0
local_value |= rtems_assoc_local_by_remote(ap, b);
200c718: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
200c71c: 40 00 00 09 call 200c740 <rtems_assoc_local_by_remote> <== NOT EXECUTED
200c720: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
200c724: a0 04 20 01 inc %l0 <== NOT EXECUTED
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
200c728: b0 16 00 08 or %i0, %o0, %i0 <== NOT EXECUTED
)
{
uint32_t b;
uint32_t local_value = 0;
for (b = 1; b; b <<= 1) {
200c72c: 80 a4 20 20 cmp %l0, 0x20 <== NOT EXECUTED
200c730: 12 bf ff f7 bne 200c70c <rtems_assoc_local_by_remote_bitfield+0x24><== NOT EXECUTED
200c734: a3 2c 60 01 sll %l1, 1, %l1 <== NOT EXECUTED
if (b & remote_value)
local_value |= rtems_assoc_local_by_remote(ap, b);
}
return local_value;
}
200c738: 81 c7 e0 08 ret
200c73c: 81 e8 00 00 restore
0200e6c0 <rtems_assoc_name_bad>:
const char *
rtems_assoc_name_bad(
uint32_t bad_value
)
{
200e6c0: 11 00 80 6c sethi %hi(0x201b000), %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;
}
200e6c4: 81 c3 e0 08 retl <== NOT EXECUTED
200e6c8: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 201b1e0 <bad_buffer.5019><== NOT EXECUTED
0200c5e0 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
200c5e0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
200c5e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200c5e8: 40 00 00 0b call 200c614 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
200c5ec: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (nap)
200c5f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200c5f4: 02 80 00 05 be 200c608 <rtems_assoc_name_by_local+0x28> <== NOT EXECUTED
200c5f8: 01 00 00 00 nop <== NOT EXECUTED
return nap->name;
return rtems_assoc_name_bad(local_value);
}
200c5fc: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
200c600: 81 c7 e0 08 ret <== NOT EXECUTED
200c604: 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);
200c608: 40 00 08 2e call 200e6c0 <rtems_assoc_name_bad> <== NOT EXECUTED
200c60c: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
0200cd94 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
200cd94: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200cd98: d0 06 00 00 ld [ %i0 ], %o0
200cd9c: 80 a2 20 00 cmp %o0, 0
200cda0: 02 80 00 1d be 200ce14 <rtems_assoc_ptr_by_local+0x80> <== NEVER TAKEN
200cda4: 13 00 80 57 sethi %hi(0x2015c00), %o1
200cda8: 40 00 04 f7 call 200e184 <strcmp>
200cdac: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 2015ea0 <__func__.5598+0x18>
200cdb0: 80 a2 20 00 cmp %o0, 0
200cdb4: 02 80 00 11 be 200cdf8 <rtems_assoc_ptr_by_local+0x64> <== NEVER TAKEN
200cdb8: 86 10 20 00 clr %g3
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->local_value == local_value)
200cdbc: c2 06 20 04 ld [ %i0 + 4 ], %g1
200cdc0: 80 a0 40 19 cmp %g1, %i1
200cdc4: 32 80 00 07 bne,a 200cde0 <rtems_assoc_ptr_by_local+0x4c>
200cdc8: b0 06 20 0c add %i0, 0xc, %i0
200cdcc: 30 80 00 14 b,a 200ce1c <rtems_assoc_ptr_by_local+0x88>
200cdd0: 80 a0 40 19 cmp %g1, %i1
200cdd4: 02 80 00 12 be 200ce1c <rtems_assoc_ptr_by_local+0x88>
200cdd8: 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++)
200cddc: b0 06 20 0c add %i0, 0xc, %i0
200cde0: c2 06 00 00 ld [ %i0 ], %g1
200cde4: 80 a0 60 00 cmp %g1, 0
200cde8: 32 bf ff fa bne,a 200cdd0 <rtems_assoc_ptr_by_local+0x3c>
200cdec: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (ap->local_value == local_value)
return ap;
return default_ap;
}
200cdf0: 81 c7 e0 08 ret
200cdf4: 91 e8 00 03 restore %g0, %g3, %o0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
200cdf8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200cdfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200ce00: 02 80 00 07 be 200ce1c <rtems_assoc_ptr_by_local+0x88> <== NOT EXECUTED
200ce04: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED
200ce08: 86 10 00 18 mov %i0, %g3 <== NOT EXECUTED
200ce0c: 10 bf ff ec b 200cdbc <rtems_assoc_ptr_by_local+0x28> <== NOT EXECUTED
200ce10: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
uint32_t local_value
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200ce14: 81 c7 e0 08 ret <== NOT EXECUTED
200ce18: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
200ce1c: 81 c7 e0 08 ret
200ce20: 81 e8 00 00 restore
0200c768 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
200c768: 9d e3 bf 98 save %sp, -104, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200c76c: d0 06 00 00 ld [ %i0 ], %o0
200c770: 80 a2 20 00 cmp %o0, 0
200c774: 02 80 00 1d be 200c7e8 <rtems_assoc_ptr_by_remote+0x80> <== NEVER TAKEN
200c778: 13 00 80 57 sethi %hi(0x2015c00), %o1
200c77c: 40 00 06 82 call 200e184 <strcmp>
200c780: 92 12 62 a0 or %o1, 0x2a0, %o1 ! 2015ea0 <__func__.5598+0x18>
200c784: 80 a2 20 00 cmp %o0, 0
200c788: 02 80 00 11 be 200c7cc <rtems_assoc_ptr_by_remote+0x64> <== NEVER TAKEN
200c78c: 86 10 20 00 clr %g3
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
200c790: c2 06 20 08 ld [ %i0 + 8 ], %g1
200c794: 80 a0 40 19 cmp %g1, %i1
200c798: 32 80 00 07 bne,a 200c7b4 <rtems_assoc_ptr_by_remote+0x4c>
200c79c: b0 06 20 0c add %i0, 0xc, %i0
200c7a0: 30 80 00 14 b,a 200c7f0 <rtems_assoc_ptr_by_remote+0x88>
200c7a4: 80 a0 40 19 cmp %g1, %i1
200c7a8: 02 80 00 12 be 200c7f0 <rtems_assoc_ptr_by_remote+0x88> <== ALWAYS TAKEN
200c7ac: 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++)
200c7b0: b0 06 20 0c add %i0, 0xc, %i0 <== NOT EXECUTED
200c7b4: c2 06 00 00 ld [ %i0 ], %g1
200c7b8: 80 a0 60 00 cmp %g1, 0
200c7bc: 32 bf ff fa bne,a 200c7a4 <rtems_assoc_ptr_by_remote+0x3c><== ALWAYS TAKEN
200c7c0: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
200c7c4: 81 c7 e0 08 ret <== NOT EXECUTED
200c7c8: 91 e8 00 03 restore %g0, %g3, %o0 <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
200c7cc: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200c7d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200c7d4: 02 80 00 07 be 200c7f0 <rtems_assoc_ptr_by_remote+0x88> <== NOT EXECUTED
200c7d8: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED
200c7dc: 86 10 00 18 mov %i0, %g3 <== NOT EXECUTED
200c7e0: 10 bf ff ec b 200c790 <rtems_assoc_ptr_by_remote+0x28> <== NOT EXECUTED
200c7e4: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
uint32_t remote_value
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
200c7e8: 81 c7 e0 08 ret <== NOT EXECUTED
200c7ec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
200c7f0: 81 c7 e0 08 ret
200c7f4: 81 e8 00 00 restore
0200c7f8 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
200c7f8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
200c7fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200c800: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200c804: 40 00 01 64 call 200cd94 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
200c808: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (nap)
200c80c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200c810: 32 80 00 02 bne,a 200c818 <rtems_assoc_remote_by_local+0x20><== NOT EXECUTED
200c814: f0 02 20 08 ld [ %o0 + 8 ], %i0 <== NOT EXECUTED
return nap->remote_value;
return 0;
}
200c818: 81 c7 e0 08 ret <== NOT EXECUTED
200c81c: 81 e8 00 00 restore <== NOT EXECUTED
02005d1c <rtems_barrier_create>:
rtems_name name,
rtems_attribute attribute_set,
uint32_t maximum_waiters,
rtems_id *id
)
{
2005d1c: 9d e3 bf 90 save %sp, -112, %sp
Barrier_Control *the_barrier;
CORE_barrier_Attributes the_attributes;
if ( !rtems_is_name_valid( name ) )
2005d20: a2 96 20 00 orcc %i0, 0, %l1
2005d24: 02 80 00 25 be 2005db8 <rtems_barrier_create+0x9c> <== NEVER TAKEN
2005d28: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
2005d2c: 80 a6 e0 00 cmp %i3, 0
2005d30: 02 80 00 22 be 2005db8 <rtems_barrier_create+0x9c> <== NEVER TAKEN
2005d34: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
2005d38: 80 8e 60 10 btst 0x10, %i1
2005d3c: 02 80 00 21 be 2005dc0 <rtems_barrier_create+0xa4>
2005d40: 80 a6 a0 00 cmp %i2, 0
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
2005d44: 02 80 00 1d be 2005db8 <rtems_barrier_create+0x9c>
2005d48: b0 10 20 0a mov 0xa, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
2005d4c: 05 00 80 6c sethi %hi(0x201b000), %g2
2005d50: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1 ! 201b0b0 <_Thread_Dispatch_disable_level>
if ( !id )
return RTEMS_INVALID_ADDRESS;
/* Initialize core barrier attributes */
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
2005d54: c0 27 bf f0 clr [ %fp + -16 ]
2005d58: 82 00 60 01 inc %g1
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
the_attributes.maximum_count = maximum_waiters;
2005d5c: f4 27 bf f4 st %i2, [ %fp + -12 ]
2005d60: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ]
* 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 );
2005d64: 21 00 80 6b sethi %hi(0x201ac00), %l0
2005d68: 40 00 07 ed call 2007d1c <_Objects_Allocate>
2005d6c: 90 14 23 3c or %l0, 0x33c, %o0 ! 201af3c <_Barrier_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
2005d70: b4 92 20 00 orcc %o0, 0, %i2
2005d74: 02 80 00 20 be 2005df4 <rtems_barrier_create+0xd8> <== NEVER TAKEN
2005d78: 90 06 a0 14 add %i2, 0x14, %o0
return RTEMS_TOO_MANY;
}
the_barrier->attribute_set = attribute_set;
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
2005d7c: 92 07 bf f0 add %fp, -16, %o1
2005d80: 40 00 05 8e call 20073b8 <_CORE_barrier_Initialize>
2005d84: f2 26 a0 10 st %i1, [ %i2 + 0x10 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2005d88: c4 06 a0 08 ld [ %i2 + 8 ], %g2
2005d8c: 82 14 23 3c or %l0, 0x33c, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2005d90: e2 26 a0 0c st %l1, [ %i2 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2005d94: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Barrier_Information,
&the_barrier->Object,
(Objects_Name) name
);
*id = the_barrier->Object.id;
2005d98: c4 26 c0 00 st %g2, [ %i3 ]
2005d9c: 03 00 00 3f sethi %hi(0xfc00), %g1
2005da0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2005da4: 84 08 80 01 and %g2, %g1, %g2
2005da8: 85 28 a0 02 sll %g2, 2, %g2
_Thread_Enable_dispatch();
2005dac: b0 10 20 00 clr %i0
2005db0: 40 00 0b c6 call 2008cc8 <_Thread_Enable_dispatch>
2005db4: f4 20 c0 02 st %i2, [ %g3 + %g2 ]
return RTEMS_SUCCESSFUL;
}
2005db8: 81 c7 e0 08 ret
2005dbc: 81 e8 00 00 restore
if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
if ( maximum_waiters == 0 )
return RTEMS_INVALID_NUMBER;
} else
the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
2005dc0: 82 10 20 01 mov 1, %g1
2005dc4: 05 00 80 6c sethi %hi(0x201b000), %g2
2005dc8: c2 27 bf f0 st %g1, [ %fp + -16 ]
2005dcc: c2 00 a0 b0 ld [ %g2 + 0xb0 ], %g1
the_attributes.maximum_count = maximum_waiters;
2005dd0: f4 27 bf f4 st %i2, [ %fp + -12 ]
2005dd4: 82 00 60 01 inc %g1
2005dd8: c2 20 a0 b0 st %g1, [ %g2 + 0xb0 ]
2005ddc: 21 00 80 6b sethi %hi(0x201ac00), %l0
2005de0: 40 00 07 cf call 2007d1c <_Objects_Allocate>
2005de4: 90 14 23 3c or %l0, 0x33c, %o0 ! 201af3c <_Barrier_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _Barrier_Allocate();
if ( !the_barrier ) {
2005de8: b4 92 20 00 orcc %o0, 0, %i2
2005dec: 12 bf ff e4 bne 2005d7c <rtems_barrier_create+0x60>
2005df0: 90 06 a0 14 add %i2, 0x14, %o0
_Thread_Enable_dispatch();
2005df4: 40 00 0b b5 call 2008cc8 <_Thread_Enable_dispatch>
2005df8: b0 10 20 05 mov 5, %i0
2005dfc: 81 c7 e0 08 ret
2005e00: 81 e8 00 00 restore
02005ea4 <rtems_barrier_release>:
rtems_status_code rtems_barrier_release(
rtems_id id,
uint32_t *released
)
{
2005ea4: 9d e3 bf 90 save %sp, -112, %sp
2005ea8: a0 10 00 18 mov %i0, %l0
Barrier_Control *the_barrier;
Objects_Locations location;
if ( !released )
2005eac: 80 a6 60 00 cmp %i1, 0
2005eb0: 02 80 00 12 be 2005ef8 <rtems_barrier_release+0x54> <== NEVER TAKEN
2005eb4: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
2005eb8: 11 00 80 6b sethi %hi(0x201ac00), %o0
2005ebc: 92 10 00 10 mov %l0, %o1
2005ec0: 90 12 23 3c or %o0, 0x33c, %o0
2005ec4: 40 00 08 fe call 20082bc <_Objects_Get>
2005ec8: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_barrier = _Barrier_Get( id, &location );
switch ( location ) {
2005ecc: c2 07 bf f4 ld [ %fp + -12 ], %g1
2005ed0: 80 a0 60 00 cmp %g1, 0
2005ed4: 12 80 00 09 bne 2005ef8 <rtems_barrier_release+0x54>
2005ed8: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
2005edc: 92 10 00 10 mov %l0, %o1
2005ee0: 94 10 20 00 clr %o2
2005ee4: 40 00 05 41 call 20073e8 <_CORE_barrier_Release>
2005ee8: 90 02 20 14 add %o0, 0x14, %o0
_Thread_Enable_dispatch();
2005eec: b0 10 20 00 clr %i0
2005ef0: 40 00 0b 76 call 2008cc8 <_Thread_Enable_dispatch>
2005ef4: d0 26 40 00 st %o0, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2005ef8: 81 c7 e0 08 ret
2005efc: 81 e8 00 00 restore
02004ee8 <rtems_clock_get>:
rtems_status_code rtems_clock_get(
rtems_clock_get_options option,
void *time_buffer
)
{
2004ee8: 9d e3 bf 98 save %sp, -104, %sp
2004eec: 82 10 00 18 mov %i0, %g1
if ( !time_buffer )
2004ef0: 80 a6 60 00 cmp %i1, 0
2004ef4: 02 80 00 10 be 2004f34 <rtems_clock_get+0x4c> <== NEVER TAKEN
2004ef8: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
2004efc: 80 a0 60 04 cmp %g1, 4
2004f00: 18 80 00 0d bgu 2004f34 <rtems_clock_get+0x4c>
2004f04: b0 10 20 0a mov 0xa, %i0
2004f08: 83 28 60 02 sll %g1, 2, %g1
2004f0c: 05 00 80 13 sethi %hi(0x2004c00), %g2
2004f10: 84 10 a2 d4 or %g2, 0x2d4, %g2 ! 2004ed4 <rtems_termios_rxdaemon+0x90>
2004f14: c6 00 80 01 ld [ %g2 + %g1 ], %g3
2004f18: 81 c0 c0 00 jmp %g3
2004f1c: 01 00 00 00 nop
*interval = rtems_clock_get_ticks_per_second();
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TIME_VALUE:
return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
2004f20: 40 00 00 5a call 2005088 <rtems_clock_get_tod_timeval>
2004f24: 91 e8 00 19 restore %g0, %i1, %o0
return RTEMS_SUCCESSFUL;
}
case RTEMS_CLOCK_GET_TICKS_PER_SECOND: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_per_second();
2004f28: 40 00 00 1d call 2004f9c <rtems_clock_get_ticks_per_second>
2004f2c: b0 10 20 00 clr %i0
2004f30: d0 26 40 00 st %o0, [ %i1 ]
2004f34: 81 c7 e0 08 ret
2004f38: 81 e8 00 00 restore
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
rtems_interval *interval = (rtems_interval *)time_buffer;
*interval = rtems_clock_get_ticks_since_boot();
2004f3c: 40 00 00 20 call 2004fbc <rtems_clock_get_ticks_since_boot>
2004f40: b0 10 20 00 clr %i0
2004f44: d0 26 40 00 st %o0, [ %i1 ]
2004f48: 81 c7 e0 08 ret
2004f4c: 81 e8 00 00 restore
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
2004f50: 40 00 00 05 call 2004f64 <rtems_clock_get_seconds_since_epoch>
2004f54: 91 e8 00 19 restore %g0, %i1, %o0
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
switch ( option ) {
case RTEMS_CLOCK_GET_TOD:
return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
2004f58: 40 00 00 1d call 2004fcc <rtems_clock_get_tod>
2004f5c: 91 e8 00 19 restore %g0, %i1, %o0
02004f64 <rtems_clock_get_seconds_since_epoch>:
rtems_status_code rtems_clock_get_seconds_since_epoch(
rtems_interval *the_interval
)
{
if ( !the_interval )
2004f64: 86 92 20 00 orcc %o0, 0, %g3
2004f68: 02 80 00 0b be 2004f94 <rtems_clock_get_seconds_since_epoch+0x30><== NEVER TAKEN
2004f6c: 90 10 20 09 mov 9, %o0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
2004f70: 03 00 80 5c sethi %hi(0x2017000), %g1
2004f74: c4 08 63 f4 ldub [ %g1 + 0x3f4 ], %g2 ! 20173f4 <_TOD_Is_set>
2004f78: 80 a0 a0 00 cmp %g2, 0
2004f7c: 02 80 00 06 be 2004f94 <rtems_clock_get_seconds_since_epoch+0x30>
2004f80: 90 10 20 0b mov 0xb, %o0
return RTEMS_NOT_DEFINED;
*the_interval = _TOD_Seconds_since_epoch;
2004f84: 03 00 80 5d sethi %hi(0x2017400), %g1
2004f88: c4 00 60 74 ld [ %g1 + 0x74 ], %g2 ! 2017474 <_TOD_Now>
2004f8c: 90 10 20 00 clr %o0
2004f90: c4 20 c0 00 st %g2, [ %g3 ]
return RTEMS_SUCCESSFUL;
}
2004f94: 81 c3 e0 08 retl
02004fcc <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod(
rtems_time_of_day *time_buffer
)
{
2004fcc: 9d e3 bf 60 save %sp, -160, %sp
rtems_time_of_day *tmbuf = time_buffer;
struct tm time;
struct timeval now;
if ( !time_buffer )
2004fd0: a2 96 20 00 orcc %i0, 0, %l1
2004fd4: 02 80 00 2b be 2005080 <rtems_clock_get_tod+0xb4> <== NEVER TAKEN
2004fd8: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
2004fdc: 03 00 80 5c sethi %hi(0x2017000), %g1
2004fe0: c4 08 63 f4 ldub [ %g1 + 0x3f4 ], %g2 ! 20173f4 <_TOD_Is_set>
2004fe4: 80 a0 a0 00 cmp %g2, 0
2004fe8: 02 80 00 26 be 2005080 <rtems_clock_get_tod+0xb4>
2004fec: b0 10 20 0b mov 0xb, %i0
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
2004ff0: 7f ff f3 7d call 2001de4 <sparc_disable_interrupts>
2004ff4: 01 00 00 00 nop
2004ff8: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
2004ffc: 40 00 05 ed call 20067b0 <_TOD_Get>
2005000: 90 07 bf e8 add %fp, -24, %o0
_ISR_Enable(level);
2005004: 7f ff f3 7c call 2001df4 <sparc_enable_interrupts>
2005008: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
200500c: c2 07 bf e8 ld [ %fp + -24 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
2005010: d0 07 bf ec ld [ %fp + -20 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
2005014: c2 27 bf f0 st %g1, [ %fp + -16 ]
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
2005018: 40 00 3a 56 call 2013970 <.udiv>
200501c: 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 );
2005020: 92 07 bf c4 add %fp, -60, %o1
2005024: d0 27 bf f4 st %o0, [ %fp + -12 ]
2005028: 40 00 21 74 call 200d5f8 <gmtime_r>
200502c: 90 07 bf f0 add %fp, -16, %o0
/* Now adjust it to the RTEMS format */
tmbuf->year = time.tm_year + 1900;
tmbuf->month = time.tm_mon + 1;
tmbuf->day = time.tm_mday;
2005030: c4 07 bf d0 ld [ %fp + -48 ], %g2
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick;
2005034: 03 00 80 5d sethi %hi(0x2017400), %g1
2005038: d0 07 bf f4 ld [ %fp + -12 ], %o0
200503c: d2 00 61 80 ld [ %g1 + 0x180 ], %o1
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;
2005040: c4 24 60 08 st %g2, [ %l1 + 8 ]
tmbuf->hour = time.tm_hour;
2005044: c2 07 bf cc ld [ %fp + -52 ], %g1
tmbuf->minute = time.tm_min;
2005048: c4 07 bf c8 ld [ %fp + -56 ], %g2
/* 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;
200504c: c2 24 60 0c st %g1, [ %l1 + 0xc ]
tmbuf->minute = time.tm_min;
2005050: c4 24 60 10 st %g2, [ %l1 + 0x10 ]
/* 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;
2005054: c2 07 bf d8 ld [ %fp + -40 ], %g1
tmbuf->month = time.tm_mon + 1;
2005058: c4 07 bf d4 ld [ %fp + -44 ], %g2
tmbuf->day = time.tm_mday;
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
200505c: c6 07 bf c4 ld [ %fp + -60 ], %g3
/* 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;
2005060: 82 00 67 6c add %g1, 0x76c, %g1
tmbuf->month = time.tm_mon + 1;
2005064: 84 00 a0 01 inc %g2
tmbuf->day = time.tm_mday;
tmbuf->hour = time.tm_hour;
tmbuf->minute = time.tm_min;
tmbuf->second = time.tm_sec;
2005068: c6 24 60 14 st %g3, [ %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;
200506c: c2 24 40 00 st %g1, [ %l1 ]
tmbuf->month = time.tm_mon + 1;
2005070: c4 24 60 04 st %g2, [ %l1 + 4 ]
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;
2005074: 40 00 3a 3f call 2013970 <.udiv>
2005078: b0 10 20 00 clr %i0
200507c: d0 24 60 18 st %o0, [ %l1 + 0x18 ]
return RTEMS_SUCCESSFUL;
}
2005080: 81 c7 e0 08 ret
2005084: 81 e8 00 00 restore
02005088 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>
rtems_status_code rtems_clock_get_tod_timeval(
struct timeval *time
)
{
2005088: 9d e3 bf 90 save %sp, -112, %sp
if ( !time )
200508c: a2 96 20 00 orcc %i0, 0, %l1
2005090: 02 80 00 15 be 20050e4 <rtems_clock_get_tod_timeval+0x5c> <== NEVER TAKEN
2005094: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Is_set )
2005098: 03 00 80 5c sethi %hi(0x2017000), %g1
200509c: c4 08 63 f4 ldub [ %g1 + 0x3f4 ], %g2 ! 20173f4 <_TOD_Is_set>
20050a0: 80 a0 a0 00 cmp %g2, 0
20050a4: 02 80 00 10 be 20050e4 <rtems_clock_get_tod_timeval+0x5c>
20050a8: b0 10 20 0b mov 0xb, %i0
)
{
ISR_Level level;
struct timespec now;
_ISR_Disable(level);
20050ac: 7f ff f3 4e call 2001de4 <sparc_disable_interrupts>
20050b0: 01 00 00 00 nop
20050b4: a0 10 00 08 mov %o0, %l0
_TOD_Get( &now );
20050b8: 40 00 05 be call 20067b0 <_TOD_Get>
20050bc: 90 07 bf f0 add %fp, -16, %o0
_ISR_Enable(level);
20050c0: 7f ff f3 4d call 2001df4 <sparc_enable_interrupts>
20050c4: 90 10 00 10 mov %l0, %o0
time->tv_sec = now.tv_sec;
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
20050c8: d0 07 bf f4 ld [ %fp + -12 ], %o0
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
20050cc: c2 07 bf f0 ld [ %fp + -16 ], %g1
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
20050d0: 92 10 23 e8 mov 0x3e8, %o1
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
time->tv_sec = now.tv_sec;
20050d4: c2 24 40 00 st %g1, [ %l1 ]
time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
20050d8: 40 00 3a 26 call 2013970 <.udiv>
20050dc: b0 10 20 00 clr %i0
20050e0: d0 24 60 04 st %o0, [ %l1 + 4 ]
return RTEMS_NOT_DEFINED;
_TOD_Get_timeval( time );
return RTEMS_SUCCESSFUL;
}
20050e4: 81 c7 e0 08 ret
20050e8: 81 e8 00 00 restore
02005304 <rtems_clock_get_uptime>:
* error code - if unsuccessful
*/
rtems_status_code rtems_clock_get_uptime(
struct timespec *uptime
)
{
2005304: 9d e3 bf 98 save %sp, -104, %sp
if ( !uptime )
2005308: 90 96 20 00 orcc %i0, 0, %o0
200530c: 02 80 00 04 be 200531c <rtems_clock_get_uptime+0x18> <== NEVER TAKEN
2005310: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
_TOD_Get_uptime( uptime );
2005314: 40 00 06 46 call 2006c2c <_TOD_Get_uptime>
2005318: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
200531c: 81 c7 e0 08 ret
2005320: 81 e8 00 00 restore
020062d4 <rtems_clock_set>:
*/
rtems_status_code rtems_clock_set(
rtems_time_of_day *time_buffer
)
{
20062d4: 9d e3 bf 90 save %sp, -112, %sp
struct timespec newtime;
if ( !time_buffer )
20062d8: a0 96 20 00 orcc %i0, 0, %l0
20062dc: 02 80 00 08 be 20062fc <rtems_clock_set+0x28> <== NEVER TAKEN
20062e0: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
20062e4: 90 10 00 10 mov %l0, %o0
20062e8: 40 00 00 6b call 2006494 <_TOD_Validate>
20062ec: b0 10 20 14 mov 0x14, %i0
20062f0: 80 8a 20 ff btst 0xff, %o0
20062f4: 12 80 00 04 bne 2006304 <rtems_clock_set+0x30>
20062f8: 01 00 00 00 nop
_TOD_Set( &newtime );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
20062fc: 81 c7 e0 08 ret
2006300: 81 e8 00 00 restore
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
2006304: 40 00 00 2f call 20063c0 <_TOD_To_seconds>
2006308: 90 10 00 10 mov %l0, %o0
newtime.tv_nsec = time_buffer->ticks *
200630c: 03 00 80 8e sethi %hi(0x2023800), %g1
if ( !time_buffer )
return RTEMS_INVALID_ADDRESS;
if ( _TOD_Validate( time_buffer ) ) {
newtime.tv_sec = _TOD_To_seconds( time_buffer );
2006310: d0 27 bf f0 st %o0, [ %fp + -16 ]
newtime.tv_nsec = time_buffer->ticks *
2006314: d2 00 61 f0 ld [ %g1 + 0x1f0 ], %o1
2006318: 40 00 43 41 call 201701c <.umul>
200631c: d0 04 20 18 ld [ %l0 + 0x18 ], %o0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
2006320: 07 00 80 8e sethi %hi(0x2023800), %g3
2006324: c4 00 e0 50 ld [ %g3 + 0x50 ], %g2 ! 2023850 <_Thread_Dispatch_disable_level>
2006328: 89 2a 20 02 sll %o0, 2, %g4
200632c: 84 00 a0 01 inc %g2
2006330: 83 2a 20 07 sll %o0, 7, %g1
2006334: c4 20 e0 50 st %g2, [ %g3 + 0x50 ]
2006338: 82 20 40 04 sub %g1, %g4, %g1
200633c: 82 00 40 08 add %g1, %o0, %g1
2006340: 83 28 60 03 sll %g1, 3, %g1
2006344: c2 27 bf f4 st %g1, [ %fp + -12 ]
(_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND);
_Thread_Disable_dispatch();
_TOD_Set( &newtime );
2006348: 90 07 bf f0 add %fp, -16, %o0
200634c: 40 00 07 10 call 2007f8c <_TOD_Set>
2006350: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
2006354: 40 00 0c 45 call 2009468 <_Thread_Enable_dispatch>
2006358: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
return RTEMS_INVALID_CLOCK;
}
200635c: 81 c7 e0 08 ret
2006360: 81 e8 00 00 restore
020050ec <rtems_clock_set_nanoseconds_extension>:
*/
rtems_status_code rtems_clock_set_nanoseconds_extension(
rtems_nanoseconds_extension_routine routine
)
{
if ( !routine )
20050ec: 84 92 20 00 orcc %o0, 0, %g2
20050f0: 02 80 00 05 be 2005104 <rtems_clock_set_nanoseconds_extension+0x18><== NEVER TAKEN
20050f4: 90 10 20 09 mov 9, %o0
return RTEMS_INVALID_ADDRESS;
_Watchdog_Nanoseconds_since_tick_handler = routine;
20050f8: 03 00 80 5d sethi %hi(0x2017400), %g1
20050fc: 90 10 20 00 clr %o0
2005100: c4 20 61 88 st %g2, [ %g1 + 0x188 ]
return RTEMS_SUCCESSFUL;
}
2005104: 81 c3 e0 08 retl
02002a78 <rtems_cpu_usage_report_with_plugin>:
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2002a78: 9d e3 bf 60 save %sp, -160, %sp
struct timespec uptime, total, ran;
#else
uint32_t total_units = 0;
#endif
if ( !print )
2002a7c: 80 a6 60 00 cmp %i1, 0
2002a80: 02 80 00 6e be 2002c38 <rtems_cpu_usage_report_with_plugin+0x1c0><== NEVER TAKEN
2002a84: 01 00 00 00 nop
* 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 );
2002a88: 40 00 15 19 call 2007eec <_TOD_Get_uptime>
2002a8c: 90 07 bf e8 add %fp, -24, %o0
_Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
2002a90: 92 07 bf e8 add %fp, -24, %o1
2002a94: b4 07 bf e0 add %fp, -32, %i2
2002a98: 11 00 80 8e sethi %hi(0x2023800), %o0
2002a9c: 94 10 00 1a mov %i2, %o2
2002aa0: 40 00 1f ab call 200a94c <_Timespec_Subtract>
2002aa4: 90 12 23 0c or %o0, 0x30c, %o0
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
2002aa8: 90 10 00 18 mov %i0, %o0
2002aac: 13 00 80 64 sethi %hi(0x2019000), %o1
2002ab0: 9f c6 40 00 call %i1
2002ab4: 92 12 60 68 or %o1, 0x68, %o1 ! 2019068 <pollCallbacks.4767+0x310>
2002ab8: 03 00 80 8d sethi %hi(0x2023400), %g1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2002abc: 05 00 80 64 sethi %hi(0x2019000), %g2
}
}
}
#endif
(*print)( context, "CPU Usage by thread\n"
2002ac0: a6 10 63 b4 or %g1, 0x3b4, %l3
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2002ac4: b6 10 a0 b0 or %g2, 0xb0, %i3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2002ac8: 03 00 80 8e sethi %hi(0x2023800), %g1
/*
* Print the information
*/
(*print)( context,
2002acc: 05 00 80 64 sethi %hi(0x2019000), %g2
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2002ad0: a8 07 bf c0 add %fp, -64, %l4
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2002ad4: b8 10 61 14 or %g1, 0x114, %i4
/*
* Print the information
*/
(*print)( context,
2002ad8: ba 10 a0 c8 or %g2, 0xc8, %i5
2002adc: aa 07 bf d8 add %fp, -40, %l5
_Timespec_Subtract(
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
2002ae0: ae 07 bf f4 add %fp, -12, %l7
2002ae4: ac 07 bf f0 add %fp, -16, %l6
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
2002ae8: c2 04 c0 00 ld [ %l3 ], %g1
2002aec: 80 a0 60 00 cmp %g1, 0
2002af0: 22 80 00 44 be,a 2002c00 <rtems_cpu_usage_report_with_plugin+0x188>
2002af4: a6 04 e0 04 add %l3, 4, %l3
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
2002af8: e4 00 60 04 ld [ %g1 + 4 ], %l2
if ( information ) {
2002afc: 80 a4 a0 00 cmp %l2, 0
2002b00: 22 80 00 40 be,a 2002c00 <rtems_cpu_usage_report_with_plugin+0x188><== NEVER TAKEN
2002b04: a6 04 e0 04 add %l3, 4, %l3 <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
2002b08: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1
2002b0c: 86 90 60 00 orcc %g1, 0, %g3
2002b10: 02 80 00 3b be 2002bfc <rtems_cpu_usage_report_with_plugin+0x184><== NEVER TAKEN
2002b14: a2 10 20 01 mov 1, %l1
the_thread = (Thread_Control *)information->local_table[ i ];
2002b18: 10 80 00 17 b 2002b74 <rtems_cpu_usage_report_with_plugin+0xfc>
2002b1c: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2
_Timespec_Subtract(
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
};
_Timespec_Divide( &ran, &total, &ival, &fval );
2002b20: 96 10 00 16 mov %l6, %o3
2002b24: 90 10 00 15 mov %l5, %o0
2002b28: 40 00 1e f6 call 200a700 <_Timespec_Divide>
2002b2c: 92 10 00 1a mov %i2, %o1
/*
* Print the information
*/
(*print)( context,
2002b30: d0 07 bf dc ld [ %fp + -36 ], %o0
2002b34: 40 00 51 74 call 2017104 <.udiv>
2002b38: 92 10 23 e8 mov 0x3e8, %o1
2002b3c: d4 07 bf d8 ld [ %fp + -40 ], %o2
2002b40: d8 07 bf f4 ld [ %fp + -12 ], %o4
2002b44: da 07 bf f0 ld [ %fp + -16 ], %o5
2002b48: 96 10 00 08 mov %o0, %o3
2002b4c: 92 10 00 1d mov %i5, %o1
2002b50: 9f c6 40 00 call %i1
2002b54: 90 10 00 18 mov %i0, %o0
2002b58: c6 14 a0 10 lduh [ %l2 + 0x10 ], %g3
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++ ) {
2002b5c: 83 28 e0 10 sll %g3, 0x10, %g1
2002b60: 83 30 60 10 srl %g1, 0x10, %g1
2002b64: 80 a0 40 11 cmp %g1, %l1
2002b68: 2a 80 00 26 bcs,a 2002c00 <rtems_cpu_usage_report_with_plugin+0x188>
2002b6c: a6 04 e0 04 add %l3, 4, %l3
the_thread = (Thread_Control *)information->local_table[ i ];
2002b70: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2
2002b74: 83 2c 60 02 sll %l1, 2, %g1
2002b78: e0 00 80 01 ld [ %g2 + %g1 ], %l0
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2002b7c: 94 10 00 14 mov %l4, %o2
2002b80: 92 10 20 0d mov 0xd, %o1
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
if ( !the_thread )
2002b84: 80 a4 20 00 cmp %l0, 0
2002b88: 02 bf ff f5 be 2002b5c <rtems_cpu_usage_report_with_plugin+0xe4><== NEVER TAKEN
2002b8c: a2 04 60 01 inc %l1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2002b90: 40 00 0f 8f call 20069cc <rtems_object_get_name>
2002b94: d0 04 20 08 ld [ %l0 + 8 ], %o0
(*print)(
2002b98: d4 04 20 08 ld [ %l0 + 8 ], %o2
2002b9c: 90 10 00 18 mov %i0, %o0
2002ba0: 92 10 00 1b mov %i3, %o1
2002ba4: 9f c6 40 00 call %i1
2002ba8: 96 10 00 14 mov %l4, %o3
#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;
2002bac: c4 04 20 84 ld [ %l0 + 0x84 ], %g2
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2002bb0: c6 07 00 00 ld [ %i4 ], %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;
2002bb4: c4 27 bf d8 st %g2, [ %fp + -40 ]
2002bb8: c2 04 20 88 ld [ %l0 + 0x88 ], %g1
2002bbc: c2 27 bf dc st %g1, [ %fp + -36 ]
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2002bc0: c4 00 e0 08 ld [ %g3 + 8 ], %g2
2002bc4: c2 04 20 08 ld [ %l0 + 8 ], %g1
2002bc8: 80 a0 80 01 cmp %g2, %g1
2002bcc: 32 bf ff d5 bne,a 2002b20 <rtems_cpu_usage_report_with_plugin+0xa8>
2002bd0: 94 10 00 17 mov %l7, %o2
struct timespec used;
_Timespec_Subtract(
2002bd4: 92 07 bf e8 add %fp, -24, %o1
2002bd8: 94 07 bf d0 add %fp, -48, %o2
2002bdc: 11 00 80 8e sethi %hi(0x2023800), %o0
2002be0: 40 00 1f 5b call 200a94c <_Timespec_Subtract>
2002be4: 90 12 21 1c or %o0, 0x11c, %o0 ! 202391c <_Thread_Time_of_last_context_switch>
&_Thread_Time_of_last_context_switch, &uptime, &used
);
_Timespec_Add_to( &ran, &used );
2002be8: 90 10 00 15 mov %l5, %o0
2002bec: 40 00 1e ab call 200a698 <_Timespec_Add_to>
2002bf0: 92 07 bf d0 add %fp, -48, %o1
};
_Timespec_Divide( &ran, &total, &ival, &fval );
2002bf4: 10 bf ff cb b 2002b20 <rtems_cpu_usage_report_with_plugin+0xa8>
2002bf8: 94 10 00 17 mov %l7, %o2
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++ ) {
2002bfc: a6 04 e0 04 add %l3, 4, %l3 <== NOT EXECUTED
" ID NAME TICKS PERCENT\n"
#endif
);
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
2002c00: 03 00 80 8d sethi %hi(0x2023400), %g1
2002c04: 82 10 63 c4 or %g1, 0x3c4, %g1 ! 20237c4 <_Objects_Information_table+0x14>
2002c08: 80 a4 c0 01 cmp %l3, %g1
2002c0c: 32 bf ff b8 bne,a 2002aec <rtems_cpu_usage_report_with_plugin+0x74>
2002c10: c2 04 c0 00 ld [ %l3 ], %g1
}
}
}
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
(*print)( context, "Time since last CPU Usage reset %" PRId32
2002c14: d0 07 bf e4 ld [ %fp + -28 ], %o0
2002c18: 40 00 51 3b call 2017104 <.udiv>
2002c1c: 92 10 23 e8 mov 0x3e8, %o1
2002c20: d4 07 bf e0 ld [ %fp + -32 ], %o2
2002c24: 96 10 00 08 mov %o0, %o3
2002c28: 13 00 80 64 sethi %hi(0x2019000), %o1
2002c2c: 90 10 00 18 mov %i0, %o0
2002c30: 9f c6 40 00 call %i1
2002c34: 92 12 60 e0 or %o1, 0xe0, %o1
2002c38: 81 c7 e0 08 ret
2002c3c: 81 e8 00 00 restore
0200c348 <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
static int
rtems_deviceio_errno(rtems_status_code code)
{
200c348: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code)))
200c34c: 11 00 80 57 sethi %hi(0x2015c00), %o0 <== NOT EXECUTED
200c350: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
200c354: 40 00 01 29 call 200c7f8 <rtems_assoc_remote_by_local> <== NOT EXECUTED
200c358: 90 12 21 84 or %o0, 0x184, %o0 <== NOT EXECUTED
200c35c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
200c360: 02 80 00 05 be 200c374 <rtems_deviceio_errno+0x2c> <== NOT EXECUTED
200c364: 01 00 00 00 nop <== NOT EXECUTED
{
errno = rc;
200c368: 40 00 02 b7 call 200ce44 <__errno> <== NOT EXECUTED
200c36c: 01 00 00 00 nop <== NOT EXECUTED
200c370: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
return -1;
}
return -1;
}
200c374: 81 c7 e0 08 ret <== NOT EXECUTED
200c378: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02003078 <rtems_error>:
int rtems_error(
int error_flag,
const char *printf_format,
...
)
{
2003078: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
200307c: 94 07 a0 4c add %fp, 0x4c, %o2 <== NOT EXECUTED
2003080: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2003084: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2003088: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
200308c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
2003090: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2003094: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003098: 7f ff ff 71 call 2002e5c <rtems_verror> <== NOT EXECUTED
200309c: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
20030a0: 81 c7 e0 08 ret <== NOT EXECUTED
20030a4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02005168 <rtems_event_receive>:
rtems_event_set event_in,
rtems_option option_set,
rtems_interval ticks,
rtems_event_set *event_out
)
{
2005168: 9d e3 bf 98 save %sp, -104, %sp
200516c: 90 10 00 18 mov %i0, %o0
2005170: 96 10 00 1b mov %i3, %o3
2005174: 92 10 00 19 mov %i1, %o1
2005178: 94 10 00 1a mov %i2, %o2
RTEMS_API_Control *api;
if ( !event_out )
200517c: 80 a6 e0 00 cmp %i3, 0
2005180: 02 80 00 15 be 20051d4 <rtems_event_receive+0x6c> <== NEVER TAKEN
2005184: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
2005188: 37 00 80 5d sethi %hi(0x2017400), %i3
200518c: c2 06 e0 a4 ld [ %i3 + 0xa4 ], %g1 ! 20174a4 <_Thread_Executing>
if ( _Event_sets_Is_empty( event_in ) ) {
2005190: 80 a2 20 00 cmp %o0, 0
2005194: 12 80 00 06 bne 20051ac <rtems_event_receive+0x44>
2005198: c2 00 61 68 ld [ %g1 + 0x168 ], %g1
*event_out = api->pending_events;
200519c: c2 00 40 00 ld [ %g1 ], %g1
20051a0: c2 22 c0 00 st %g1, [ %o3 ]
20051a4: 81 c7 e0 08 ret
20051a8: 91 e8 20 00 restore %g0, 0, %o0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
20051ac: 03 00 80 5c sethi %hi(0x2017000), %g1
20051b0: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 20173e0 <_Thread_Dispatch_disable_level>
20051b4: 84 00 a0 01 inc %g2
20051b8: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ]
return RTEMS_SUCCESSFUL;
}
_Thread_Disable_dispatch();
_Event_Seize( event_in, option_set, ticks, event_out );
20051bc: 40 00 00 08 call 20051dc <_Event_Seize>
20051c0: 01 00 00 00 nop
_Thread_Enable_dispatch();
20051c4: 40 00 0a 6d call 2007b78 <_Thread_Enable_dispatch>
20051c8: 01 00 00 00 nop
return( _Thread_Executing->Wait.return_code );
20051cc: c2 06 e0 a4 ld [ %i3 + 0xa4 ], %g1
20051d0: f0 00 60 34 ld [ %g1 + 0x34 ], %i0
}
20051d4: 81 c7 e0 08 ret
20051d8: 81 e8 00 00 restore
02001fa0 <rtems_filesystem_evaluate_parent>:
int rtems_filesystem_evaluate_parent(
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
2001fa0: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
2001fa4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2001fa8: 02 80 00 28 be 2002048 <rtems_filesystem_evaluate_parent+0xa8><== NOT EXECUTED
2001fac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
if ( !pathloc->ops->evalpath_h )
2001fb0: c8 06 60 08 ld [ %i1 + 8 ], %g4 <== NOT EXECUTED
2001fb4: da 01 00 00 ld [ %g4 ], %o5 <== NOT EXECUTED
2001fb8: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
2001fbc: 02 80 00 1d be 2002030 <rtems_filesystem_evaluate_parent+0x90><== NOT EXECUTED
2001fc0: 11 00 80 56 sethi %hi(0x2015800), %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
parent = *pathloc;
2001fc4: c6 06 60 0c ld [ %i1 + 0xc ], %g3 <== NOT EXECUTED
2001fc8: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
2001fcc: c4 06 60 04 ld [ %i1 + 4 ], %g2 <== NOT EXECUTED
2001fd0: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED
2001fd4: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
2001fd8: c8 27 bf f0 st %g4, [ %fp + -16 ] <== NOT EXECUTED
2001fdc: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
2001fe0: b2 07 bf e8 add %fp, -24, %i1 <== NOT EXECUTED
2001fe4: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
2001fe8: 9f c3 40 00 call %o5 <== NOT EXECUTED
2001fec: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
if (result != 0){
2001ff0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2001ff4: 12 80 00 0d bne 2002028 <rtems_filesystem_evaluate_parent+0x88><== NOT EXECUTED
2001ff8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
return -1;
}
rtems_filesystem_freenode( &parent );
2001ffc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002000: 02 80 00 16 be 2002058 <rtems_filesystem_evaluate_parent+0xb8><== NOT EXECUTED
2002004: 01 00 00 00 nop <== NOT EXECUTED
2002008: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
200200c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002010: 02 80 00 12 be 2002058 <rtems_filesystem_evaluate_parent+0xb8><== NOT EXECUTED
2002014: 01 00 00 00 nop <== NOT EXECUTED
2002018: 9f c0 40 00 call %g1 <== NOT EXECUTED
200201c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
return result;
}
2002020: 81 c7 e0 08 ret <== NOT EXECUTED
2002024: 81 e8 00 00 restore <== NOT EXECUTED
if ( !pathloc->ops->evalpath_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
parent = *pathloc;
result = (*pathloc->ops->evalpath_h)( "..", flags, &parent );
if (result != 0){
2002028: 81 c7 e0 08 ret <== NOT EXECUTED
200202c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
if ( !pathloc->ops->evalpath_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2002030: 40 00 2b 85 call 200ce44 <__errno> <== NOT EXECUTED
2002034: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2002038: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
200203c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2002040: 81 c7 e0 08 ret <== NOT EXECUTED
2002044: 81 e8 00 00 restore <== NOT EXECUTED
{
rtems_filesystem_location_info_t parent;
int result;
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
2002048: 40 00 2b 7f call 200ce44 <__errno> <== NOT EXECUTED
200204c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2002050: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2002054: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2002058: 81 c7 e0 08 ret <== NOT EXECUTED
200205c: 81 e8 00 00 restore <== NOT EXECUTED
02002060 <rtems_filesystem_evaluate_path>:
const char *pathname,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
2002060: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify Input parameters.
*/
if ( !pathname )
2002064: 80 a6 20 00 cmp %i0, 0
2002068: 02 80 00 50 be 20021a8 <rtems_filesystem_evaluate_path+0x148><== NEVER TAKEN
200206c: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
2002070: 02 80 00 54 be 20021c0 <rtems_filesystem_evaluate_path+0x160><== NEVER TAKEN
2002074: 01 00 00 00 nop
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
2002078: c2 4e 00 00 ldsb [ %i0 ], %g1
200207c: 80 a0 60 2f cmp %g1, 0x2f
2002080: 02 80 00 06 be 2002098 <rtems_filesystem_evaluate_path+0x38><== ALWAYS TAKEN
2002084: 80 a0 60 5c cmp %g1, 0x5c
2002088: 02 80 00 04 be 2002098 <rtems_filesystem_evaluate_path+0x38><== NOT EXECUTED
200208c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002090: 12 80 00 27 bne 200212c <rtems_filesystem_evaluate_path+0xcc><== NOT EXECUTED
2002094: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
2002098: 03 00 80 5a sethi %hi(0x2016800), %g1
200209c: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 ! 2016aa4 <rtems_current_user_env>
20020a0: 88 10 20 01 mov 1, %g4
20020a4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1
20020a8: c2 26 80 00 st %g1, [ %i2 ]
20020ac: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2
20020b0: c4 26 a0 04 st %g2, [ %i2 + 4 ]
20020b4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1
20020b8: c2 26 a0 08 st %g1, [ %i2 + 8 ]
20020bc: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2
20020c0: c4 26 a0 0c st %g2, [ %i2 + 0xc ]
if ( !pathloc->ops->evalpath_h )
20020c4: c2 06 a0 08 ld [ %i2 + 8 ], %g1
20020c8: c2 00 40 00 ld [ %g1 ], %g1
20020cc: 80 a0 60 00 cmp %g1, 0
20020d0: 02 80 00 30 be 2002190 <rtems_filesystem_evaluate_path+0x130><== NEVER TAKEN
20020d4: 90 06 00 04 add %i0, %g4, %o0
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc );
20020d8: 92 10 00 19 mov %i1, %o1
20020dc: 9f c0 40 00 call %g1
20020e0: 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 ) {
20020e4: b0 92 20 00 orcc %o0, 0, %i0
20020e8: 12 80 00 0f bne 2002124 <rtems_filesystem_evaluate_path+0xc4><== NEVER TAKEN
20020ec: 80 a6 e0 00 cmp %i3, 0
20020f0: 02 80 00 38 be 20021d0 <rtems_filesystem_evaluate_path+0x170>
20020f4: 01 00 00 00 nop
if ( !pathloc->ops->node_type_h ){
20020f8: c4 06 a0 08 ld [ %i2 + 8 ], %g2
20020fc: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1
2002100: 80 a0 60 00 cmp %g1, 0
2002104: 22 80 00 1e be,a 200217c <rtems_filesystem_evaluate_path+0x11c><== NEVER TAKEN
2002108: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
rtems_filesystem_freenode( pathloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
200210c: 9f c0 40 00 call %g1
2002110: 90 10 00 1a mov %i2, %o0
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
2002114: 90 02 3f fd add %o0, -3, %o0
2002118: 80 a2 20 01 cmp %o0, 1
200211c: 28 80 00 0f bleu,a 2002158 <rtems_filesystem_evaluate_path+0xf8><== NEVER TAKEN
2002120: c4 06 a0 08 ld [ %i2 + 8 ], %g2 <== NOT EXECUTED
}
}
return result;
}
2002124: 81 c7 e0 08 ret
2002128: 81 e8 00 00 restore
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
200212c: c6 00 62 a4 ld [ %g1 + 0x2a4 ], %g3 <== NOT EXECUTED
2002130: 88 10 20 00 clr %g4 <== NOT EXECUTED
2002134: c2 00 e0 04 ld [ %g3 + 4 ], %g1 <== NOT EXECUTED
2002138: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
200213c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED
2002140: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
2002144: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 <== NOT EXECUTED
2002148: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
200214c: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 <== NOT EXECUTED
2002150: 10 bf ff dd b 20020c4 <rtems_filesystem_evaluate_path+0x64><== NOT EXECUTED
2002154: c4 26 a0 0c st %g2, [ %i2 + 0xc ] <== NOT EXECUTED
type = (*pathloc->ops->node_type_h)( pathloc );
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
2002158: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 <== NOT EXECUTED
200215c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002160: 02 80 00 06 be 2002178 <rtems_filesystem_evaluate_path+0x118><== NOT EXECUTED
2002164: 90 10 00 1a mov %i2, %o0 <== 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 );
2002168: 9f c0 40 00 call %g1 <== NOT EXECUTED
200216c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
}
return result;
}
2002170: 81 c7 e0 08 ret <== NOT EXECUTED
2002174: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
rtems_filesystem_freenode( pathloc );
2002178: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
200217c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002180: 02 80 00 04 be 2002190 <rtems_filesystem_evaluate_path+0x130><== NOT EXECUTED
2002184: 01 00 00 00 nop <== NOT EXECUTED
2002188: 9f c0 40 00 call %g1 <== NOT EXECUTED
200218c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2002190: 40 00 2b 2d call 200ce44 <__errno> <== NOT EXECUTED
2002194: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2002198: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
200219c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20021a0: 81 c7 e0 08 ret <== NOT EXECUTED
20021a4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Verify Input parameters.
*/
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
20021a8: 40 00 2b 27 call 200ce44 <__errno> <== NOT EXECUTED
20021ac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20021b0: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED
20021b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20021b8: 81 c7 e0 08 ret <== NOT EXECUTED
20021bc: 81 e8 00 00 restore <== NOT EXECUTED
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
20021c0: 40 00 2b 21 call 200ce44 <__errno> <== NOT EXECUTED
20021c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20021c8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20021cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20021d0: 81 c7 e0 08 ret
20021d4: 81 e8 00 00 restore
0200a69c <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 )
{
200a69c: 9d e3 bf 80 save %sp, -128, %sp
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
200a6a0: 25 00 80 5a sethi %hi(0x2016800), %l2
200a6a4: c4 04 a2 a4 ld [ %l2 + 0x2a4 ], %g2 ! 2016aa4 <rtems_current_user_env>
200a6a8: 82 10 20 12 mov 0x12, %g1
init_fs_mount_table();
200a6ac: 40 00 02 51 call 200aff0 <init_fs_mount_table>
200a6b0: c2 30 a0 24 sth %g1, [ %g2 + 0x24 ]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
200a6b4: 03 00 80 54 sethi %hi(0x2015000), %g1
200a6b8: c4 00 63 9c ld [ %g1 + 0x39c ], %g2 ! 201539c <rtems_filesystem_mount_table_size>
200a6bc: 80 a0 a0 00 cmp %g2, 0
200a6c0: 02 80 00 3d be 200a7b4 <rtems_filesystem_initialize+0x118><== NEVER TAKEN
200a6c4: 03 00 80 59 sethi %hi(0x2016400), %g1
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
200a6c8: c4 00 61 90 ld [ %g1 + 0x190 ], %g2 ! 2016590 <rtems_filesystem_mount_table>
status = mount(
200a6cc: 90 07 bf f4 add %fp, -12, %o0
200a6d0: d8 00 a0 0c ld [ %g2 + 0xc ], %o4
200a6d4: d2 00 80 00 ld [ %g2 ], %o1
200a6d8: d4 00 a0 04 ld [ %g2 + 4 ], %o2
200a6dc: 40 00 02 4d call 200b010 <mount>
200a6e0: d6 00 a0 08 ld [ %g2 + 8 ], %o3
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
200a6e4: 80 a2 3f ff cmp %o0, -1
200a6e8: 02 80 00 36 be 200a7c0 <rtems_filesystem_initialize+0x124><== NEVER TAKEN
200a6ec: c8 07 bf f4 ld [ %fp + -12 ], %g4
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
200a6f0: c2 04 a2 a4 ld [ %l2 + 0x2a4 ], %g1
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
200a6f4: c4 01 20 18 ld [ %g4 + 0x18 ], %g2
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
200a6f8: c0 30 60 26 clrh [ %g1 + 0x26 ]
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
200a6fc: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
200a700: c6 01 20 1c ld [ %g4 + 0x1c ], %g3
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a704: a0 07 bf e4 add %fp, -28, %l0
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
200a708: c6 20 60 18 st %g3, [ %g1 + 0x18 ]
200a70c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a710: 23 00 80 57 sethi %hi(0x2015c00), %l1
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
200a714: c4 20 60 1c st %g2, [ %g1 + 0x1c ]
200a718: c6 01 20 24 ld [ %g4 + 0x24 ], %g3
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a71c: 92 10 20 00 clr %o1
* set_private_env() - but then: that's
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
200a720: c6 20 60 20 st %g3, [ %g1 + 0x20 ]
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a724: 94 10 00 10 mov %l0, %o2
200a728: 96 10 20 00 clr %o3
200a72c: 7f ff de 4d call 2002060 <rtems_filesystem_evaluate_path>
200a730: 90 14 60 10 or %l1, 0x10, %o0
rtems_filesystem_root = loc;
200a734: c4 04 a2 a4 ld [ %l2 + 0x2a4 ], %g2
200a738: c2 07 bf e4 ld [ %fp + -28 ], %g1
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a73c: 94 10 00 10 mov %l0, %o2
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
200a740: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
200a744: c2 07 bf e8 ld [ %fp + -24 ], %g1
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a748: 92 10 20 00 clr %o1
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
200a74c: c2 20 a0 18 st %g1, [ %g2 + 0x18 ]
200a750: c2 07 bf ec ld [ %fp + -20 ], %g1
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a754: 96 10 20 00 clr %o3
* Till Straumann, 10/25/2002
*/
rtems_filesystem_root = entry->mt_fs_root;
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
200a758: c2 20 a0 1c st %g1, [ %g2 + 0x1c ]
200a75c: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
200a760: 90 14 60 10 or %l1, 0x10, %o0
200a764: 7f ff de 3f call 2002060 <rtems_filesystem_evaluate_path>
200a768: c2 20 a0 20 st %g1, [ %g2 + 0x20 ]
rtems_filesystem_current = loc;
200a76c: c2 07 bf e4 ld [ %fp + -28 ], %g1
200a770: c6 04 a2 a4 ld [ %l2 + 0x2a4 ], %g3
*
* 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);
200a774: 11 00 80 57 sethi %hi(0x2015c00), %o0
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_current = loc;
200a778: c2 20 e0 04 st %g1, [ %g3 + 4 ]
200a77c: c2 07 bf e8 ld [ %fp + -24 ], %g1
*
* 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);
200a780: 90 12 20 18 or %o0, 0x18, %o0
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_current = loc;
200a784: c2 20 e0 08 st %g1, [ %g3 + 8 ]
200a788: c2 07 bf ec ld [ %fp + -20 ], %g1
*
* 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);
200a78c: 92 10 21 ff mov 0x1ff, %o1
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 0, &loc, 0);
rtems_filesystem_current = loc;
200a790: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
200a794: c4 07 bf f0 ld [ %fp + -16 ], %g2
*
* 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);
200a798: 40 00 02 0c call 200afc8 <mkdir>
200a79c: c4 20 e0 10 st %g2, [ %g3 + 0x10 ]
if ( status != 0 )
200a7a0: 80 a2 20 00 cmp %o0, 0
200a7a4: 12 80 00 0a bne 200a7cc <rtems_filesystem_initialize+0x130><== NEVER TAKEN
200a7a8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
200a7ac: 81 c7 e0 08 ret
200a7b0: 81 e8 00 00 restore
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
200a7b4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
200a7b8: 7f ff ed eb call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
200a7bc: 90 12 20 01 or %o0, 1, %o0 ! abcd0001 <RAM_END+0xa98d0001><== NOT EXECUTED
status = mount(
&entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
200a7c0: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
200a7c4: 7f ff ed e8 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
200a7c8: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0xa98d0002><== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
200a7cc: 7f ff ed e6 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
200a7d0: 90 12 20 03 or %o0, 3, %o0 <== NOT EXECUTED
02001e04 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
2001e04: 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 );
2001e08: 92 10 20 00 clr %o1 <== NOT EXECUTED
2001e0c: a2 07 bf e8 add %fp, -24, %l1 <== NOT EXECUTED
2001e10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2001e14: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2001e18: 40 00 00 92 call 2002060 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
2001e1c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
2001e20: 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 );
2001e24: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
2001e28: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED
2001e2c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2001e30: 02 80 00 28 be 2001ed0 <rtems_io_lookup_name+0xcc> <== NOT EXECUTED
2001e34: e4 07 bf e8 ld [ %fp + -24 ], %l2 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
node_type = (*loc.ops->node_type_h)( &loc );
2001e38: 9f c0 40 00 call %g1 <== NOT EXECUTED
2001e3c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
2001e40: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2001e44: 02 80 00 0e be 2001e7c <rtems_io_lookup_name+0x78> <== NOT EXECUTED
2001e48: 80 a2 20 02 cmp %o0, 2 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
2001e4c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2001e50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2001e54: 02 80 00 2b be 2001f00 <rtems_io_lookup_name+0xfc> <== NOT EXECUTED
2001e58: 01 00 00 00 nop <== NOT EXECUTED
2001e5c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2001e60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2001e64: 02 80 00 27 be 2001f00 <rtems_io_lookup_name+0xfc> <== NOT EXECUTED
2001e68: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2001e6c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2001e70: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
2001e74: 81 c7 e0 08 ret <== NOT EXECUTED
2001e78: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
node_type = (*loc.ops->node_type_h)( &loc );
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
2001e7c: 12 bf ff f5 bne 2001e50 <rtems_io_lookup_name+0x4c> <== NOT EXECUTED
2001e80: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
2001e84: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
2001e88: 40 00 31 11 call 200e2cc <strlen> <== NOT EXECUTED
2001e8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2001e90: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
2001e94: c2 04 a0 4c ld [ %l2 + 0x4c ], %g1 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
2001e98: c6 07 bf f0 ld [ %fp + -16 ], %g3 <== 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;
2001e9c: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
2001ea0: c4 04 a0 50 ld [ %l2 + 0x50 ], %g2 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
2001ea4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2001ea8: 02 80 00 18 be 2001f08 <rtems_io_lookup_name+0x104> <== NOT EXECUTED
2001eac: c4 26 60 0c st %g2, [ %i1 + 0xc ] <== NOT EXECUTED
2001eb0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
2001eb4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2001eb8: 02 80 00 14 be 2001f08 <rtems_io_lookup_name+0x104> <== NOT EXECUTED
2001ebc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2001ec0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2001ec4: b0 10 20 00 clr %i0 <== NOT EXECUTED
2001ec8: 81 c7 e0 08 ret <== NOT EXECUTED
2001ecc: 81 e8 00 00 restore <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( name, 0x00, &loc, true );
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
rtems_filesystem_freenode( &loc );
2001ed0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED
2001ed4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2001ed8: 02 80 00 04 be 2001ee8 <rtems_io_lookup_name+0xe4> <== NOT EXECUTED
2001edc: 01 00 00 00 nop <== NOT EXECUTED
2001ee0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2001ee4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2001ee8: 40 00 2b d7 call 200ce44 <__errno> <== NOT EXECUTED
2001eec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2001ef0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
2001ef4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2001ef8: 81 c7 e0 08 ret <== NOT EXECUTED
2001efc: 81 e8 00 00 restore <== 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 );
2001f00: 81 c7 e0 08 ret <== NOT EXECUTED
2001f04: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED
#endif
return RTEMS_SUCCESSFUL;
}
2001f08: 81 c7 e0 08 ret <== NOT EXECUTED
2001f0c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02006f7c <rtems_io_register_driver>:
{
/*
* Validate the pointer data and contents passed in
*/
if ( !driver_table )
2006f7c: 9a 92 60 00 orcc %o1, 0, %o5
2006f80: 02 80 00 4d be 20070b4 <rtems_io_register_driver+0x138>
2006f84: 80 a2 a0 00 cmp %o2, 0
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
2006f88: 02 80 00 4c be 20070b8 <rtems_io_register_driver+0x13c>
2006f8c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
2006f90: c2 03 40 00 ld [ %o5 ], %g1
2006f94: 80 a0 60 00 cmp %g1, 0
2006f98: 22 80 00 44 be,a 20070a8 <rtems_io_register_driver+0x12c>
2006f9c: c2 03 60 04 ld [ %o5 + 4 ], %g1
*registered_major = 0;
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
2006fa0: 03 00 80 6c sethi %hi(0x201b000), %g1
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
return RTEMS_INVALID_ADDRESS;
*registered_major = 0;
2006fa4: c0 22 80 00 clr [ %o2 ]
/*
* The requested major number is higher than what is configured.
*/
if ( major >= _IO_Number_of_drivers )
2006fa8: c8 00 62 40 ld [ %g1 + 0x240 ], %g4
2006fac: 80 a1 00 08 cmp %g4, %o0
2006fb0: 08 80 00 39 bleu 2007094 <rtems_io_register_driver+0x118>
2006fb4: 82 10 20 0a mov 0xa, %g1
/*
* Test for initialise/open being present to indicate the driver slot is
* in use.
*/
if ( major == 0 ) {
2006fb8: 80 a2 20 00 cmp %o0, 0
2006fbc: 12 80 00 29 bne 2007060 <rtems_io_register_driver+0xe4>
2006fc0: 03 00 80 6c sethi %hi(0x201b000), %g1
bool found = false;
for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
2006fc4: 90 81 3f ff addcc %g4, -1, %o0
2006fc8: 02 80 00 35 be 200709c <rtems_io_register_driver+0x120> <== NEVER TAKEN
2006fcc: 05 00 80 6c sethi %hi(0x201b000), %g2
2006fd0: c6 00 a2 44 ld [ %g2 + 0x244 ], %g3 ! 201b244 <_IO_Driver_address_table>
2006fd4: 85 29 20 03 sll %g4, 3, %g2
2006fd8: 83 29 20 05 sll %g4, 5, %g1
2006fdc: 82 20 40 02 sub %g1, %g2, %g1
2006fe0: 82 00 7f e8 add %g1, -24, %g1
2006fe4: 10 80 00 05 b 2006ff8 <rtems_io_register_driver+0x7c>
2006fe8: 84 00 c0 01 add %g3, %g1, %g2
2006fec: 90 82 3f ff addcc %o0, -1, %o0
2006ff0: 02 80 00 2b be 200709c <rtems_io_register_driver+0x120>
2006ff4: 84 00 bf e8 add %g2, -24, %g2
if ( !_IO_Driver_address_table[major].initialization_entry &&
2006ff8: c2 00 80 00 ld [ %g2 ], %g1
2006ffc: 80 a0 60 00 cmp %g1, 0
2007000: 12 bf ff fb bne 2006fec <rtems_io_register_driver+0x70>
2007004: 88 10 00 02 mov %g2, %g4
2007008: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200700c: 80 a0 60 00 cmp %g1, 0
2007010: 32 bf ff f8 bne,a 2006ff0 <rtems_io_register_driver+0x74><== NEVER TAKEN
2007014: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED
if ( _IO_Driver_address_table[major].initialization_entry ||
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
2007018: c2 03 40 00 ld [ %o5 ], %g1
*registered_major = major;
200701c: d0 22 80 00 st %o0, [ %o2 ]
if ( _IO_Driver_address_table[major].initialization_entry ||
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
2007020: c2 21 00 00 st %g1, [ %g4 ]
2007024: c4 03 60 04 ld [ %o5 + 4 ], %g2
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
2007028: 92 10 20 00 clr %o1
if ( _IO_Driver_address_table[major].initialization_entry ||
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
200702c: c4 21 20 04 st %g2, [ %g4 + 4 ]
2007030: c2 03 60 08 ld [ %o5 + 8 ], %g1
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
2007034: 94 10 20 00 clr %o2
if ( _IO_Driver_address_table[major].initialization_entry ||
_IO_Driver_address_table[major].open_entry )
return RTEMS_RESOURCE_IN_USE;
_IO_Driver_address_table[major] = *driver_table;
2007038: c2 21 20 08 st %g1, [ %g4 + 8 ]
200703c: c4 03 60 0c ld [ %o5 + 0xc ], %g2
2007040: c4 21 20 0c st %g2, [ %g4 + 0xc ]
2007044: c2 03 60 10 ld [ %o5 + 0x10 ], %g1
2007048: c2 21 20 10 st %g1, [ %g4 + 0x10 ]
200704c: c4 03 60 14 ld [ %o5 + 0x14 ], %g2
2007050: c4 21 20 14 st %g2, [ %g4 + 0x14 ]
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
2007054: 82 13 c0 00 mov %o7, %g1
2007058: 7f ff ff 48 call 2006d78 <rtems_io_initialize>
200705c: 9e 10 40 00 mov %g1, %o7
if ( !found )
return RTEMS_TOO_MANY;
}
if ( _IO_Driver_address_table[major].initialization_entry ||
2007060: c8 00 62 44 ld [ %g1 + 0x244 ], %g4
2007064: 85 2a 20 03 sll %o0, 3, %g2
2007068: 83 2a 20 05 sll %o0, 5, %g1
200706c: 82 20 40 02 sub %g1, %g2, %g1
2007070: c6 01 00 01 ld [ %g4 + %g1 ], %g3
2007074: 80 a0 e0 00 cmp %g3, 0
2007078: 12 80 00 06 bne 2007090 <rtems_io_register_driver+0x114> <== ALWAYS TAKEN
200707c: 88 01 00 01 add %g4, %g1, %g4
2007080: c2 01 20 04 ld [ %g4 + 4 ], %g1 <== NOT EXECUTED
2007084: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2007088: 22 bf ff e5 be,a 200701c <rtems_io_register_driver+0xa0> <== NOT EXECUTED
200708c: c2 03 40 00 ld [ %o5 ], %g1 <== NOT EXECUTED
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
2007090: 82 10 20 0c mov 0xc, %g1
}
2007094: 81 c3 e0 08 retl
2007098: 90 10 00 01 mov %g1, %o0
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
200709c: 82 10 20 05 mov 5, %g1
}
20070a0: 81 c3 e0 08 retl
20070a4: 90 10 00 01 mov %g1, %o0
return RTEMS_INVALID_ADDRESS;
if ( !registered_major )
return RTEMS_INVALID_ADDRESS;
if ( !driver_table->initialization_entry && !driver_table->open_entry )
20070a8: 80 a0 60 00 cmp %g1, 0
20070ac: 12 bf ff be bne 2006fa4 <rtems_io_register_driver+0x28> <== NEVER TAKEN
20070b0: 03 00 80 6c sethi %hi(0x201b000), %g1
_IO_Driver_address_table[major] = *driver_table;
*registered_major = major;
return rtems_io_initialize( major, 0, NULL );
20070b4: 82 10 20 09 mov 9, %g1
}
20070b8: 81 c3 e0 08 retl
20070bc: 90 10 00 01 mov %g1, %o0
020070c0 <rtems_io_unregister_driver>:
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
20070c0: 9d e3 bf 98 save %sp, -104, %sp
if ( major < _IO_Number_of_drivers ) {
20070c4: 03 00 80 6c sethi %hi(0x201b000), %g1
20070c8: c4 00 62 40 ld [ %g1 + 0x240 ], %g2 ! 201b240 <_IO_Number_of_drivers>
*/
rtems_status_code rtems_io_unregister_driver(
rtems_device_major_number major
)
{
20070cc: 86 10 00 18 mov %i0, %g3
if ( major < _IO_Number_of_drivers ) {
20070d0: 80 a0 80 18 cmp %g2, %i0
20070d4: 08 80 00 0c bleu 2007104 <rtems_io_unregister_driver+0x44><== NEVER TAKEN
20070d8: b0 10 20 0d mov 0xd, %i0
memset(
20070dc: 03 00 80 6c sethi %hi(0x201b000), %g1
20070e0: c4 00 62 44 ld [ %g1 + 0x244 ], %g2 ! 201b244 <_IO_Driver_address_table>
20070e4: 83 28 e0 03 sll %g3, 3, %g1
20070e8: 91 28 e0 05 sll %g3, 5, %o0
20070ec: 92 10 20 00 clr %o1
20070f0: 90 22 00 01 sub %o0, %g1, %o0
20070f4: 94 10 20 18 mov 0x18, %o2
20070f8: 90 00 80 08 add %g2, %o0, %o0
20070fc: 40 00 1d 4d call 200e630 <memset>
2007100: b0 10 20 00 clr %i0
sizeof( rtems_driver_address_table )
);
return RTEMS_SUCCESSFUL;
}
return RTEMS_UNSATISFIED;
}
2007104: 81 c7 e0 08 ret
2007108: 81 e8 00 00 restore
020083a8 <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)
{
20083a8: 9d e3 bf 98 save %sp, -104, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
20083ac: 80 a6 20 00 cmp %i0, 0
20083b0: 02 80 00 23 be 200843c <rtems_iterate_over_all_threads+0x94><== NEVER TAKEN
20083b4: 03 00 80 8d sethi %hi(0x2023400), %g1
return;
20083b8: a4 10 63 b4 or %g1, 0x3b4, %l2 ! 20237b4 <_Objects_Information_table+0x4>
20083bc: a6 04 a0 10 add %l2, 0x10, %l3
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
api_index++ ) {
if ( !_Objects_Information_table[ api_index ] )
20083c0: c2 04 80 00 ld [ %l2 ], %g1
20083c4: 80 a0 60 00 cmp %g1, 0
20083c8: 22 80 00 1a be,a 2008430 <rtems_iterate_over_all_threads+0x88>
20083cc: a4 04 a0 04 add %l2, 4, %l2
continue;
information = _Objects_Information_table[ api_index ][ 1 ];
20083d0: e2 00 60 04 ld [ %g1 + 4 ], %l1
if ( information ) {
20083d4: 80 a4 60 00 cmp %l1, 0
20083d8: 22 80 00 16 be,a 2008430 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
20083dc: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
20083e0: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1
20083e4: 86 90 60 00 orcc %g1, 0, %g3
20083e8: 22 80 00 12 be,a 2008430 <rtems_iterate_over_all_threads+0x88><== NEVER TAKEN
20083ec: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED
20083f0: a0 10 20 01 mov 1, %l0
the_thread = (Thread_Control *)information->local_table[ i ];
20083f4: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
20083f8: 83 2c 20 02 sll %l0, 2, %g1
20083fc: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
2008400: 80 a2 20 00 cmp %o0, 0
2008404: 02 80 00 05 be 2008418 <rtems_iterate_over_all_threads+0x70><== NEVER TAKEN
2008408: a0 04 20 01 inc %l0
continue;
(*routine)(the_thread);
200840c: 9f c6 00 00 call %i0
2008410: 01 00 00 00 nop
2008414: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3
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++ ) {
2008418: 83 28 e0 10 sll %g3, 0x10, %g1
200841c: 83 30 60 10 srl %g1, 0x10, %g1
2008420: 80 a0 40 10 cmp %g1, %l0
2008424: 3a bf ff f5 bcc,a 20083f8 <rtems_iterate_over_all_threads+0x50>
2008428: c4 04 60 1c ld [ %l1 + 0x1c ], %g2
200842c: a4 04 a0 04 add %l2, 4, %l2
if ( !routine )
return;
for ( api_index = 1 ;
api_index <= OBJECTS_APIS_LAST ;
2008430: 80 a4 80 13 cmp %l2, %l3
2008434: 32 bf ff e4 bne,a 20083c4 <rtems_iterate_over_all_threads+0x1c>
2008438: c2 04 80 00 ld [ %l2 ], %g1
200843c: 81 c7 e0 08 ret
2008440: 81 e8 00 00 restore
0200ad04 <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 )
{
200ad04: 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 );
200ad08: 23 00 80 5c sethi %hi(0x2017000), %l1
200ad0c: d0 04 62 14 ld [ %l1 + 0x214 ], %o0 ! 2017214 <rtems_libio_semaphore>
200ad10: 92 10 20 00 clr %o1
200ad14: 7f ff ea d3 call 2005860 <rtems_semaphore_obtain>
200ad18: 94 10 20 00 clr %o2
if (rtems_libio_iop_freelist) {
200ad1c: 21 00 80 5c sethi %hi(0x2017000), %l0
200ad20: c4 04 22 10 ld [ %l0 + 0x210 ], %g2 ! 2017210 <rtems_libio_iop_freelist>
200ad24: 80 a0 a0 00 cmp %g2, 0
200ad28: 12 80 00 07 bne 200ad44 <rtems_libio_allocate+0x40>
200ad2c: 03 00 80 5c sethi %hi(0x2017000), %g1
}
failed:
iop = 0;
done:
200ad30: b0 10 20 00 clr %i0
rtems_semaphore_release( rtems_libio_semaphore );
200ad34: 7f ff eb 13 call 2005980 <rtems_semaphore_release>
200ad38: d0 04 62 14 ld [ %l1 + 0x214 ], %o0
return iop;
}
200ad3c: 81 c7 e0 08 ret
200ad40: 81 e8 00 00 restore
rtems_id sema;
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
if (rtems_libio_iop_freelist) {
rc = rtems_semaphore_create(
200ad44: c6 00 62 0c ld [ %g1 + 0x20c ], %g3
200ad48: 92 10 20 01 mov 1, %o1
200ad4c: 86 20 80 03 sub %g2, %g3, %g3
200ad50: 87 38 e0 02 sra %g3, 2, %g3
200ad54: 83 28 e0 02 sll %g3, 2, %g1
200ad58: 85 28 e0 06 sll %g3, 6, %g2
200ad5c: 84 20 80 01 sub %g2, %g1, %g2
200ad60: 83 28 a0 06 sll %g2, 6, %g1
200ad64: 82 20 40 02 sub %g1, %g2, %g1
200ad68: 85 28 60 0c sll %g1, 0xc, %g2
200ad6c: 82 00 40 02 add %g1, %g2, %g1
200ad70: 82 00 40 03 add %g1, %g3, %g1
200ad74: 83 28 60 04 sll %g1, 4, %g1
200ad78: 82 20 40 03 sub %g1, %g3, %g1
200ad7c: 83 28 60 02 sll %g1, 2, %g1
200ad80: 86 20 c0 01 sub %g3, %g1, %g3
200ad84: 94 10 20 54 mov 0x54, %o2
200ad88: 96 10 20 00 clr %o3
200ad8c: 11 13 10 92 sethi %hi(0x4c424800), %o0
200ad90: 98 07 bf f4 add %fp, -12, %o4
200ad94: 90 12 21 00 or %o0, 0x100, %o0
200ad98: 7f ff ea 0b call 20055c4 <rtems_semaphore_create>
200ad9c: 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)
200ada0: 80 a2 20 00 cmp %o0, 0
200ada4: 32 bf ff e4 bne,a 200ad34 <rtems_libio_allocate+0x30> <== NEVER TAKEN
200ada8: b0 10 20 00 clr %i0 <== NOT EXECUTED
goto failed;
iop = rtems_libio_iop_freelist;
200adac: f0 04 22 10 ld [ %l0 + 0x210 ], %i0
next = iop->data1;
(void) memset( iop, 0, sizeof(rtems_libio_t) );
iop->flags = LIBIO_FLAGS_OPEN;
200adb0: 84 10 21 00 mov 0x100, %g2
&sema
);
if (rc != RTEMS_SUCCESSFUL)
goto failed;
iop = rtems_libio_iop_freelist;
next = iop->data1;
200adb4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
(void) memset( iop, 0, sizeof(rtems_libio_t) );
200adb8: c0 26 20 20 clr [ %i0 + 0x20 ]
200adbc: c0 26 00 00 clr [ %i0 ]
200adc0: c0 26 20 04 clr [ %i0 + 4 ]
200adc4: c0 26 20 08 clr [ %i0 + 8 ]
200adc8: c0 26 20 10 clr [ %i0 + 0x10 ]
200adcc: c0 26 20 14 clr [ %i0 + 0x14 ]
200add0: c0 26 20 18 clr [ %i0 + 0x18 ]
200add4: c0 26 20 1c clr [ %i0 + 0x1c ]
200add8: c0 26 20 24 clr [ %i0 + 0x24 ]
200addc: c0 26 20 2c clr [ %i0 + 0x2c ]
200ade0: c0 26 20 30 clr [ %i0 + 0x30 ]
200ade4: c0 26 20 28 clr [ %i0 + 0x28 ]
iop->flags = LIBIO_FLAGS_OPEN;
iop->sem = sema;
rtems_libio_iop_freelist = next;
200ade8: c2 24 22 10 st %g1, [ %l0 + 0x210 ]
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;
200adec: c2 07 bf f4 ld [ %fp + -12 ], %g1
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;
200adf0: c4 26 20 0c st %g2, [ %i0 + 0xc ]
iop->sem = sema;
200adf4: 10 bf ff d0 b 200ad34 <rtems_libio_allocate+0x30>
200adf8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
0200aca8 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
200aca8: 9d e3 bf 98 save %sp, -104, %sp
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200acac: 23 00 80 5c sethi %hi(0x2017000), %l1
200acb0: d0 04 62 14 ld [ %l1 + 0x214 ], %o0 ! 2017214 <rtems_libio_semaphore>
200acb4: 92 10 20 00 clr %o1
200acb8: 7f ff ea ea call 2005860 <rtems_semaphore_obtain>
200acbc: 94 10 20 00 clr %o2
if (iop->sem)
200acc0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200acc4: 80 a2 20 00 cmp %o0, 0
200acc8: 02 80 00 04 be 200acd8 <rtems_libio_free+0x30> <== NEVER TAKEN
200accc: a0 10 00 18 mov %i0, %l0
rtems_semaphore_delete(iop->sem);
200acd0: 7f ff ea b7 call 20057ac <rtems_semaphore_delete>
200acd4: 01 00 00 00 nop
iop->flags &= ~LIBIO_FLAGS_OPEN;
200acd8: c2 04 20 0c ld [ %l0 + 0xc ], %g1
iop->data1 = rtems_libio_iop_freelist;
200acdc: 05 00 80 5c sethi %hi(0x2017000), %g2
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
200ace0: f0 04 62 14 ld [ %l1 + 0x214 ], %i0
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
200ace4: c6 00 a2 10 ld [ %g2 + 0x210 ], %g3
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
200ace8: 82 08 7e ff and %g1, -257, %g1
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
200acec: e0 20 a2 10 st %l0, [ %g2 + 0x210 ]
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
200acf0: c6 24 20 28 st %g3, [ %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;
200acf4: c2 24 20 0c st %g1, [ %l0 + 0xc ]
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_semaphore_release(rtems_libio_semaphore);
200acf8: 7f ff eb 22 call 2005980 <rtems_semaphore_release>
200acfc: 81 e8 00 00 restore
020021d8 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
20021d8: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code rc;
int i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
20021dc: 21 00 80 59 sethi %hi(0x2016400), %l0
20021e0: d0 04 21 88 ld [ %l0 + 0x188 ], %o0 ! 2016588 <rtems_libio_number_iops>
20021e4: 80 a2 20 00 cmp %o0, 0
20021e8: 22 80 00 1e be,a 2002260 <rtems_libio_init+0x88>
20021ec: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
20021f0: 40 00 21 7a call 200a7d8 <calloc>
20021f4: 92 10 20 34 mov 0x34, %o1
20021f8: 03 00 80 5c sethi %hi(0x2017000), %g1
20021fc: d0 20 62 0c st %o0, [ %g1 + 0x20c ] ! 201720c <rtems_libio_iops>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2002200: 80 a2 20 00 cmp %o0, 0
2002204: 02 80 00 23 be 2002290 <rtems_libio_init+0xb8> <== NEVER TAKEN
2002208: 84 10 00 08 mov %o0, %g2
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++)
200220c: c8 04 21 88 ld [ %l0 + 0x188 ], %g4
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;
2002210: 03 00 80 5c sethi %hi(0x2017000), %g1
for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++)
2002214: 80 a1 20 01 cmp %g4, 1
2002218: 02 80 00 10 be 2002258 <rtems_libio_init+0x80> <== NEVER TAKEN
200221c: d0 20 62 10 st %o0, [ %g1 + 0x210 ]
2002220: 82 02 20 34 add %o0, 0x34, %g1
2002224: 86 10 20 01 mov 1, %g3
iop->data1 = iop + 1;
2002228: c2 20 7f f4 st %g1, [ %g1 + -12 ]
200222c: 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++)
2002230: 80 a0 c0 04 cmp %g3, %g4
2002234: 12 bf ff fd bne 2002228 <rtems_libio_init+0x50>
2002238: 82 00 60 34 add %g1, 0x34, %g1
200223c: 85 28 e0 02 sll %g3, 2, %g2
2002240: 83 28 e0 04 sll %g3, 4, %g1
2002244: 82 20 40 02 sub %g1, %g2, %g1
2002248: 82 00 40 03 add %g1, %g3, %g1
200224c: 83 28 60 02 sll %g1, 2, %g1
2002250: 82 00 7f cc add %g1, -52, %g1
2002254: 84 02 00 01 add %o0, %g1, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
2002258: c0 20 a0 28 clr [ %g2 + 0x28 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
200225c: 11 13 10 92 sethi %hi(0x4c424800), %o0
2002260: 92 10 20 01 mov 1, %o1
2002264: 90 12 21 4f or %o0, 0x14f, %o0
2002268: 94 10 20 54 mov 0x54, %o2
200226c: 96 10 20 00 clr %o3
2002270: 19 00 80 5c sethi %hi(0x2017000), %o4
2002274: 40 00 0c d4 call 20055c4 <rtems_semaphore_create>
2002278: 98 13 22 14 or %o4, 0x214, %o4 ! 2017214 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
200227c: 80 a2 20 00 cmp %o0, 0
2002280: 12 80 00 06 bne 2002298 <rtems_libio_init+0xc0> <== NEVER TAKEN
2002284: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
rtems_filesystem_initialize();
2002288: 40 00 21 05 call 200a69c <rtems_filesystem_initialize>
200228c: 81 e8 00 00 restore
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
2002290: 40 00 0f 35 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2002294: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
2002298: 40 00 0f 33 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
0200aba0 <rtems_libio_is_file_open>:
*/
int rtems_libio_is_file_open(
void *node_access
)
{
200aba0: 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 );
200aba4: 21 00 80 5c sethi %hi(0x2017000), %l0 <== NOT EXECUTED
200aba8: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 ! 2017214 <rtems_libio_semaphore><== NOT EXECUTED
200abac: 92 10 20 00 clr %o1 <== NOT EXECUTED
200abb0: 7f ff eb 2c call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
200abb4: 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++){
200abb8: 03 00 80 59 sethi %hi(0x2016400), %g1 <== NOT EXECUTED
200abbc: c8 00 61 88 ld [ %g1 + 0x188 ], %g4 ! 2016588 <rtems_libio_number_iops><== NOT EXECUTED
200abc0: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
200abc4: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
200abc8: 02 80 00 0e be 200ac00 <rtems_libio_is_file_open+0x60> <== NOT EXECUTED
200abcc: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 <== NOT EXECUTED
200abd0: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
200abd4: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 <== NOT EXECUTED
200abd8: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
200abdc: 02 80 00 06 be 200abf4 <rtems_libio_is_file_open+0x54> <== NOT EXECUTED
200abe0: 84 00 a0 01 inc %g2 <== NOT EXECUTED
/*
* Check if this node is under the file system that we
* are trying to dismount.
*/
if ( iop->pathinfo.node_access == node_access ) {
200abe4: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 <== NOT EXECUTED
200abe8: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
200abec: 02 80 00 0a be 200ac14 <rtems_libio_is_file_open+0x74> <== NOT EXECUTED
200abf0: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
200abf4: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
200abf8: 0a bf ff f7 bcs 200abd4 <rtems_libio_is_file_open+0x34> <== NOT EXECUTED
200abfc: 86 00 e0 34 add %g3, 0x34, %g3 <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
200ac00: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 <== NOT EXECUTED
200ac04: 7f ff eb 5f call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
200ac08: b0 10 20 00 clr %i0 <== NOT EXECUTED
return result;
}
200ac0c: 81 c7 e0 08 ret <== NOT EXECUTED
200ac10: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
200ac14: 7f ff eb 5b call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
200ac18: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return result;
}
200ac1c: 81 c7 e0 08 ret <== NOT EXECUTED
200ac20: 81 e8 00 00 restore <== NOT EXECUTED
0200ac24 <rtems_libio_is_open_files_in_fs>:
*/
int rtems_libio_is_open_files_in_fs(
rtems_filesystem_mount_table_entry_t * fs_mt_entry
)
{
200ac24: 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 );
200ac28: 21 00 80 5c sethi %hi(0x2017000), %l0 <== NOT EXECUTED
200ac2c: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 ! 2017214 <rtems_libio_semaphore><== NOT EXECUTED
200ac30: 92 10 20 00 clr %o1 <== NOT EXECUTED
200ac34: 7f ff eb 0b call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
200ac38: 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++){
200ac3c: 03 00 80 59 sethi %hi(0x2016400), %g1 <== NOT EXECUTED
200ac40: c8 00 61 88 ld [ %g1 + 0x188 ], %g4 ! 2016588 <rtems_libio_number_iops><== NOT EXECUTED
200ac44: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
200ac48: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED
200ac4c: 02 80 00 0e be 200ac84 <rtems_libio_is_open_files_in_fs+0x60><== NOT EXECUTED
200ac50: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 <== NOT EXECUTED
200ac54: 84 10 20 00 clr %g2 <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) {
200ac58: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 <== NOT EXECUTED
200ac5c: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
200ac60: 02 80 00 06 be 200ac78 <rtems_libio_is_open_files_in_fs+0x54><== NOT EXECUTED
200ac64: 84 00 a0 01 inc %g2 <== 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 ) {
200ac68: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED
200ac6c: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED
200ac70: 02 80 00 0a be 200ac98 <rtems_libio_is_open_files_in_fs+0x74><== NOT EXECUTED
200ac74: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 <== NOT EXECUTED
/*
* Look for any active file descriptor entry.
*/
for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){
200ac78: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
200ac7c: 0a bf ff f7 bcs 200ac58 <rtems_libio_is_open_files_in_fs+0x34><== NOT EXECUTED
200ac80: 86 00 e0 34 add %g3, 0x34, %g3 <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
200ac84: d0 04 22 14 ld [ %l0 + 0x214 ], %o0 <== NOT EXECUTED
200ac88: 7f ff eb 3e call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
200ac8c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return result;
}
200ac90: 81 c7 e0 08 ret <== NOT EXECUTED
200ac94: 81 e8 00 00 restore <== NOT EXECUTED
break;
}
}
}
rtems_semaphore_release( rtems_libio_semaphore );
200ac98: 7f ff eb 3a call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
200ac9c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return result;
}
200aca0: 81 c7 e0 08 ret <== NOT EXECUTED
200aca4: 81 e8 00 00 restore <== NOT EXECUTED
0200ab44 <rtems_libio_to_fcntl_flags>:
*/
uint32_t rtems_libio_to_fcntl_flags(
uint32_t flags
)
{
200ab44: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200ab48: 82 08 a0 06 and %g2, 6, %g1 <== NOT EXECUTED
200ab4c: 80 a0 60 06 cmp %g1, 6 <== NOT EXECUTED
200ab50: 02 80 00 06 be 200ab68 <rtems_libio_to_fcntl_flags+0x24> <== NOT EXECUTED
200ab54: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200ab58: 83 30 a0 02 srl %g2, 2, %g1 <== NOT EXECUTED
200ab5c: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED
200ab60: 12 80 00 0e bne 200ab98 <rtems_libio_to_fcntl_flags+0x54> <== NOT EXECUTED
200ab64: 90 08 60 01 and %g1, 1, %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 ) {
200ab68: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
200ab6c: 02 80 00 04 be 200ab7c <rtems_libio_to_fcntl_flags+0x38> <== NOT EXECUTED
200ab70: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED
fcntl_flags |= O_NONBLOCK;
200ab74: 03 00 00 10 sethi %hi(0x4000), %g1 <== NOT EXECUTED
200ab78: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200ab7c: 32 80 00 02 bne,a 200ab84 <rtems_libio_to_fcntl_flags+0x40><== NOT EXECUTED
200ab80: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200ab84: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED
200ab88: 32 80 00 02 bne,a 200ab90 <rtems_libio_to_fcntl_flags+0x4c><== NOT EXECUTED
200ab8c: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200ab90: 81 c3 e0 08 retl <== NOT EXECUTED
200ab94: 01 00 00 00 nop <== NOT EXECUTED
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200ab98: 10 bf ff f4 b 200ab68 <rtems_libio_to_fcntl_flags+0x24> <== NOT EXECUTED
200ab9c: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
02004e60 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
2004e60: 9d e3 bf 98 save %sp, -104, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
2004e64: a0 96 20 00 orcc %i0, 0, %l0
2004e68: 02 80 00 1f be 2004ee4 <rtems_memalign+0x84>
2004e6c: 03 00 80 74 sethi %hi(0x201d000), %g1
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2004e70: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 ! 201d1c4 <_System_state_Current>
2004e74: 80 a0 a0 03 cmp %g2, 3
2004e78: 02 80 00 16 be 2004ed0 <rtems_memalign+0x70> <== ALWAYS TAKEN
2004e7c: c0 24 00 00 clr [ %l0 ]
/*
*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2004e80: 7f ff fb 6d call 2003c34 <malloc_deferred_frees_process>
2004e84: b0 10 20 0c mov 0xc, %i0
/*
* Perform the aligned allocation requested
*/
return_this = _Protected_heap_Allocate_aligned(
2004e88: 92 10 00 1a mov %i2, %o1
2004e8c: 94 10 00 19 mov %i1, %o2
2004e90: 11 00 80 73 sethi %hi(0x201cc00), %o0
2004e94: 40 00 13 e4 call 2009e24 <_Protected_heap_Allocate_aligned>
2004e98: 90 12 22 50 or %o0, 0x250, %o0 ! 201ce50 <RTEMS_Malloc_Heap>
&RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
2004e9c: b4 92 20 00 orcc %o0, 0, %i2
2004ea0: 02 80 00 12 be 2004ee8 <rtems_memalign+0x88>
2004ea4: 03 00 80 71 sethi %hi(0x201c400), %g1
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
2004ea8: c2 00 63 44 ld [ %g1 + 0x344 ], %g1 ! 201c744 <rtems_malloc_statistics_helpers>
2004eac: 80 a0 60 00 cmp %g1, 0
2004eb0: 22 80 00 06 be,a 2004ec8 <rtems_memalign+0x68> <== ALWAYS TAKEN
2004eb4: f4 24 00 00 st %i2, [ %l0 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
2004eb8: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
2004ebc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004ec0: 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;
2004ec4: f4 24 00 00 st %i2, [ %l0 ] <== NOT EXECUTED
2004ec8: 81 c7 e0 08 ret
2004ecc: 91 e8 20 00 restore %g0, 0, %o0
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2004ed0: 7f ff fb 3f call 2003bcc <malloc_is_system_state_OK>
2004ed4: 01 00 00 00 nop
2004ed8: 80 8a 20 ff btst 0xff, %o0
2004edc: 12 bf ff e9 bne 2004e80 <rtems_memalign+0x20> <== ALWAYS TAKEN
2004ee0: 01 00 00 00 nop
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
*pointer = return_this;
return 0;
2004ee4: b0 10 20 16 mov 0x16, %i0 ! 16 <PROM_START+0x16>
}
2004ee8: 81 c7 e0 08 ret
2004eec: 81 e8 00 00 restore
0200f21c <rtems_message_queue_create>:
uint32_t count,
size_t max_message_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
200f21c: 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 ) )
200f220: a2 96 20 00 orcc %i0, 0, %l1
200f224: 02 80 00 26 be 200f2bc <rtems_message_queue_create+0xa0>
200f228: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
200f22c: 80 a7 20 00 cmp %i4, 0
200f230: 02 80 00 23 be 200f2bc <rtems_message_queue_create+0xa0> <== NEVER TAKEN
200f234: 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 )
200f238: 80 a6 60 00 cmp %i1, 0
200f23c: 02 80 00 20 be 200f2bc <rtems_message_queue_create+0xa0> <== NEVER TAKEN
200f240: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
if ( max_message_size == 0 )
200f244: 80 a6 a0 00 cmp %i2, 0
200f248: 02 80 00 1d be 200f2bc <rtems_message_queue_create+0xa0> <== NEVER TAKEN
200f24c: b0 10 20 08 mov 8, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
200f250: 05 00 80 c3 sethi %hi(0x2030c00), %g2
200f254: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1 ! 2030d80 <_Thread_Dispatch_disable_level>
200f258: 82 00 60 01 inc %g1
200f25c: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
#endif
#endif
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
200f260: 40 00 26 1f call 2018adc <_Message_queue_Allocate>
200f264: 01 00 00 00 nop
if ( !the_message_queue ) {
200f268: a0 92 20 00 orcc %o0, 0, %l0
200f26c: 02 80 00 26 be 200f304 <rtems_message_queue_create+0xe8>
200f270: 80 8e e0 04 btst 4, %i3
}
#endif
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
200f274: 02 80 00 14 be 200f2c4 <rtems_message_queue_create+0xa8>
200f278: f6 24 20 10 st %i3, [ %l0 + 0x10 ]
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
200f27c: 82 10 20 01 mov 1, %g1
200f280: c2 27 bf f4 st %g1, [ %fp + -12 ]
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
if ( ! _CORE_message_queue_Initialize(
200f284: 94 10 00 19 mov %i1, %o2
200f288: 96 10 00 1a mov %i2, %o3
200f28c: 90 04 20 14 add %l0, 0x14, %o0
200f290: 40 00 0d 6b call 201283c <_CORE_message_queue_Initialize>
200f294: 92 07 bf f4 add %fp, -12, %o1
200f298: 80 8a 20 ff btst 0xff, %o0
200f29c: 12 80 00 0c bne 200f2cc <rtems_message_queue_create+0xb0>
200f2a0: 92 10 00 10 mov %l0, %o1
*/
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
Message_queue_Control *the_message_queue
)
{
_Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
200f2a4: 11 00 80 c4 sethi %hi(0x2031000), %o0
200f2a8: 90 12 20 60 or %o0, 0x60, %o0 ! 2031060 <_Message_queue_Information>
200f2ac: 40 00 13 6e call 2014064 <_Objects_Free>
200f2b0: 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();
200f2b4: 40 00 16 6e call 2014c6c <_Thread_Enable_dispatch>
200f2b8: 01 00 00 00 nop
200f2bc: 81 c7 e0 08 ret
200f2c0: 81 e8 00 00 restore
the_message_queue->attribute_set = attribute_set;
if (_Attributes_Is_priority( attribute_set ) )
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
else
the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
200f2c4: 10 bf ff f0 b 200f284 <rtems_message_queue_create+0x68>
200f2c8: c0 27 bf f4 clr [ %fp + -12 ]
200f2cc: c4 04 20 08 ld [ %l0 + 8 ], %g2
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200f2d0: e2 24 20 0c st %l1, [ %l0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200f2d4: 03 00 80 c4 sethi %hi(0x2031000), %g1
200f2d8: c6 00 60 7c ld [ %g1 + 0x7c ], %g3 ! 203107c <_Message_queue_Information+0x1c>
&_Message_queue_Information,
&the_message_queue->Object,
(Objects_Name) name
);
*id = the_message_queue->Object.id;
200f2dc: c4 27 00 00 st %g2, [ %i4 ]
200f2e0: 03 00 00 3f sethi %hi(0xfc00), %g1
200f2e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
200f2e8: 84 08 80 01 and %g2, %g1, %g2
200f2ec: 85 28 a0 02 sll %g2, 2, %g2
name,
0
);
#endif
_Thread_Enable_dispatch();
200f2f0: b0 10 20 00 clr %i0
200f2f4: 40 00 16 5e call 2014c6c <_Thread_Enable_dispatch>
200f2f8: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
return RTEMS_SUCCESSFUL;
}
200f2fc: 81 c7 e0 08 ret
200f300: 81 e8 00 00 restore
_Thread_Disable_dispatch(); /* protects object pointer */
the_message_queue = _Message_queue_Allocate();
if ( !the_message_queue ) {
_Thread_Enable_dispatch();
200f304: 40 00 16 5a call 2014c6c <_Thread_Enable_dispatch>
200f308: b0 10 20 05 mov 5, %i0
200f30c: 81 c7 e0 08 ret
200f310: 81 e8 00 00 restore
0200f37c <rtems_message_queue_flush>:
rtems_status_code rtems_message_queue_flush(
Objects_Id id,
uint32_t *count
)
{
200f37c: 9d e3 bf 90 save %sp, -112, %sp
200f380: 92 10 00 18 mov %i0, %o1
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
200f384: 80 a6 60 00 cmp %i1, 0
200f388: 02 80 00 0f be 200f3c4 <rtems_message_queue_flush+0x48> <== NEVER TAKEN
200f38c: 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 *)
200f390: 11 00 80 c4 sethi %hi(0x2031000), %o0
200f394: 94 07 bf f4 add %fp, -12, %o2
200f398: 40 00 13 b2 call 2014260 <_Objects_Get>
200f39c: 90 12 20 60 or %o0, 0x60, %o0
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
200f3a0: c2 07 bf f4 ld [ %fp + -12 ], %g1
200f3a4: 80 a0 60 00 cmp %g1, 0
200f3a8: 12 80 00 07 bne 200f3c4 <rtems_message_queue_flush+0x48>
200f3ac: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
200f3b0: 40 00 0d 03 call 20127bc <_CORE_message_queue_Flush>
200f3b4: 90 02 20 14 add %o0, 0x14, %o0
_Thread_Enable_dispatch();
200f3b8: b0 10 20 00 clr %i0
200f3bc: 40 00 16 2c call 2014c6c <_Thread_Enable_dispatch>
200f3c0: d0 26 40 00 st %o0, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f3c4: 81 c7 e0 08 ret
200f3c8: 81 e8 00 00 restore
0200f3cc <rtems_message_queue_get_number_pending>:
rtems_status_code rtems_message_queue_get_number_pending(
Objects_Id id,
uint32_t *count
)
{
200f3cc: 9d e3 bf 90 save %sp, -112, %sp
200f3d0: 92 10 00 18 mov %i0, %o1
register Message_queue_Control *the_message_queue;
Objects_Locations location;
if ( !count )
200f3d4: 80 a6 60 00 cmp %i1, 0
200f3d8: 02 80 00 0e be 200f410 <rtems_message_queue_get_number_pending+0x44><== NEVER TAKEN
200f3dc: b0 10 20 09 mov 9, %i0
200f3e0: 11 00 80 c4 sethi %hi(0x2031000), %o0
200f3e4: 94 07 bf f4 add %fp, -12, %o2
200f3e8: 40 00 13 9e call 2014260 <_Objects_Get>
200f3ec: 90 12 20 60 or %o0, 0x60, %o0
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
200f3f0: c2 07 bf f4 ld [ %fp + -12 ], %g1
200f3f4: 80 a0 60 00 cmp %g1, 0
200f3f8: 12 80 00 06 bne 200f410 <rtems_message_queue_get_number_pending+0x44>
200f3fc: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*count = the_message_queue->message_queue.number_of_pending_messages;
200f400: c2 02 20 5c ld [ %o0 + 0x5c ], %g1
_Thread_Enable_dispatch();
200f404: b0 10 20 00 clr %i0
200f408: 40 00 16 19 call 2014c6c <_Thread_Enable_dispatch>
200f40c: c2 26 40 00 st %g1, [ %i1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f410: 81 c7 e0 08 ret
200f414: 81 e8 00 00 restore
0200f4dc <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
Objects_Id id,
const void *buffer,
size_t size
)
{
200f4dc: 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 )
200f4e0: 80 a6 60 00 cmp %i1, 0
200f4e4: 02 80 00 0c be 200f514 <rtems_message_queue_send+0x38> <== NEVER TAKEN
200f4e8: 90 10 20 09 mov 9, %o0
200f4ec: 11 00 80 c4 sethi %hi(0x2031000), %o0
200f4f0: 92 10 00 18 mov %i0, %o1
200f4f4: 90 12 20 60 or %o0, 0x60, %o0
200f4f8: 40 00 13 5a call 2014260 <_Objects_Get>
200f4fc: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
200f500: c2 07 bf f4 ld [ %fp + -12 ], %g1
200f504: 84 10 00 08 mov %o0, %g2
200f508: 80 a0 60 00 cmp %g1, 0
200f50c: 02 80 00 04 be 200f51c <rtems_message_queue_send+0x40>
200f510: 90 10 20 04 mov 4, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f514: 81 c7 e0 08 ret
200f518: 91 e8 00 08 restore %g0, %o0, %o0
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
200f51c: 96 10 00 18 mov %i0, %o3
200f520: 92 10 00 19 mov %i1, %o1
200f524: 94 10 00 1a mov %i2, %o2
200f528: 90 00 a0 14 add %g2, 0x14, %o0
200f52c: 98 10 20 00 clr %o4
200f530: c0 23 a0 5c clr [ %sp + 0x5c ]
200f534: c0 23 a0 60 clr [ %sp + 0x60 ]
200f538: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5
200f53c: 40 00 0d 31 call 2012a00 <_CORE_message_queue_Submit>
200f540: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff <RAM_END+0x7dbfffff>
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
200f544: 40 00 15 ca call 2014c6c <_Thread_Enable_dispatch>
200f548: 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);
200f54c: 40 00 00 04 call 200f55c <_Message_queue_Translate_core_message_queue_return_code>
200f550: 90 10 00 10 mov %l0, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f554: 81 c7 e0 08 ret
200f558: 91 e8 00 08 restore %g0, %o0, %o0
0200f570 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
Objects_Id id,
const void *buffer,
size_t size
)
{
200f570: 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 )
200f574: 80 a6 60 00 cmp %i1, 0
200f578: 02 80 00 0c be 200f5a8 <rtems_message_queue_urgent+0x38> <== NEVER TAKEN
200f57c: 90 10 20 09 mov 9, %o0
200f580: 11 00 80 c4 sethi %hi(0x2031000), %o0
200f584: 92 10 00 18 mov %i0, %o1
200f588: 90 12 20 60 or %o0, 0x60, %o0
200f58c: 40 00 13 35 call 2014260 <_Objects_Get>
200f590: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
200f594: c2 07 bf f4 ld [ %fp + -12 ], %g1
200f598: 84 10 00 08 mov %o0, %g2
200f59c: 80 a0 60 00 cmp %g1, 0
200f5a0: 02 80 00 04 be 200f5b0 <rtems_message_queue_urgent+0x40>
200f5a4: 90 10 20 04 mov 4, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f5a8: 81 c7 e0 08 ret
200f5ac: 91 e8 00 08 restore %g0, %o0, %o0
CORE_message_queue_API_mp_support_callout api_message_queue_mp_support,
bool wait,
Watchdog_Interval timeout
)
{
return _CORE_message_queue_Submit(
200f5b0: 96 10 00 18 mov %i0, %o3
200f5b4: 92 10 00 19 mov %i1, %o1
200f5b8: 94 10 00 1a mov %i2, %o2
200f5bc: 90 00 a0 14 add %g2, 0x14, %o0
200f5c0: 98 10 20 00 clr %o4
200f5c4: 1b 20 00 00 sethi %hi(0x80000000), %o5
200f5c8: c0 23 a0 5c clr [ %sp + 0x5c ]
200f5cc: 40 00 0d 0d call 2012a00 <_CORE_message_queue_Submit>
200f5d0: c0 23 a0 60 clr [ %sp + 0x60 ]
id,
MESSAGE_QUEUE_MP_HANDLER,
FALSE, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
200f5d4: 40 00 15 a6 call 2014c6c <_Thread_Enable_dispatch>
200f5d8: 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);
200f5dc: 7f ff ff e0 call 200f55c <_Message_queue_Translate_core_message_queue_return_code>
200f5e0: 90 10 00 10 mov %l0, %o0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f5e4: 81 c7 e0 08 ret
200f5e8: 91 e8 00 08 restore %g0, %o0, %o0
02006f14 <rtems_object_get_class_information>:
rtems_status_code rtems_object_get_class_information(
uint32_t the_api,
uint32_t the_class,
rtems_object_api_class_information *info
)
{
2006f14: 9d e3 bf 98 save %sp, -104, %sp
2006f18: 90 10 00 18 mov %i0, %o0
2006f1c: 92 10 00 19 mov %i1, %o1
uint32_t i;
/*
* Validate parameters and look up information structure.
*/
if ( !info )
2006f20: 80 a6 a0 00 cmp %i2, 0
2006f24: 02 80 00 1f be 2006fa0 <rtems_object_get_class_information+0x8c>
2006f28: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
obj_info = _Objects_Get_information( the_api, the_class );
2006f2c: 40 00 07 09 call 2008b50 <_Objects_Get_information>
2006f30: b0 10 20 0a mov 0xa, %i0
if ( !obj_info )
2006f34: 80 a2 20 00 cmp %o0, 0
2006f38: 02 80 00 1a be 2006fa0 <rtems_object_get_class_information+0x8c>
2006f3c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
2006f40: c2 02 20 08 ld [ %o0 + 8 ], %g1
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
2006f44: da 12 20 10 lduh [ %o0 + 0x10 ], %o5
return RTEMS_INVALID_NUMBER;
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
2006f48: c2 26 80 00 st %g1, [ %i2 ]
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
2006f4c: c4 0a 20 12 ldub [ %o0 + 0x12 ], %g2
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
2006f50: c2 02 20 0c ld [ %o0 + 0xc ], %g1
info->auto_extend = obj_info->auto_extend;
2006f54: c4 2e a0 0c stb %g2, [ %i2 + 0xc ]
/*
* Return information about this object class to the user.
*/
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
2006f58: c2 26 a0 04 st %g1, [ %i2 + 4 ]
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
2006f5c: da 26 a0 08 st %o5, [ %i2 + 8 ]
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
2006f60: 80 a3 60 00 cmp %o5, 0
2006f64: 02 80 00 0d be 2006f98 <rtems_object_get_class_information+0x84><== NEVER TAKEN
2006f68: 88 10 20 00 clr %g4
2006f6c: d0 02 20 1c ld [ %o0 + 0x1c ], %o0
2006f70: 88 10 20 00 clr %g4
2006f74: 86 10 20 01 mov 1, %g3
if ( !obj_info->local_table[i] )
2006f78: 83 28 e0 02 sll %g3, 2, %g1
2006f7c: c4 02 00 01 ld [ %o0 + %g1 ], %g2
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
2006f80: 86 00 e0 01 inc %g3
if ( !obj_info->local_table[i] )
unallocated++;
2006f84: 80 a0 00 02 cmp %g0, %g2
2006f88: 88 61 3f ff subx %g4, -1, %g4
info->minimum_id = obj_info->minimum_id;
info->maximum_id = obj_info->maximum_id;
info->auto_extend = obj_info->auto_extend;
info->maximum = obj_info->maximum;
for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
2006f8c: 80 a3 40 03 cmp %o5, %g3
2006f90: 1a bf ff fb bcc 2006f7c <rtems_object_get_class_information+0x68>
2006f94: 83 28 e0 02 sll %g3, 2, %g1
if ( !obj_info->local_table[i] )
unallocated++;
info->unallocated = unallocated;
2006f98: c8 26 a0 10 st %g4, [ %i2 + 0x10 ]
2006f9c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
2006fa0: 81 c7 e0 08 ret
2006fa4: 81 e8 00 00 restore
02006ff8 <rtems_object_set_name>:
*/
rtems_status_code rtems_object_set_name(
rtems_id id,
const char *name
)
{
2006ff8: 9d e3 bf 90 save %sp, -112, %sp
2006ffc: 90 10 00 18 mov %i0, %o0
Objects_Information *information;
Objects_Locations location;
Objects_Control *the_object;
Objects_Id tmpId;
if ( !name )
2007000: 80 a6 60 00 cmp %i1, 0
2007004: 02 80 00 16 be 200705c <rtems_object_set_name+0x64> <== NEVER TAKEN
2007008: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
200700c: b0 92 20 00 orcc %o0, 0, %i0
2007010: 02 80 00 18 be 2007070 <rtems_object_set_name+0x78>
2007014: 03 00 80 71 sethi %hi(0x201c400), %g1
information = _Objects_Get_information_id( tmpId );
2007018: 40 00 06 c7 call 2008b34 <_Objects_Get_information_id>
200701c: 90 10 00 18 mov %i0, %o0
if ( !information )
2007020: a0 92 20 00 orcc %o0, 0, %l0
2007024: 02 80 00 10 be 2007064 <rtems_object_set_name+0x6c>
2007028: 92 10 00 18 mov %i0, %o1
return RTEMS_INVALID_ID;
the_object = _Objects_Get( information, tmpId, &location );
200702c: 40 00 07 56 call 2008d84 <_Objects_Get>
2007030: 94 07 bf f4 add %fp, -12, %o2
switch ( location ) {
2007034: c2 07 bf f4 ld [ %fp + -12 ], %g1
2007038: 80 a0 60 00 cmp %g1, 0
200703c: 32 80 00 08 bne,a 200705c <rtems_object_set_name+0x64>
2007040: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
_Objects_Set_name( information, the_object, name );
2007044: 92 10 00 08 mov %o0, %o1
2007048: 94 10 00 19 mov %i1, %o2
200704c: 40 00 07 e6 call 2008fe4 <_Objects_Set_name>
2007050: 90 10 00 10 mov %l0, %o0
_Thread_Enable_dispatch();
2007054: 40 00 0a 13 call 20098a0 <_Thread_Enable_dispatch>
2007058: b0 10 20 00 clr %i0
200705c: 81 c7 e0 08 ret
2007060: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
2007064: b0 10 20 04 mov 4, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2007068: 81 c7 e0 08 ret
200706c: 81 e8 00 00 restore
Objects_Id tmpId;
if ( !name )
return RTEMS_INVALID_ADDRESS;
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
2007070: c4 00 62 f4 ld [ %g1 + 0x2f4 ], %g2
2007074: 10 bf ff e9 b 2007018 <rtems_object_set_name+0x20>
2007078: f0 00 a0 08 ld [ %g2 + 8 ], %i0
02003044 <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
2003044: 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);
2003048: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
200304c: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED
2003050: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2003054: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2003058: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
200305c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
2003060: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
2003064: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2003068: 7f ff ff 7d call 2002e5c <rtems_verror> <== NOT EXECUTED
200306c: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED
va_end(arglist);
}
2003070: 81 c7 e0 08 ret <== NOT EXECUTED
2003074: 81 e8 00 00 restore <== NOT EXECUTED
0200f5ec <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
Objects_Id *id
)
{
200f5ec: 9d e3 bf 98 save %sp, -104, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
200f5f0: a4 96 20 00 orcc %i0, 0, %l2
200f5f4: 02 80 00 36 be 200f6cc <rtems_partition_create+0xe0>
200f5f8: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !starting_address )
200f5fc: 80 a6 60 00 cmp %i1, 0
200f600: 02 80 00 35 be 200f6d4 <rtems_partition_create+0xe8> <== NEVER TAKEN
200f604: 80 a7 60 00 cmp %i5, 0
return RTEMS_INVALID_ADDRESS;
if ( !id )
200f608: 02 80 00 33 be 200f6d4 <rtems_partition_create+0xe8> <== NEVER TAKEN
200f60c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
200f610: 12 80 00 04 bne 200f620 <rtems_partition_create+0x34>
200f614: 80 a6 e0 00 cmp %i3, 0
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
200f618: 81 c7 e0 08 ret
200f61c: 91 e8 20 08 restore %g0, 8, %o0
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
200f620: 02 80 00 2b be 200f6cc <rtems_partition_create+0xe0>
200f624: b0 10 20 08 mov 8, %i0
200f628: 80 a6 80 1b cmp %i2, %i3
200f62c: 0a 80 00 28 bcs 200f6cc <rtems_partition_create+0xe0>
200f630: 80 8e e0 07 btst 7, %i3
200f634: 12 80 00 26 bne 200f6cc <rtems_partition_create+0xe0>
200f638: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
200f63c: 12 80 00 26 bne 200f6d4 <rtems_partition_create+0xe8>
200f640: 05 00 80 c3 sethi %hi(0x2030c00), %g2
200f644: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1 ! 2030d80 <_Thread_Dispatch_disable_level>
200f648: 82 00 60 01 inc %g1
200f64c: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
* 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 );
200f650: 31 00 80 c2 sethi %hi(0x2030800), %i0
200f654: 40 00 11 89 call 2013c78 <_Objects_Allocate>
200f658: 90 16 23 34 or %i0, 0x334, %o0 ! 2030b34 <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
200f65c: a2 92 20 00 orcc %o0, 0, %l1
200f660: 02 80 00 1f be 200f6dc <rtems_partition_create+0xf0>
200f664: 92 10 00 1b mov %i3, %o1
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
200f668: f8 24 60 1c st %i4, [ %l1 + 0x1c ]
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
200f66c: f2 24 60 10 st %i1, [ %l1 + 0x10 ]
the_partition->length = length;
200f670: f4 24 60 14 st %i2, [ %l1 + 0x14 ]
the_partition->buffer_size = buffer_size;
200f674: f6 24 60 18 st %i3, [ %l1 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
200f678: c0 24 60 20 clr [ %l1 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
200f67c: 40 00 4c ba call 2022964 <.udiv>
200f680: 90 10 00 1a mov %i2, %o0
200f684: 92 10 00 19 mov %i1, %o1
200f688: 94 10 00 08 mov %o0, %o2
200f68c: 96 10 00 1b mov %i3, %o3
200f690: a0 04 60 24 add %l1, 0x24, %l0
200f694: 40 00 0c 06 call 20126ac <_Chain_Initialize>
200f698: 90 10 00 10 mov %l0, %o0
200f69c: c4 04 60 08 ld [ %l1 + 8 ], %g2
200f6a0: 82 16 23 34 or %i0, 0x334, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200f6a4: e4 24 60 0c st %l2, [ %l1 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200f6a8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
200f6ac: c4 27 40 00 st %g2, [ %i5 ]
200f6b0: 03 00 00 3f sethi %hi(0xfc00), %g1
200f6b4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
200f6b8: 84 08 80 01 and %g2, %g1, %g2
200f6bc: 85 28 a0 02 sll %g2, 2, %g2
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
200f6c0: b0 10 20 00 clr %i0
200f6c4: 40 00 15 6a call 2014c6c <_Thread_Enable_dispatch>
200f6c8: e2 20 c0 02 st %l1, [ %g3 + %g2 ]
200f6cc: 81 c7 e0 08 ret
200f6d0: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
200f6d4: 81 c7 e0 08 ret
200f6d8: 91 e8 20 09 restore %g0, 9, %o0
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
_Thread_Enable_dispatch();
200f6dc: 40 00 15 64 call 2014c6c <_Thread_Enable_dispatch>
200f6e0: b0 10 20 05 mov 5, %i0
200f6e4: 81 c7 e0 08 ret
200f6e8: 81 e8 00 00 restore
0200f760 <rtems_partition_get_buffer>:
rtems_status_code rtems_partition_get_buffer(
Objects_Id id,
void **buffer
)
{
200f760: 9d e3 bf 90 save %sp, -112, %sp
200f764: 92 10 00 18 mov %i0, %o1
register Partition_Control *the_partition;
Objects_Locations location;
void *the_buffer;
if ( !buffer )
200f768: 80 a6 60 00 cmp %i1, 0
200f76c: 02 80 00 19 be 200f7d0 <rtems_partition_get_buffer+0x70> <== NEVER TAKEN
200f770: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
200f774: 11 00 80 c2 sethi %hi(0x2030800), %o0
200f778: 94 07 bf f4 add %fp, -12, %o2
200f77c: 40 00 12 b9 call 2014260 <_Objects_Get>
200f780: 90 12 23 34 or %o0, 0x334, %o0
return RTEMS_INVALID_ADDRESS;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
200f784: c2 07 bf f4 ld [ %fp + -12 ], %g1
200f788: a0 10 00 08 mov %o0, %l0
200f78c: 80 a0 60 00 cmp %g1, 0
200f790: 12 80 00 10 bne 200f7d0 <rtems_partition_get_buffer+0x70>
200f794: b0 10 20 04 mov 4, %i0
*/
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
Partition_Control *the_partition
)
{
return _Chain_Get( &the_partition->Memory );
200f798: 40 00 0b b2 call 2012660 <_Chain_Get>
200f79c: 90 02 20 24 add %o0, 0x24, %o0
case OBJECTS_LOCAL:
the_buffer = _Partition_Allocate_buffer( the_partition );
if ( the_buffer ) {
200f7a0: b0 92 20 00 orcc %o0, 0, %i0
200f7a4: 02 80 00 09 be 200f7c8 <rtems_partition_get_buffer+0x68>
200f7a8: 01 00 00 00 nop
the_partition->number_of_used_blocks += 1;
200f7ac: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
200f7b0: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
200f7b4: 40 00 15 2e call 2014c6c <_Thread_Enable_dispatch>
200f7b8: c2 24 20 20 st %g1, [ %l0 + 0x20 ]
*buffer = the_buffer;
200f7bc: f0 26 40 00 st %i0, [ %i1 ]
200f7c0: 81 c7 e0 08 ret
200f7c4: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
200f7c8: 40 00 15 29 call 2014c6c <_Thread_Enable_dispatch>
200f7cc: b0 10 20 0d mov 0xd, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200f7d0: 81 c7 e0 08 ret
200f7d4: 81 e8 00 00 restore
0200eb30 <rtems_port_create>:
void *internal_start,
void *external_start,
uint32_t length,
Objects_Id *id
)
{
200eb30: 9d e3 bf 98 save %sp, -104, %sp
register Dual_ported_memory_Control *the_port;
if ( !rtems_is_name_valid( name) )
200eb34: a0 96 20 00 orcc %i0, 0, %l0
200eb38: 02 80 00 22 be 200ebc0 <rtems_port_create+0x90>
200eb3c: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
200eb40: 80 a7 20 00 cmp %i4, 0
200eb44: 02 80 00 05 be 200eb58 <rtems_port_create+0x28> <== NEVER TAKEN
200eb48: 82 16 80 19 or %i2, %i1, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_Addresses_Is_aligned( internal_start ) ||
200eb4c: 80 88 60 07 btst 7, %g1
200eb50: 02 80 00 04 be 200eb60 <rtems_port_create+0x30>
200eb54: 05 00 80 c3 sethi %hi(0x2030c00), %g2
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
200eb58: 81 c7 e0 08 ret
200eb5c: 91 e8 20 09 restore %g0, 9, %o0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
200eb60: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1
200eb64: 82 00 60 01 inc %g1
200eb68: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
* of free port control blocks.
*/
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control
*_Dual_ported_memory_Allocate ( void )
{
return (Dual_ported_memory_Control *)
200eb6c: 31 00 80 c2 sethi %hi(0x2030800), %i0
200eb70: 40 00 14 42 call 2013c78 <_Objects_Allocate>
200eb74: 90 16 22 f4 or %i0, 0x2f4, %o0 ! 2030af4 <_Dual_ported_memory_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
200eb78: 80 a2 20 00 cmp %o0, 0
200eb7c: 02 80 00 13 be 200ebc8 <rtems_port_create+0x98>
200eb80: 82 16 22 f4 or %i0, 0x2f4, %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200eb84: c4 02 20 08 ld [ %o0 + 8 ], %g2
200eb88: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200eb8c: e0 22 20 0c st %l0, [ %o0 + 0xc ]
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
the_port->external_base = external_start;
the_port->length = length - 1;
200eb90: 82 06 ff ff add %i3, -1, %g1
200eb94: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
&_Dual_ported_memory_Information,
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
200eb98: c4 27 00 00 st %g2, [ %i4 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200eb9c: 03 00 00 3f sethi %hi(0xfc00), %g1
200eba0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
200eba4: 84 08 80 01 and %g2, %g1, %g2
200eba8: 85 28 a0 02 sll %g2, 2, %g2
if ( !the_port ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_port->internal_base = internal_start;
200ebac: f2 22 20 10 st %i1, [ %o0 + 0x10 ]
the_port->external_base = external_start;
200ebb0: f4 22 20 14 st %i2, [ %o0 + 0x14 ]
200ebb4: d0 20 c0 02 st %o0, [ %g3 + %g2 ]
&the_port->Object,
(Objects_Name) name
);
*id = the_port->Object.id;
_Thread_Enable_dispatch();
200ebb8: 40 00 18 2d call 2014c6c <_Thread_Enable_dispatch>
200ebbc: b0 10 20 00 clr %i0
200ebc0: 81 c7 e0 08 ret
200ebc4: 81 e8 00 00 restore
_Thread_Disable_dispatch(); /* to prevent deletion */
the_port = _Dual_ported_memory_Allocate();
if ( !the_port ) {
_Thread_Enable_dispatch();
200ebc8: 40 00 18 29 call 2014c6c <_Thread_Enable_dispatch>
200ebcc: b0 10 20 05 mov 5, %i0
200ebd0: 81 c7 e0 08 ret
200ebd4: 81 e8 00 00 restore
0200ec30 <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
Objects_Id id,
void *external,
void **internal
)
{
200ec30: 9d e3 bf 90 save %sp, -112, %sp
200ec34: 92 10 00 18 mov %i0, %o1
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !internal )
200ec38: 80 a6 a0 00 cmp %i2, 0
200ec3c: 02 80 00 13 be 200ec88 <rtems_port_external_to_internal+0x58><== NEVER TAKEN
200ec40: 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 *)
200ec44: 11 00 80 c2 sethi %hi(0x2030800), %o0
200ec48: 94 07 bf f4 add %fp, -12, %o2
200ec4c: 40 00 15 85 call 2014260 <_Objects_Get>
200ec50: 90 12 22 f4 or %o0, 0x2f4, %o0
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
200ec54: c2 07 bf f4 ld [ %fp + -12 ], %g1
200ec58: 80 a0 60 00 cmp %g1, 0
200ec5c: 12 80 00 0b bne 200ec88 <rtems_port_external_to_internal+0x58>
200ec60: b0 10 20 04 mov 4, %i0
RTEMS_INLINE_ROUTINE uint32_t _Addresses_Subtract (
void *left,
void *right
)
{
return ((char *) left - (char *) right);
200ec64: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
200ec68: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
200ec6c: 86 26 40 01 sub %i1, %g1, %g3
200ec70: 80 a0 80 03 cmp %g2, %g3
200ec74: 3a 80 00 07 bcc,a 200ec90 <rtems_port_external_to_internal+0x60>
200ec78: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
*internal = external;
200ec7c: f2 26 80 00 st %i1, [ %i2 ]
else
*internal = _Addresses_Add_offset( the_port->internal_base,
ending );
_Thread_Enable_dispatch();
200ec80: 40 00 17 fb call 2014c6c <_Thread_Enable_dispatch>
200ec84: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200ec88: 81 c7 e0 08 ret
200ec8c: 81 e8 00 00 restore
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( external, the_port->external_base );
if ( ending > the_port->length )
*internal = external;
else
*internal = _Addresses_Add_offset( the_port->internal_base,
200ec90: 82 00 40 03 add %g1, %g3, %g1
200ec94: 10 bf ff fb b 200ec80 <rtems_port_external_to_internal+0x50>
200ec98: c2 26 80 00 st %g1, [ %i2 ]
0200ecd0 <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
Objects_Id id,
void *internal,
void **external
)
{
200ecd0: 9d e3 bf 90 save %sp, -112, %sp
200ecd4: 92 10 00 18 mov %i0, %o1
register Dual_ported_memory_Control *the_port;
Objects_Locations location;
uint32_t ending;
if ( !external )
200ecd8: 80 a6 a0 00 cmp %i2, 0
200ecdc: 02 80 00 13 be 200ed28 <rtems_port_internal_to_external+0x58><== NEVER TAKEN
200ece0: b0 10 20 09 mov 9, %i0
200ece4: 11 00 80 c2 sethi %hi(0x2030800), %o0
200ece8: 94 07 bf f4 add %fp, -12, %o2
200ecec: 40 00 15 5d call 2014260 <_Objects_Get>
200ecf0: 90 12 22 f4 or %o0, 0x2f4, %o0
return RTEMS_INVALID_ADDRESS;
the_port = _Dual_ported_memory_Get( id, &location );
switch ( location ) {
200ecf4: c2 07 bf f4 ld [ %fp + -12 ], %g1
200ecf8: 80 a0 60 00 cmp %g1, 0
200ecfc: 12 80 00 0b bne 200ed28 <rtems_port_internal_to_external+0x58>
200ed00: b0 10 20 04 mov 4, %i0
200ed04: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
200ed08: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
200ed0c: 86 26 40 01 sub %i1, %g1, %g3
200ed10: 80 a0 80 03 cmp %g2, %g3
200ed14: 3a 80 00 07 bcc,a 200ed30 <rtems_port_internal_to_external+0x60>
200ed18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
*external = internal;
200ed1c: f2 26 80 00 st %i1, [ %i2 ]
else
*external = _Addresses_Add_offset( the_port->external_base,
ending );
_Thread_Enable_dispatch();
200ed20: 40 00 17 d3 call 2014c6c <_Thread_Enable_dispatch>
200ed24: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200ed28: 81 c7 e0 08 ret
200ed2c: 81 e8 00 00 restore
case OBJECTS_LOCAL:
ending = _Addresses_Subtract( internal, the_port->internal_base );
if ( ending > the_port->length )
*external = internal;
else
*external = _Addresses_Add_offset( the_port->external_base,
200ed30: 82 00 40 03 add %g1, %g3, %g1
200ed34: 10 bf ff fb b 200ed20 <rtems_port_internal_to_external+0x50>
200ed38: c2 26 80 00 st %g1, [ %i2 ]
020066f0 <rtems_rate_monotonic_create>:
rtems_status_code rtems_rate_monotonic_create(
rtems_name name,
Objects_Id *id
)
{
20066f0: 9d e3 bf 98 save %sp, -104, %sp
Rate_monotonic_Control *the_period;
if ( !rtems_is_name_valid( name ) )
20066f4: a2 96 20 00 orcc %i0, 0, %l1
20066f8: 02 80 00 33 be 20067c4 <rtems_rate_monotonic_create+0xd4>
20066fc: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
2006700: 80 a6 60 00 cmp %i1, 0
2006704: 02 80 00 30 be 20067c4 <rtems_rate_monotonic_create+0xd4> <== NEVER TAKEN
2006708: b0 10 20 09 mov 9, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
200670c: 05 00 80 6f sethi %hi(0x201bc00), %g2
2006710: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 201bed0 <_Thread_Dispatch_disable_level>
2006714: 82 00 60 01 inc %g1
2006718: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
* 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 *)
200671c: 21 00 80 6f sethi %hi(0x201bc00), %l0
2006720: 40 00 08 2b call 20087cc <_Objects_Allocate>
2006724: 90 14 21 54 or %l0, 0x154, %o0 ! 201bd54 <_Rate_monotonic_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
2006728: 80 a2 20 00 cmp %o0, 0
200672c: 02 80 00 28 be 20067cc <rtems_rate_monotonic_create+0xdc>
2006730: 03 00 80 6f sethi %hi(0x201bc00), %g1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
2006734: c4 00 63 94 ld [ %g1 + 0x394 ], %g2 ! 201bf94 <_Thread_Executing>
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
2006738: c0 22 20 30 clr [ %o0 + 0x30 ]
the_period->state = RATE_MONOTONIC_INACTIVE;
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
200673c: c0 22 20 54 clr [ %o0 + 0x54 ]
if ( !the_period ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_period->owner = _Thread_Executing;
2006740: c4 22 20 50 st %g2, [ %o0 + 0x50 ]
the_period->state = RATE_MONOTONIC_INACTIVE;
2006744: c0 22 20 38 clr [ %o0 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2006748: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
200674c: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2006750: c0 22 20 34 clr [ %o0 + 0x34 ]
_Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );
_Rate_monotonic_Reset_statistics( the_period );
2006754: 82 02 20 54 add %o0, 0x54, %g1
2006758: c0 20 60 34 clr [ %g1 + 0x34 ]
200675c: c0 20 60 04 clr [ %g1 + 4 ]
2006760: c0 20 60 10 clr [ %g1 + 0x10 ]
2006764: c0 20 60 14 clr [ %g1 + 0x14 ]
2006768: c0 20 60 18 clr [ %g1 + 0x18 ]
200676c: c0 20 60 1c clr [ %g1 + 0x1c ]
2006770: c0 20 60 28 clr [ %g1 + 0x28 ]
2006774: c0 20 60 2c clr [ %g1 + 0x2c ]
2006778: c0 20 60 30 clr [ %g1 + 0x30 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200677c: c4 02 20 08 ld [ %o0 + 8 ], %g2
2006780: 86 14 21 54 or %l0, 0x154, %g3
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2006784: e2 22 20 0c st %l1, [ %o0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2006788: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
200678c: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
2006790: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x7dbfffff>
2006794: c2 22 20 78 st %g1, [ %o0 + 0x78 ]
2006798: c2 22 20 5c st %g1, [ %o0 + 0x5c ]
200679c: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
20067a0: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
&_Rate_monotonic_Information,
&the_period->Object,
(Objects_Name) name
);
*id = the_period->Object.id;
20067a4: c4 26 40 00 st %g2, [ %i1 ]
20067a8: 03 00 00 3f sethi %hi(0xfc00), %g1
20067ac: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
20067b0: 84 08 80 01 and %g2, %g1, %g2
20067b4: 85 28 a0 02 sll %g2, 2, %g2
_Thread_Enable_dispatch();
20067b8: b0 10 20 00 clr %i0
20067bc: 40 00 0c 3b call 20098a8 <_Thread_Enable_dispatch>
20067c0: d0 21 00 02 st %o0, [ %g4 + %g2 ]
return RTEMS_SUCCESSFUL;
}
20067c4: 81 c7 e0 08 ret
20067c8: 81 e8 00 00 restore
_Thread_Disable_dispatch(); /* to prevent deletion */
the_period = _Rate_monotonic_Allocate();
if ( !the_period ) {
_Thread_Enable_dispatch();
20067cc: 40 00 0c 37 call 20098a8 <_Thread_Enable_dispatch>
20067d0: b0 10 20 05 mov 5, %i0
20067d4: 81 c7 e0 08 ret
20067d8: 81 e8 00 00 restore
0200d56c <rtems_rate_monotonic_get_statistics>:
rtems_status_code rtems_rate_monotonic_get_statistics(
Objects_Id id,
rtems_rate_monotonic_period_statistics *statistics
)
{
200d56c: 9d e3 bf 90 save %sp, -112, %sp
200d570: 92 10 00 18 mov %i0, %o1
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !statistics )
200d574: 80 a6 60 00 cmp %i1, 0
200d578: 02 80 00 10 be 200d5b8 <rtems_rate_monotonic_get_statistics+0x4c><== NEVER TAKEN
200d57c: b0 10 20 09 mov 9, %i0
200d580: 11 00 80 6f sethi %hi(0x201bc00), %o0
200d584: 94 07 bf f4 add %fp, -12, %o2
200d588: 7f ff ee 45 call 2008e9c <_Objects_Get>
200d58c: 90 12 21 54 or %o0, 0x154, %o0
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
200d590: c2 07 bf f4 ld [ %fp + -12 ], %g1
200d594: 80 a0 60 00 cmp %g1, 0
200d598: 12 80 00 08 bne 200d5b8 <rtems_rate_monotonic_get_statistics+0x4c>
200d59c: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
*statistics = the_period->Statistics;
200d5a0: 92 02 20 54 add %o0, 0x54, %o1
200d5a4: 94 10 20 38 mov 0x38, %o2
200d5a8: 40 00 08 4a call 200f6d0 <memcpy>
200d5ac: 90 10 00 19 mov %i1, %o0
_Thread_Enable_dispatch();
200d5b0: 7f ff f0 be call 20098a8 <_Thread_Enable_dispatch>
200d5b4: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200d5b8: 81 c7 e0 08 ret
200d5bc: 81 e8 00 00 restore
0200d5c0 <rtems_rate_monotonic_get_status>:
rtems_status_code rtems_rate_monotonic_get_status(
Objects_Id id,
rtems_rate_monotonic_period_status *status
)
{
200d5c0: 9d e3 bf 88 save %sp, -120, %sp
200d5c4: 92 10 00 18 mov %i0, %o1
Objects_Locations location;
Rate_monotonic_Control *the_period;
if ( !status )
200d5c8: 80 a6 60 00 cmp %i1, 0
200d5cc: 02 80 00 1b be 200d638 <rtems_rate_monotonic_get_status+0x78><== NEVER TAKEN
200d5d0: b0 10 20 09 mov 9, %i0
200d5d4: 11 00 80 6f sethi %hi(0x201bc00), %o0
200d5d8: 94 07 bf f4 add %fp, -12, %o2
200d5dc: 7f ff ee 30 call 2008e9c <_Objects_Get>
200d5e0: 90 12 21 54 or %o0, 0x154, %o0
return RTEMS_INVALID_ADDRESS;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
200d5e4: c2 07 bf f4 ld [ %fp + -12 ], %g1
200d5e8: a2 10 00 08 mov %o0, %l1
200d5ec: 80 a0 60 00 cmp %g1, 0
200d5f0: 12 80 00 12 bne 200d638 <rtems_rate_monotonic_get_status+0x78>
200d5f4: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
200d5f8: c2 02 20 50 ld [ %o0 + 0x50 ], %g1
200d5fc: 80 a0 60 00 cmp %g1, 0
200d600: 02 80 00 03 be 200d60c <rtems_rate_monotonic_get_status+0x4c><== NEVER TAKEN
200d604: 84 10 20 00 clr %g2
200d608: c4 00 60 08 ld [ %g1 + 8 ], %g2
status->state = the_period->state;
200d60c: 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);
200d610: c4 26 40 00 st %g2, [ %i1 ]
status->state = the_period->state;
if ( status->state == RATE_MONOTONIC_INACTIVE ) {
200d614: 80 a0 60 00 cmp %g1, 0
200d618: 12 80 00 0a bne 200d640 <rtems_rate_monotonic_get_status+0x80>
200d61c: 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;
200d620: 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;
200d624: c0 26 60 08 clr [ %i1 + 8 ]
status->since_last_period.tv_nsec = 0;
200d628: 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;
200d62c: c0 26 60 10 clr [ %i1 + 0x10 ]
the_period->owner->cpu_time_used -
the_period->owner_executed_at_period;
#endif
}
_Thread_Enable_dispatch();
200d630: 7f ff f0 9e call 20098a8 <_Thread_Enable_dispatch>
200d634: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200d638: 81 c7 e0 08 ret
200d63c: 81 e8 00 00 restore
* 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 );
200d640: a0 07 bf ec add %fp, -20, %l0
200d644: 7f ff eb 5b call 20083b0 <_TOD_Get_uptime>
200d648: 90 10 00 10 mov %l0, %o0
#endif
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
_Timespec_Subtract(
200d64c: 90 04 60 44 add %l1, 0x44, %o0
200d650: 92 10 00 10 mov %l0, %o1
200d654: 7f ff f5 61 call 200abd8 <_Timespec_Subtract>
200d658: 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(
200d65c: 92 10 00 10 mov %l0, %o1
200d660: 94 06 60 10 add %i1, 0x10, %o2
200d664: 11 00 80 6f sethi %hi(0x201bc00), %o0
200d668: 7f ff f5 5c call 200abd8 <_Timespec_Subtract>
200d66c: 90 12 23 9c or %o0, 0x39c, %o0 ! 201bf9c <_Thread_Time_of_last_context_switch>
200d670: 30 bf ff f0 b,a 200d630 <rtems_rate_monotonic_get_status+0x70>
020069ec <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
Objects_Id id,
rtems_interval length
)
{
20069ec: 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 *)
20069f0: 11 00 80 6f sethi %hi(0x201bc00), %o0
20069f4: 92 10 00 18 mov %i0, %o1
20069f8: 90 12 21 54 or %o0, 0x154, %o0
20069fc: 40 00 09 28 call 2008e9c <_Objects_Get>
2006a00: 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 ) {
2006a04: c2 07 bf f4 ld [ %fp + -12 ], %g1
2006a08: 80 a0 60 00 cmp %g1, 0
2006a0c: 02 80 00 04 be 2006a1c <rtems_rate_monotonic_period+0x30>
2006a10: a2 10 00 08 mov %o0, %l1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2006a14: 81 c7 e0 08 ret
2006a18: 91 e8 20 04 restore %g0, 4, %o0
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
2006a1c: 25 00 80 6f sethi %hi(0x201bc00), %l2
2006a20: c4 02 20 50 ld [ %o0 + 0x50 ], %g2
2006a24: c2 04 a3 94 ld [ %l2 + 0x394 ], %g1
2006a28: 80 a0 80 01 cmp %g2, %g1
2006a2c: 02 80 00 06 be 2006a44 <rtems_rate_monotonic_period+0x58>
2006a30: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
2006a34: 40 00 0b 9d call 20098a8 <_Thread_Enable_dispatch>
2006a38: b0 10 20 17 mov 0x17, %i0
2006a3c: 81 c7 e0 08 ret
2006a40: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
2006a44: 12 80 00 0f bne 2006a80 <rtems_rate_monotonic_period+0x94>
2006a48: 01 00 00 00 nop
switch ( the_period->state ) {
2006a4c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2006a50: 80 a0 60 00 cmp %g1, 0
2006a54: 02 80 00 07 be 2006a70 <rtems_rate_monotonic_period+0x84>
2006a58: b0 10 20 0b mov 0xb, %i0
2006a5c: 82 00 7f fd add %g1, -3, %g1
2006a60: 80 a0 60 01 cmp %g1, 1
2006a64: 18 80 00 03 bgu 2006a70 <rtems_rate_monotonic_period+0x84>
2006a68: b0 10 20 00 clr %i0
2006a6c: b0 10 20 06 mov 6, %i0
);
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
2006a70: 40 00 0b 8e call 20098a8 <_Thread_Enable_dispatch>
2006a74: 01 00 00 00 nop
2006a78: 81 c7 e0 08 ret
2006a7c: 81 e8 00 00 restore
}
_Thread_Enable_dispatch();
return( return_value );
}
_ISR_Disable( level );
2006a80: 7f ff f0 66 call 2002c18 <sparc_disable_interrupts>
2006a84: 01 00 00 00 nop
2006a88: a0 10 00 08 mov %o0, %l0
switch ( the_period->state ) {
2006a8c: e6 04 60 38 ld [ %l1 + 0x38 ], %l3
2006a90: 80 a4 e0 02 cmp %l3, 2
2006a94: 02 80 00 1a be 2006afc <rtems_rate_monotonic_period+0x110>
2006a98: 80 a4 e0 04 cmp %l3, 4
2006a9c: 02 80 00 32 be 2006b64 <rtems_rate_monotonic_period+0x178>
2006aa0: 80 a4 e0 00 cmp %l3, 0
2006aa4: 12 bf ff dc bne 2006a14 <rtems_rate_monotonic_period+0x28><== NEVER TAKEN
2006aa8: 01 00 00 00 nop
case RATE_MONOTONIC_INACTIVE: {
_ISR_Enable( level );
2006aac: 7f ff f0 5f call 2002c28 <sparc_enable_interrupts>
2006ab0: 01 00 00 00 nop
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
2006ab4: 7f ff ff 58 call 2006814 <_Rate_monotonic_Initiate_statistics>
2006ab8: 90 10 00 11 mov %l1, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
2006abc: 84 10 20 02 mov 2, %g2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2006ac0: 03 00 80 1b sethi %hi(0x2006c00), %g1
2006ac4: 82 10 62 c0 or %g1, 0x2c0, %g1 ! 2006ec0 <_Rate_monotonic_Timeout>
the_watchdog->id = id;
2006ac8: f0 24 60 30 st %i0, [ %l1 + 0x30 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006acc: 92 04 60 10 add %l1, 0x10, %o1
2006ad0: 11 00 80 6f sethi %hi(0x201bc00), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2006ad4: f2 24 60 1c st %i1, [ %l1 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006ad8: 90 12 23 b4 or %o0, 0x3b4, %o0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2006adc: c0 24 60 18 clr [ %l1 + 0x18 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2006ae0: c0 24 60 34 clr [ %l1 + 0x34 ]
_Rate_monotonic_Timeout,
id,
NULL
);
the_period->next_length = length;
2006ae4: f2 24 60 4c st %i1, [ %l1 + 0x4c ]
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
the_period->state = RATE_MONOTONIC_ACTIVE;
2006ae8: c4 24 60 38 st %g2, [ %l1 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2006aec: c2 24 60 2c st %g1, [ %l1 + 0x2c ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006af0: 40 00 11 09 call 200af14 <_Watchdog_Insert>
2006af4: b0 10 20 00 clr %i0
2006af8: 30 bf ff de b,a 2006a70 <rtems_rate_monotonic_period+0x84>
case RATE_MONOTONIC_ACTIVE:
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
2006afc: 7f ff ff 62 call 2006884 <_Rate_monotonic_Update_statistics>
2006b00: 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;
2006b04: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
2006b08: 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;
2006b0c: c2 24 60 38 st %g1, [ %l1 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
2006b10: 7f ff f0 46 call 2002c28 <sparc_enable_interrupts>
2006b14: 90 10 00 10 mov %l0, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
2006b18: c2 04 a3 94 ld [ %l2 + 0x394 ], %g1
2006b1c: c4 04 60 08 ld [ %l1 + 8 ], %g2
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2006b20: 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;
2006b24: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2006b28: 40 00 0e 14 call 200a378 <_Thread_Set_state>
2006b2c: 13 00 00 10 sethi %hi(0x4000), %o1
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
2006b30: 7f ff f0 3a call 2002c18 <sparc_disable_interrupts>
2006b34: 01 00 00 00 nop
local_state = the_period->state;
2006b38: e0 04 60 38 ld [ %l1 + 0x38 ], %l0
the_period->state = RATE_MONOTONIC_ACTIVE;
2006b3c: e6 24 60 38 st %l3, [ %l1 + 0x38 ]
_ISR_Enable( level );
2006b40: 7f ff f0 3a call 2002c28 <sparc_enable_interrupts>
2006b44: 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 )
2006b48: 80 a4 20 03 cmp %l0, 3
2006b4c: 02 80 00 17 be 2006ba8 <rtems_rate_monotonic_period+0x1bc><== NEVER TAKEN
2006b50: d0 04 a3 94 ld [ %l2 + 0x394 ], %o0
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
_Thread_Enable_dispatch();
2006b54: 40 00 0b 55 call 20098a8 <_Thread_Enable_dispatch>
2006b58: b0 10 20 00 clr %i0
2006b5c: 81 c7 e0 08 ret
2006b60: 81 e8 00 00 restore
case RATE_MONOTONIC_EXPIRED:
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
2006b64: 7f ff ff 48 call 2006884 <_Rate_monotonic_Update_statistics>
2006b68: 90 10 00 11 mov %l1, %o0
_ISR_Enable( level );
2006b6c: 7f ff f0 2f call 2002c28 <sparc_enable_interrupts>
2006b70: 90 10 00 10 mov %l0, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
2006b74: 82 10 20 02 mov 2, %g1
2006b78: 92 04 60 10 add %l1, 0x10, %o1
2006b7c: 11 00 80 6f sethi %hi(0x201bc00), %o0
2006b80: 90 12 23 b4 or %o0, 0x3b4, %o0 ! 201bfb4 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2006b84: f2 24 60 1c st %i1, [ %l1 + 0x1c ]
the_period->next_length = length;
2006b88: f2 24 60 4c st %i1, [ %l1 + 0x4c ]
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
2006b8c: c2 24 60 38 st %g1, [ %l1 + 0x38 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2006b90: 40 00 10 e1 call 200af14 <_Watchdog_Insert>
2006b94: b0 10 20 06 mov 6, %i0
the_period->next_length = length;
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
2006b98: 40 00 0b 44 call 20098a8 <_Thread_Enable_dispatch>
2006b9c: 01 00 00 00 nop
2006ba0: 81 c7 e0 08 ret
2006ba4: 81 e8 00 00 restore
/*
* If it did, then we want to unblock ourself and continue as
* if nothing happen. The period was reset in the timeout routine.
*/
if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING )
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2006ba8: 40 00 0a 27 call 2009444 <_Thread_Clear_state> <== NOT EXECUTED
2006bac: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED
2006bb0: 30 bf ff e9 b,a 2006b54 <rtems_rate_monotonic_period+0x168><== NOT EXECUTED
02006bb4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2006bb4: 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 )
2006bb8: 80 a6 60 00 cmp %i1, 0
2006bbc: 02 80 00 4a be 2006ce4 <rtems_rate_monotonic_report_statistics_with_plugin+0x130><== NEVER TAKEN
2006bc0: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
2006bc4: 13 00 80 66 sethi %hi(0x2019800), %o1
2006bc8: 9f c6 40 00 call %i1
2006bcc: 92 12 60 c0 or %o1, 0xc0, %o1 ! 20198c0 <rtems_status_assoc+0x1b8>
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
(*print)( context, "--- CPU times are in seconds ---\n" );
2006bd0: 90 10 00 18 mov %i0, %o0
2006bd4: 13 00 80 66 sethi %hi(0x2019800), %o1
2006bd8: 9f c6 40 00 call %i1
2006bdc: 92 12 60 e0 or %o1, 0xe0, %o1 ! 20198e0 <rtems_status_assoc+0x1d8>
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
(*print)( context, "--- Wall times are in seconds ---\n" );
2006be0: 90 10 00 18 mov %i0, %o0
2006be4: 13 00 80 66 sethi %hi(0x2019800), %o1
2006be8: 9f c6 40 00 call %i1
2006bec: 92 12 61 08 or %o1, 0x108, %o1 ! 2019908 <rtems_status_assoc+0x200>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
2006bf0: 90 10 00 18 mov %i0, %o0
2006bf4: 13 00 80 66 sethi %hi(0x2019800), %o1
2006bf8: 9f c6 40 00 call %i1
2006bfc: 92 12 61 30 or %o1, 0x130, %o1 ! 2019930 <rtems_status_assoc+0x228>
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
2006c00: 90 10 00 18 mov %i0, %o0
2006c04: 13 00 80 66 sethi %hi(0x2019800), %o1
2006c08: 9f c6 40 00 call %i1
2006c0c: 92 12 61 80 or %o1, 0x180, %o1 ! 2019980 <rtems_status_assoc+0x278>
/*
* 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 ;
2006c10: 03 00 80 6f sethi %hi(0x201bc00), %g1
2006c14: a6 10 61 54 or %g1, 0x154, %l3 ! 201bd54 <_Rate_monotonic_Information>
2006c18: e4 04 e0 08 ld [ %l3 + 8 ], %l2
id <= _Rate_monotonic_Information.maximum_id ;
2006c1c: c2 04 e0 0c ld [ %l3 + 0xc ], %g1
2006c20: 80 a4 80 01 cmp %l2, %g1
2006c24: 18 80 00 30 bgu 2006ce4 <rtems_rate_monotonic_report_statistics_with_plugin+0x130><== NEVER TAKEN
2006c28: 03 00 80 66 sethi %hi(0x2019800), %g1
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
2006c2c: 05 00 80 66 sethi %hi(0x2019800), %g2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2006c30: b6 10 61 d0 or %g1, 0x1d0, %i3
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
2006c34: b8 10 a1 00 or %g2, 0x100, %i4
2006c38: a8 07 bf 98 add %fp, -104, %l4
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 );
2006c3c: ae 07 bf d0 add %fp, -48, %l7
2006c40: ac 07 bf f0 add %fp, -16, %l6
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
2006c44: ba 07 bf b0 add %fp, -80, %i5
2006c48: aa 07 bf e8 add %fp, -24, %l5
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
2006c4c: 10 80 00 06 b 2006c64 <rtems_rate_monotonic_report_statistics_with_plugin+0xb0>
2006c50: b4 07 bf c8 add %fp, -56, %i2
* 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++ ) {
2006c54: 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 ;
2006c58: 80 a0 40 12 cmp %g1, %l2
2006c5c: 0a 80 00 22 bcs 2006ce4 <rtems_rate_monotonic_report_statistics_with_plugin+0x130>
2006c60: 01 00 00 00 nop
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
2006c64: 90 10 00 12 mov %l2, %o0
2006c68: 40 00 1a 41 call 200d56c <rtems_rate_monotonic_get_statistics>
2006c6c: 92 10 00 14 mov %l4, %o1
if ( status != RTEMS_SUCCESSFUL )
2006c70: 80 a2 20 00 cmp %o0, 0
2006c74: 32 bf ff f8 bne,a 2006c54 <rtems_rate_monotonic_report_statistics_with_plugin+0xa0>
2006c78: c2 04 e0 0c ld [ %l3 + 0xc ], %g1
continue;
/* If the above passed, so should this but check it anyway */
status = rtems_rate_monotonic_get_status( id, &the_status );
2006c7c: 92 10 00 17 mov %l7, %o1
2006c80: 40 00 1a 50 call 200d5c0 <rtems_rate_monotonic_get_status>
2006c84: 90 10 00 12 mov %l2, %o0
continue;
#endif
name[ 0 ] = '\0';
if ( the_status.owner ) {
2006c88: d0 07 bf d0 ld [ %fp + -48 ], %o0
2006c8c: 80 a2 20 00 cmp %o0, 0
2006c90: 12 80 00 4b bne 2006dbc <rtems_rate_monotonic_report_statistics_with_plugin+0x208><== ALWAYS TAKEN
2006c94: c0 2f bf f0 clrb [ %fp + -16 ]
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2006c98: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED
2006c9c: 94 10 00 12 mov %l2, %o2
2006ca0: 92 10 00 1b mov %i3, %o1
2006ca4: 96 10 00 16 mov %l6, %o3
2006ca8: 9f c6 40 00 call %i1
2006cac: 90 10 00 18 mov %i0, %o0
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
2006cb0: c2 07 bf 98 ld [ %fp + -104 ], %g1
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
2006cb4: 94 10 00 15 mov %l5, %o2
2006cb8: 90 10 00 1d mov %i5, %o0
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
2006cbc: 80 a0 60 00 cmp %g1, 0
2006cc0: 12 80 00 0b bne 2006cec <rtems_rate_monotonic_report_statistics_with_plugin+0x138>
2006cc4: 92 10 00 1c mov %i4, %o1
(*print)( context, "\n" );
2006cc8: 9f c6 40 00 call %i1
2006ccc: 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 ;
2006cd0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1
id++ ) {
2006cd4: 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 ;
2006cd8: 80 a0 40 12 cmp %g1, %l2
2006cdc: 1a bf ff e3 bcc 2006c68 <rtems_rate_monotonic_report_statistics_with_plugin+0xb4><== ALWAYS TAKEN
2006ce0: 90 10 00 12 mov %l2, %o0
2006ce4: 81 c7 e0 08 ret
2006ce8: 81 e8 00 00 restore
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
struct timespec cpu_average;
_Timespec_Divide_by_integer(
2006cec: 40 00 0f 52 call 200aa34 <_Timespec_Divide_by_integer>
2006cf0: 92 10 00 01 mov %g1, %o1
&the_stats.total_cpu_time,
the_stats.count,
&cpu_average
);
(*print)( context,
2006cf4: d0 07 bf a4 ld [ %fp + -92 ], %o0
2006cf8: 40 00 41 c6 call 2017410 <.div>
2006cfc: 92 10 23 e8 mov 0x3e8, %o1
2006d00: a2 10 00 08 mov %o0, %l1
2006d04: d0 07 bf ac ld [ %fp + -84 ], %o0
2006d08: 40 00 41 c2 call 2017410 <.div>
2006d0c: 92 10 23 e8 mov 0x3e8, %o1
2006d10: c2 07 bf e8 ld [ %fp + -24 ], %g1
2006d14: a0 10 00 08 mov %o0, %l0
2006d18: d0 07 bf ec ld [ %fp + -20 ], %o0
2006d1c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2006d20: 40 00 41 bc call 2017410 <.div>
2006d24: 92 10 23 e8 mov 0x3e8, %o1
2006d28: d8 07 bf a8 ld [ %fp + -88 ], %o4
2006d2c: d4 07 bf a0 ld [ %fp + -96 ], %o2
2006d30: 96 10 00 11 mov %l1, %o3
2006d34: 9a 10 00 10 mov %l0, %o5
2006d38: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
2006d3c: 13 00 80 66 sethi %hi(0x2019800), %o1
2006d40: 90 10 00 18 mov %i0, %o0
2006d44: 9f c6 40 00 call %i1
2006d48: 92 12 61 e8 or %o1, 0x1e8, %o1
* print Wall time part of statistics
*/
{
#ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
struct timespec wall_average;
_Timespec_Divide_by_integer(
2006d4c: d2 07 bf 98 ld [ %fp + -104 ], %o1
2006d50: 94 10 00 15 mov %l5, %o2
2006d54: 40 00 0f 38 call 200aa34 <_Timespec_Divide_by_integer>
2006d58: 90 10 00 1a mov %i2, %o0
&the_stats.total_wall_time,
the_stats.count,
&wall_average
);
(*print)( context,
2006d5c: d0 07 bf bc ld [ %fp + -68 ], %o0
2006d60: 40 00 41 ac call 2017410 <.div>
2006d64: 92 10 23 e8 mov 0x3e8, %o1
2006d68: a2 10 00 08 mov %o0, %l1
2006d6c: d0 07 bf c4 ld [ %fp + -60 ], %o0
2006d70: 40 00 41 a8 call 2017410 <.div>
2006d74: 92 10 23 e8 mov 0x3e8, %o1
2006d78: c2 07 bf e8 ld [ %fp + -24 ], %g1
2006d7c: a0 10 00 08 mov %o0, %l0
2006d80: d0 07 bf ec ld [ %fp + -20 ], %o0
2006d84: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2006d88: 40 00 41 a2 call 2017410 <.div>
2006d8c: 92 10 23 e8 mov 0x3e8, %o1
2006d90: d4 07 bf b8 ld [ %fp + -72 ], %o2
2006d94: d8 07 bf c0 ld [ %fp + -64 ], %o4
2006d98: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
2006d9c: 96 10 00 11 mov %l1, %o3
2006da0: 9a 10 00 10 mov %l0, %o5
2006da4: 90 10 00 18 mov %i0, %o0
2006da8: 13 00 80 66 sethi %hi(0x2019800), %o1
2006dac: 9f c6 40 00 call %i1
2006db0: 92 12 62 08 or %o1, 0x208, %o1 ! 2019a08 <rtems_status_assoc+0x300>
/*
* 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 ;
2006db4: 10 bf ff a8 b 2006c54 <rtems_rate_monotonic_report_statistics_with_plugin+0xa0>
2006db8: c2 04 e0 0c ld [ %l3 + 0xc ], %g1
#endif
name[ 0 ] = '\0';
if ( the_status.owner ) {
rtems_object_get_name( the_status.owner, sizeof(name), name );
2006dbc: 94 10 00 16 mov %l6, %o2
2006dc0: 40 00 00 70 call 2006f80 <rtems_object_get_name>
2006dc4: 92 10 20 05 mov 5, %o1
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2006dc8: 10 bf ff b5 b 2006c9c <rtems_rate_monotonic_report_statistics_with_plugin+0xe8>
2006dcc: d8 1f bf 98 ldd [ %fp + -104 ], %o4
02006dec <rtems_rate_monotonic_reset_all_statistics>:
/*
* rtems_rate_monotonic_reset_all_statistics
*/
void rtems_rate_monotonic_reset_all_statistics( void )
{
2006dec: 9d e3 bf 98 save %sp, -104, %sp
2006df0: 05 00 80 6f sethi %hi(0x201bc00), %g2
2006df4: c2 00 a2 d0 ld [ %g2 + 0x2d0 ], %g1 ! 201bed0 <_Thread_Dispatch_disable_level>
2006df8: 82 00 60 01 inc %g1
2006dfc: c2 20 a2 d0 st %g1, [ %g2 + 0x2d0 ]
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
2006e00: 03 00 80 6f sethi %hi(0x201bc00), %g1
2006e04: a2 10 61 54 or %g1, 0x154, %l1 ! 201bd54 <_Rate_monotonic_Information>
2006e08: e0 04 60 08 ld [ %l1 + 8 ], %l0
id <= _Rate_monotonic_Information.maximum_id ;
2006e0c: c2 04 60 0c ld [ %l1 + 0xc ], %g1
2006e10: 80 a4 00 01 cmp %l0, %g1
2006e14: 18 80 00 09 bgu 2006e38 <rtems_rate_monotonic_reset_all_statistics+0x4c><== NEVER TAKEN
2006e18: 01 00 00 00 nop
id++ ) {
status = rtems_rate_monotonic_reset_statistics( id );
2006e1c: 40 00 00 0a call 2006e44 <rtems_rate_monotonic_reset_statistics>
2006e20: 90 10 00 10 mov %l0, %o0
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
2006e24: c2 04 60 0c ld [ %l1 + 0xc ], %g1
id++ ) {
2006e28: a0 04 20 01 inc %l0
/*
* Cycle through all possible ids and try to reset each one. If it
* is a period that is inactive, we just get an error back. No big deal.
*/
for ( id=_Rate_monotonic_Information.minimum_id ;
id <= _Rate_monotonic_Information.maximum_id ;
2006e2c: 80 a0 40 10 cmp %g1, %l0
2006e30: 1a bf ff fb bcc 2006e1c <rtems_rate_monotonic_reset_all_statistics+0x30>
2006e34: 01 00 00 00 nop
}
/*
* Done so exit thread dispatching disabled critical section.
*/
_Thread_Enable_dispatch();
2006e38: 40 00 0a 9c call 20098a8 <_Thread_Enable_dispatch>
2006e3c: 81 e8 00 00 restore
02010148 <rtems_region_extend>:
rtems_status_code rtems_region_extend(
Objects_Id id,
void *starting_address,
uint32_t length
)
{
2010148: 9d e3 bf 90 save %sp, -112, %sp
201014c: 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 )
2010150: 80 a6 60 00 cmp %i1, 0
2010154: 02 80 00 28 be 20101f4 <rtems_region_extend+0xac> <== NEVER TAKEN
2010158: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
201015c: 23 00 80 c3 sethi %hi(0x2030c00), %l1
2010160: 40 00 09 12 call 20125a8 <_API_Mutex_Lock>
2010164: d0 04 62 3c ld [ %l1 + 0x23c ], %o0 ! 2030e3c <_RTEMS_Allocator_Mutex>
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Region_Control *)
2010168: 92 10 00 10 mov %l0, %o1
201016c: 11 00 80 c2 sethi %hi(0x2030800), %o0
2010170: 94 07 bf f0 add %fp, -16, %o2
2010174: 40 00 10 29 call 2014218 <_Objects_Get_no_protection>
2010178: 90 12 23 b4 or %o0, 0x3b4, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
201017c: c2 07 bf f0 ld [ %fp + -16 ], %g1
2010180: 80 a0 60 00 cmp %g1, 0
2010184: 12 80 00 16 bne 20101dc <rtems_region_extend+0x94>
2010188: a0 10 00 08 mov %o0, %l0
case OBJECTS_LOCAL:
heap_status = _Heap_Extend(
201018c: 92 10 00 19 mov %i1, %o1
2010190: 94 10 00 1a mov %i2, %o2
2010194: 90 02 20 68 add %o0, 0x68, %o0
2010198: 96 07 bf f4 add %fp, -12, %o3
201019c: 40 00 0c 48 call 20132bc <_Heap_Extend>
20101a0: b0 10 20 09 mov 9, %i0
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
20101a4: 80 a2 20 01 cmp %o0, 1
20101a8: 02 80 00 11 be 20101ec <rtems_region_extend+0xa4>
20101ac: 01 00 00 00 nop
20101b0: 1a 80 00 13 bcc 20101fc <rtems_region_extend+0xb4>
20101b4: 80 a2 20 02 cmp %o0, 2
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
20101b8: c6 07 bf f4 ld [ %fp + -12 ], %g3
20101bc: c4 04 20 54 ld [ %l0 + 0x54 ], %g2
the_region->maximum_segment_size += amount_extended;
20101c0: c2 04 20 5c ld [ %l0 + 0x5c ], %g1
&amount_extended
);
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
20101c4: 84 00 80 03 add %g2, %g3, %g2
the_region->maximum_segment_size += amount_extended;
20101c8: 82 00 40 03 add %g1, %g3, %g1
&amount_extended
);
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
20101cc: c4 24 20 54 st %g2, [ %l0 + 0x54 ]
the_region->maximum_segment_size += amount_extended;
20101d0: c2 24 20 5c st %g1, [ %l0 + 0x5c ]
20101d4: 10 80 00 06 b 20101ec <rtems_region_extend+0xa4>
20101d8: b0 10 20 00 clr %i0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator(); /* to prevent deletion */
the_region = _Region_Get( id, &location );
switch ( location ) {
20101dc: 80 a0 60 01 cmp %g1, 1
20101e0: 02 80 00 03 be 20101ec <rtems_region_extend+0xa4> <== ALWAYS TAKEN
20101e4: b0 10 20 04 mov 4, %i0
switch ( heap_status ) {
case HEAP_EXTEND_SUCCESSFUL:
the_region->length += amount_extended;
the_region->maximum_segment_size += amount_extended;
return_status = RTEMS_SUCCESSFUL;
break;
20101e8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
20101ec: 40 00 09 05 call 2012600 <_API_Mutex_Unlock>
20101f0: d0 04 62 3c ld [ %l1 + 0x23c ], %o0
return return_status;
}
20101f4: 81 c7 e0 08 ret
20101f8: 81 e8 00 00 restore
starting_address,
length,
&amount_extended
);
switch ( heap_status ) {
20101fc: 12 bf ff fb bne 20101e8 <rtems_region_extend+0xa0> <== NEVER TAKEN
2010200: b0 10 20 18 mov 0x18, %i0
2010204: 30 bf ff fa b,a 20101ec <rtems_region_extend+0xa4>
0201030c <rtems_region_get_segment>:
uint32_t size,
rtems_option option_set,
rtems_interval timeout,
void **segment
)
{
201030c: 9d e3 bf 90 save %sp, -112, %sp
2010310: 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 )
2010314: 80 a7 20 00 cmp %i4, 0
2010318: 02 80 00 1b be 2010384 <rtems_region_get_segment+0x78> <== NEVER TAKEN
201031c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
*segment = NULL;
2010320: c0 27 00 00 clr [ %i4 ]
if ( size == 0 )
2010324: 80 a6 60 00 cmp %i1, 0
2010328: 02 80 00 17 be 2010384 <rtems_region_get_segment+0x78> <== NEVER TAKEN
201032c: b0 10 20 08 mov 8, %i0
return RTEMS_INVALID_SIZE;
_RTEMS_Lock_allocator();
2010330: 23 00 80 c3 sethi %hi(0x2030c00), %l1
2010334: 40 00 08 9d call 20125a8 <_API_Mutex_Lock>
2010338: d0 04 62 3c ld [ %l1 + 0x23c ], %o0 ! 2030e3c <_RTEMS_Allocator_Mutex>
executing = _Thread_Executing;
201033c: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2010340: 92 10 00 13 mov %l3, %o1
2010344: e4 00 62 44 ld [ %g1 + 0x244 ], %l2
2010348: 11 00 80 c2 sethi %hi(0x2030800), %o0
201034c: 94 07 bf f4 add %fp, -12, %o2
2010350: 40 00 0f b2 call 2014218 <_Objects_Get_no_protection>
2010354: 90 12 23 b4 or %o0, 0x3b4, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
2010358: c2 07 bf f4 ld [ %fp + -12 ], %g1
201035c: 80 a0 60 00 cmp %g1, 0
2010360: 02 80 00 0b be 201038c <rtems_region_get_segment+0x80>
2010364: a0 10 00 08 mov %o0, %l0
2010368: 82 18 60 01 xor %g1, 1, %g1
201036c: 80 a0 00 01 cmp %g0, %g1
2010370: 84 40 3f ff addx %g0, -1, %g2
2010374: b0 08 bf eb and %g2, -21, %i0
2010378: b0 06 20 19 add %i0, 0x19, %i0
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
201037c: 40 00 08 a1 call 2012600 <_API_Mutex_Unlock>
2010380: d0 04 62 3c ld [ %l1 + 0x23c ], %o0
return return_status;
}
2010384: 81 c7 e0 08 ret
2010388: 81 e8 00 00 restore
executing = _Thread_Executing;
the_region = _Region_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( size > the_region->maximum_segment_size )
201038c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1
2010390: 80 a6 40 01 cmp %i1, %g1
2010394: 18 bf ff fa bgu 201037c <rtems_region_get_segment+0x70>
2010398: 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 );
201039c: 90 02 20 68 add %o0, 0x68, %o0
20103a0: 40 00 0b 85 call 20131b4 <_Heap_Allocate>
20103a4: 92 10 00 19 mov %i1, %o1
the_segment = _Region_Allocate_segment( the_region, size );
_Region_Debug_Walk( the_region, 2 );
if ( the_segment ) {
20103a8: 80 a2 20 00 cmp %o0, 0
20103ac: 02 80 00 07 be 20103c8 <rtems_region_get_segment+0xbc>
20103b0: b0 10 20 00 clr %i0
the_region->number_of_used_blocks += 1;
20103b4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1
*segment = the_segment;
20103b8: 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;
20103bc: 82 00 60 01 inc %g1
20103c0: 10 bf ff ef b 201037c <rtems_region_get_segment+0x70>
20103c4: c2 24 20 64 st %g1, [ %l0 + 0x64 ]
*segment = the_segment;
return_status = RTEMS_SUCCESSFUL;
}
else if ( _Options_Is_no_wait( option_set ) ) {
20103c8: 80 8e a0 01 btst 1, %i2
20103cc: 12 bf ff ec bne 201037c <rtems_region_get_segment+0x70>
20103d0: b0 10 20 0d mov 0xd, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
20103d4: 05 00 80 c3 sethi %hi(0x2030c00), %g2
20103d8: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1 ! 2030d80 <_Thread_Dispatch_disable_level>
20103dc: 82 00 60 01 inc %g1
20103e0: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
* 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();
20103e4: 40 00 08 87 call 2012600 <_API_Mutex_Unlock>
20103e8: d0 04 62 3c ld [ %l1 + 0x23c ], %o0
executing->Wait.queue = &the_region->Wait_queue;
20103ec: 84 04 20 10 add %l0, 0x10, %g2
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;
20103f0: 82 10 20 01 mov 1, %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 );
20103f4: 92 10 00 1b mov %i3, %o1
20103f8: 90 10 00 02 mov %g2, %o0
20103fc: 15 00 80 55 sethi %hi(0x2015400), %o2
2010400: 94 12 a2 3c or %o2, 0x23c, %o2 ! 201563c <_Thread_queue_Timeout>
* because this thread is going to block.
*/
_Thread_Disable_dispatch();
_RTEMS_Unlock_allocator();
executing->Wait.queue = &the_region->Wait_queue;
2010404: c4 24 a0 44 st %g2, [ %l2 + 0x44 ]
2010408: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
executing->Wait.id = id;
201040c: e6 24 a0 20 st %l3, [ %l2 + 0x20 ]
executing->Wait.count = size;
2010410: f2 24 a0 24 st %i1, [ %l2 + 0x24 ]
executing->Wait.return_argument = segment;
_Thread_queue_Enter_critical_section( &the_region->Wait_queue );
_Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
2010414: 40 00 13 74 call 20151e4 <_Thread_queue_Enqueue_with_handler>
2010418: f8 24 a0 28 st %i4, [ %l2 + 0x28 ]
_Thread_Enable_dispatch();
201041c: 40 00 12 14 call 2014c6c <_Thread_Enable_dispatch>
2010420: 01 00 00 00 nop
return (rtems_status_code) executing->Wait.return_code;
2010424: f0 04 a0 34 ld [ %l2 + 0x34 ], %i0
2010428: 81 c7 e0 08 ret
201042c: 81 e8 00 00 restore
02010504 <rtems_region_resize_segment>:
Objects_Id id,
void *segment,
size_t size,
size_t *old_size
)
{
2010504: 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 )
2010508: 80 a6 e0 00 cmp %i3, 0
201050c: 02 80 00 2e be 20105c4 <rtems_region_resize_segment+0xc0>
2010510: 21 00 80 c3 sethi %hi(0x2030c00), %l0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
2010514: 40 00 08 25 call 20125a8 <_API_Mutex_Lock>
2010518: d0 04 22 3c ld [ %l0 + 0x23c ], %o0 ! 2030e3c <_RTEMS_Allocator_Mutex>
201051c: 92 10 00 18 mov %i0, %o1
2010520: 11 00 80 c2 sethi %hi(0x2030800), %o0
2010524: 94 07 bf f0 add %fp, -16, %o2
2010528: 40 00 0f 3c call 2014218 <_Objects_Get_no_protection>
201052c: 90 12 23 b4 or %o0, 0x3b4, %o0
the_region = _Region_Get( id, &location );
switch ( location ) {
2010530: c2 07 bf f0 ld [ %fp + -16 ], %g1
2010534: 80 a0 60 00 cmp %g1, 0
2010538: 12 80 00 14 bne 2010588 <rtems_region_resize_segment+0x84>
201053c: b0 10 00 08 mov %o0, %i0
case OBJECTS_LOCAL:
_Region_Debug_Walk( the_region, 7 );
status = _Heap_Resize_block(
2010540: 94 10 00 1a mov %i2, %o2
2010544: 92 10 00 19 mov %i1, %o1
2010548: 90 02 20 68 add %o0, 0x68, %o0
201054c: 96 07 bf ec add %fp, -20, %o3
2010550: 40 00 0c e5 call 20138e4 <_Heap_Resize_block>
2010554: 98 07 bf f4 add %fp, -12, %o4
segment,
(uint32_t) size,
&osize,
&avail_size
);
*old_size = (uint32_t) osize;
2010558: c2 07 bf ec ld [ %fp + -20 ], %g1
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
201055c: b4 92 20 00 orcc %o0, 0, %i2
2010560: 12 80 00 13 bne 20105ac <rtems_region_resize_segment+0xa8><== ALWAYS TAKEN
2010564: c2 26 c0 00 st %g1, [ %i3 ]
2010568: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
201056c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2010570: 12 80 00 17 bne 20105cc <rtems_region_resize_segment+0xc8><== NOT EXECUTED
2010574: d0 04 22 3c ld [ %l0 + 0x23c ], %o0 <== NOT EXECUTED
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
2010578: 40 00 08 22 call 2012600 <_API_Mutex_Unlock> <== NOT EXECUTED
201057c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2010580: 81 c7 e0 08 ret <== NOT EXECUTED
2010584: 81 e8 00 00 restore <== NOT EXECUTED
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
2010588: d0 04 22 3c ld [ %l0 + 0x23c ], %o0
return RTEMS_INVALID_ADDRESS;
_RTEMS_Lock_allocator();
the_region = _Region_Get( id, &location );
switch ( location ) {
201058c: 82 18 60 01 xor %g1, 1, %g1
2010590: 80 a0 00 01 cmp %g0, %g1
2010594: 84 40 3f ff addx %g0, -1, %g2
2010598: b0 08 bf eb and %g2, -21, %i0
case OBJECTS_ERROR:
return_status = RTEMS_INVALID_ID;
break;
}
_RTEMS_Unlock_allocator();
201059c: 40 00 08 19 call 2012600 <_API_Mutex_Unlock>
20105a0: b0 06 20 19 add %i0, 0x19, %i0
20105a4: 81 c7 e0 08 ret
20105a8: 81 e8 00 00 restore
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
_Region_Process_queue( the_region ); /* unlocks allocator */
else
_RTEMS_Unlock_allocator();
20105ac: d0 04 22 3c ld [ %l0 + 0x23c ], %o0
20105b0: 40 00 08 14 call 2012600 <_API_Mutex_Unlock>
20105b4: b0 10 20 0d mov 0xd, %i0
return
20105b8: 80 a6 a0 01 cmp %i2, 1
20105bc: 02 80 00 07 be 20105d8 <rtems_region_resize_segment+0xd4> <== NEVER TAKEN
20105c0: 01 00 00 00 nop
break;
}
_RTEMS_Unlock_allocator();
return return_status;
}
20105c4: 81 c7 e0 08 ret
20105c8: 91 e8 20 09 restore %g0, 9, %o0
*old_size = (uint32_t) osize;
_Region_Debug_Walk( the_region, 8 );
if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 )
_Region_Process_queue( the_region ); /* unlocks allocator */
20105cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20105d0: 40 00 21 70 call 2018b90 <_Region_Process_queue> <== NOT EXECUTED
20105d4: b0 10 20 00 clr %i0 <== NOT EXECUTED
20105d8: 81 c7 e0 08 ret <== NOT EXECUTED
20105dc: 81 e8 00 00 restore <== NOT EXECUTED
020055c4 <rtems_semaphore_create>:
uint32_t count,
rtems_attribute attribute_set,
rtems_task_priority priority_ceiling,
rtems_id *id
)
{
20055c4: 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 ) )
20055c8: a4 96 20 00 orcc %i0, 0, %l2
20055cc: 02 80 00 33 be 2005698 <rtems_semaphore_create+0xd4>
20055d0: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
20055d4: 80 a7 20 00 cmp %i4, 0
20055d8: 02 80 00 30 be 2005698 <rtems_semaphore_create+0xd4> <== NEVER TAKEN
20055dc: b0 10 20 09 mov 9, %i0
return RTEMS_NOT_DEFINED;
} else
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
20055e0: 82 8e a0 c0 andcc %i2, 0xc0, %g1
20055e4: 12 80 00 2f bne 20056a0 <rtems_semaphore_create+0xdc>
20055e8: a0 0e a0 30 and %i2, 0x30, %l0
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
_Attributes_Is_priority_ceiling( attribute_set ) )
return RTEMS_NOT_DEFINED;
if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
20055ec: 80 a4 20 00 cmp %l0, 0
20055f0: 02 80 00 04 be 2005600 <rtems_semaphore_create+0x3c>
20055f4: 80 a6 60 01 cmp %i1, 1
20055f8: 18 80 00 28 bgu 2005698 <rtems_semaphore_create+0xd4>
20055fc: b0 10 20 0a mov 0xa, %i0
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
2005600: 05 00 80 5c sethi %hi(0x2017000), %g2
2005604: c2 00 a3 e0 ld [ %g2 + 0x3e0 ], %g1 ! 20173e0 <_Thread_Dispatch_disable_level>
2005608: 82 00 60 01 inc %g1
200560c: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ]
* 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 );
2005610: 31 00 80 5c sethi %hi(0x2017000), %i0
2005614: 40 00 05 6e call 2006bcc <_Objects_Allocate>
2005618: 90 16 22 ac or %i0, 0x2ac, %o0 ! 20172ac <_Semaphore_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
200561c: a2 92 20 00 orcc %o0, 0, %l1
2005620: 02 80 00 4e be 2005758 <rtems_semaphore_create+0x194>
2005624: 80 a4 20 00 cmp %l0, 0
* 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 ) ) {
2005628: 02 80 00 2c be 20056d8 <rtems_semaphore_create+0x114>
200562c: f4 24 60 10 st %i2, [ %l1 + 0x10 ]
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
2005630: 80 8e a0 40 btst 0x40, %i2
2005634: 02 80 00 44 be 2005744 <rtems_semaphore_create+0x180>
2005638: 80 8e a0 80 btst 0x80, %i2
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
200563c: 82 10 20 02 mov 2, %g1
2005640: c2 27 bf e8 st %g1, [ %fp + -24 ]
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
else
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
2005644: 80 a4 20 10 cmp %l0, 0x10
2005648: 02 80 00 48 be 2005768 <rtems_semaphore_create+0x1a4>
200564c: 82 10 20 02 mov 2, %g1
the_mutex_attributes.only_owner_release = TRUE;
break;
}
} else {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
the_mutex_attributes.only_owner_release = FALSE;
2005650: 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;
2005654: 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(
2005658: 82 1e 60 01 xor %i1, 1, %g1
200565c: 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;
2005660: f6 27 bf ec st %i3, [ %fp + -20 ]
mutex_status = _CORE_mutex_Initialize(
2005664: 94 60 3f ff subx %g0, -1, %o2
2005668: 90 04 60 14 add %l1, 0x14, %o0
200566c: 40 00 03 3e call 2006364 <_CORE_mutex_Initialize>
2005670: 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 ) {
2005674: 80 a2 20 06 cmp %o0, 6
2005678: 32 80 00 26 bne,a 2005710 <rtems_semaphore_create+0x14c> <== ALWAYS TAKEN
200567c: c4 04 60 08 ld [ %l1 + 8 ], %g2
*/
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
2005680: 90 16 22 ac or %i0, 0x2ac, %o0 <== NOT EXECUTED
2005684: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2005688: 40 00 06 4c call 2006fb8 <_Objects_Free> <== NOT EXECUTED
200568c: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
2005690: 40 00 09 3a call 2007b78 <_Thread_Enable_dispatch> <== NOT EXECUTED
2005694: 01 00 00 00 nop <== NOT EXECUTED
2005698: 81 c7 e0 08 ret
200569c: 81 e8 00 00 restore
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
20056a0: 80 a4 20 10 cmp %l0, 0x10
20056a4: 02 80 00 06 be 20056bc <rtems_semaphore_create+0xf8>
20056a8: 80 a4 20 20 cmp %l0, 0x20
20056ac: 02 80 00 05 be 20056c0 <rtems_semaphore_create+0xfc>
20056b0: 80 8e a0 04 btst 4, %i2
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
20056b4: 81 c7 e0 08 ret
20056b8: 91 e8 20 0b restore %g0, 0xb, %o0
#endif
if ( _Attributes_Is_inherit_priority( attribute_set ) ||
_Attributes_Is_priority_ceiling( attribute_set ) ) {
if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
20056bc: 80 8e a0 04 btst 4, %i2
20056c0: 02 bf ff fd be 20056b4 <rtems_semaphore_create+0xf0>
20056c4: 80 a0 60 c0 cmp %g1, 0xc0
_Attributes_Is_priority( attribute_set ) ) )
return RTEMS_NOT_DEFINED;
}
if ( _Attributes_Is_inherit_priority( attribute_set ) &&
20056c8: 12 bf ff ca bne 20055f0 <rtems_semaphore_create+0x2c>
20056cc: 80 a4 20 00 cmp %l0, 0
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
20056d0: 81 c7 e0 08 ret
20056d4: 91 e8 20 0b restore %g0, 0xb, %o0
_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
return RTEMS_INVALID_PRIORITY;
}
} else {
if ( _Attributes_Is_priority( attribute_set ) )
20056d8: 80 8e a0 04 btst 4, %i2
20056dc: 22 80 00 04 be,a 20056ec <rtems_semaphore_create+0x128>
20056e0: c0 27 bf f4 clr [ %fp + -12 ]
the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
20056e4: 82 10 20 01 mov 1, %g1
20056e8: c2 27 bf f4 st %g1, [ %fp + -12 ]
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
20056ec: 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;
20056f0: c0 27 bf e0 clr [ %fp + -32 ]
the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
20056f4: c0 27 bf ec clr [ %fp + -20 ]
_CORE_semaphore_Initialize(
20056f8: 94 10 00 19 mov %i1, %o2
/*
* This effectively disables limit checking.
*/
the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
20056fc: 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(
2005700: 90 04 60 14 add %l1, 0x14, %o0
2005704: 40 00 04 03 call 2006710 <_CORE_semaphore_Initialize>
2005708: 92 07 bf f0 add %fp, -16, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200570c: c4 04 60 08 ld [ %l1 + 8 ], %g2
2005710: 82 16 22 ac or %i0, 0x2ac, %g1
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2005714: e4 24 60 0c st %l2, [ %l1 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2005718: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
&_Semaphore_Information,
&the_semaphore->Object,
(Objects_Name) name
);
*id = the_semaphore->Object.id;
200571c: c4 27 00 00 st %g2, [ %i4 ]
2005720: 03 00 00 3f sethi %hi(0xfc00), %g1
2005724: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2005728: 84 08 80 01 and %g2, %g1, %g2
200572c: 85 28 a0 02 sll %g2, 2, %g2
the_semaphore->Object.id,
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
2005730: b0 10 20 00 clr %i0
2005734: 40 00 09 11 call 2007b78 <_Thread_Enable_dispatch>
2005738: e2 20 c0 02 st %l1, [ %g3 + %g2 ]
200573c: 81 c7 e0 08 ret
2005740: 81 e8 00 00 restore
if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
CORE_mutex_Status mutex_status;
if ( _Attributes_Is_inherit_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
2005744: 02 80 00 0f be 2005780 <rtems_semaphore_create+0x1bc>
2005748: 80 8e a0 04 btst 4, %i2
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
200574c: 82 10 20 03 mov 3, %g1
2005750: 10 bf ff bd b 2005644 <rtems_semaphore_create+0x80>
2005754: c2 27 bf e8 st %g1, [ %fp + -24 ]
_Thread_Disable_dispatch(); /* prevents deletion */
the_semaphore = _Semaphore_Allocate();
if ( !the_semaphore ) {
_Thread_Enable_dispatch();
2005758: 40 00 09 08 call 2007b78 <_Thread_Enable_dispatch>
200575c: b0 10 20 05 mov 5, %i0
2005760: 81 c7 e0 08 ret
2005764: 81 e8 00 00 restore
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
switch ( the_mutex_attributes.discipline ) {
2005768: c2 07 bf e8 ld [ %fp + -24 ], %g1
200576c: 80 a0 60 01 cmp %g1, 1
2005770: 18 80 00 09 bgu 2005794 <rtems_semaphore_create+0x1d0>
2005774: c0 27 bf e0 clr [ %fp + -32 ]
case CORE_MUTEX_DISCIPLINES_FIFO:
case CORE_MUTEX_DISCIPLINES_PRIORITY:
the_mutex_attributes.only_owner_release = FALSE;
2005778: 10 bf ff b8 b 2005658 <rtems_semaphore_create+0x94>
200577c: c0 2f bf e4 clrb [ %fp + -28 ]
if ( _Attributes_Is_inherit_priority( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
else if ( _Attributes_Is_priority( attribute_set ) )
2005780: 22 bf ff b1 be,a 2005644 <rtems_semaphore_create+0x80>
2005784: c0 27 bf e8 clr [ %fp + -24 ]
the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
2005788: 82 10 20 01 mov 1, %g1
200578c: 10 bf ff ae b 2005644 <rtems_semaphore_create+0x80>
2005790: c2 27 bf e8 st %g1, [ %fp + -24 ]
if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
switch ( the_mutex_attributes.discipline ) {
2005794: 80 a0 60 03 cmp %g1, 3
2005798: 18 bf ff b1 bgu 200565c <rtems_semaphore_create+0x98> <== NEVER TAKEN
200579c: 82 1e 60 01 xor %i1, 1, %g1
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;
20057a0: 82 10 20 01 mov 1, %g1
20057a4: 10 bf ff ad b 2005658 <rtems_semaphore_create+0x94>
20057a8: c2 2f bf e4 stb %g1, [ %fp + -28 ]
0201091c <rtems_semaphore_flush>:
#endif
rtems_status_code rtems_semaphore_flush(
rtems_id id
)
{
201091c: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Semaphore_Control *)
2010920: 11 00 80 c2 sethi %hi(0x2030800), %o0
2010924: 92 10 00 18 mov %i0, %o1
2010928: 90 12 23 f4 or %o0, 0x3f4, %o0
201092c: 40 00 0e 4d call 2014260 <_Objects_Get>
2010930: 94 07 bf f4 add %fp, -12, %o2
register Semaphore_Control *the_semaphore;
Objects_Locations location;
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
2010934: c2 07 bf f4 ld [ %fp + -12 ], %g1
2010938: 80 a0 60 00 cmp %g1, 0
201093c: 12 80 00 0b bne 2010968 <rtems_semaphore_flush+0x4c>
2010940: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
2010944: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2010948: 80 88 60 30 btst 0x30, %g1
201094c: 12 80 00 09 bne 2010970 <rtems_semaphore_flush+0x54> <== ALWAYS TAKEN
2010950: 90 02 20 14 add %o0, 0x14, %o0
&the_semaphore->Core_control.mutex,
SEND_OBJECT_WAS_DELETED,
CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
);
} else {
_CORE_semaphore_Flush(
2010954: 92 10 20 00 clr %o1 <== NOT EXECUTED
2010958: 40 00 09 60 call 2012ed8 <_CORE_semaphore_Flush> <== NOT EXECUTED
201095c: 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();
2010960: 40 00 10 c3 call 2014c6c <_Thread_Enable_dispatch>
2010964: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2010968: 81 c7 e0 08 ret
201096c: 81 e8 00 00 restore
the_semaphore = _Semaphore_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
_CORE_mutex_Flush(
2010970: 92 10 20 00 clr %o1
2010974: 40 00 08 6e call 2012b2c <_CORE_mutex_Flush>
2010978: 94 10 20 01 mov 1, %o2
201097c: 30 bf ff f9 b,a 2010960 <rtems_semaphore_flush+0x44>
02014b00 <rtems_shutdown_executive>:
*/
void rtems_shutdown_executive(
uint32_t result
)
{
2014b00: 9d e3 bf 10 save %sp, -240, %sp
if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
2014b04: 05 00 80 5d sethi %hi(0x2017400), %g2
2014b08: c2 00 a1 84 ld [ %g2 + 0x184 ], %g1 ! 2017584 <_System_state_Current>
2014b0c: 80 a0 60 04 cmp %g1, 4
2014b10: 02 80 00 07 be 2014b2c <rtems_shutdown_executive+0x2c> <== NEVER TAKEN
2014b14: 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 );
2014b18: 13 00 80 5c sethi %hi(0x2017000), %o1
2014b1c: c2 20 a1 84 st %g1, [ %g2 + 0x184 ]
2014b20: 92 12 63 58 or %o1, 0x358, %o1
2014b24: 7f ff d2 0f call 2009360 <_CPU_Context_switch>
2014b28: 90 07 bf 70 add %fp, -144, %o0
2014b2c: 81 c7 e0 08 ret <== NOT EXECUTED
2014b30: 81 e8 00 00 restore <== NOT EXECUTED
02010b80 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
Objects_Id id,
rtems_signal_set signal_set
)
{
2010b80: 9d e3 bf 90 save %sp, -112, %sp
2010b84: 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 )
2010b88: 80 a6 60 00 cmp %i1, 0
2010b8c: 02 80 00 2f be 2010c48 <rtems_signal_send+0xc8> <== NEVER TAKEN
2010b90: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
2010b94: 40 00 10 44 call 2014ca4 <_Thread_Get>
2010b98: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2010b9c: c2 07 bf f4 ld [ %fp + -12 ], %g1
ASR_Information *asr;
if ( !signal_set )
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
2010ba0: a0 10 00 08 mov %o0, %l0
switch ( location ) {
2010ba4: 80 a0 60 00 cmp %g1, 0
2010ba8: 12 80 00 28 bne 2010c48 <rtems_signal_send+0xc8>
2010bac: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
2010bb0: f0 02 21 68 ld [ %o0 + 0x168 ], %i0
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
2010bb4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2010bb8: 80 a0 60 00 cmp %g1, 0
2010bbc: 02 80 00 25 be 2010c50 <rtems_signal_send+0xd0>
2010bc0: 01 00 00 00 nop
if ( asr->is_enabled ) {
2010bc4: c2 0e 20 08 ldub [ %i0 + 8 ], %g1
2010bc8: 80 a0 60 00 cmp %g1, 0
2010bcc: 02 80 00 16 be 2010c24 <rtems_signal_send+0xa4>
2010bd0: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2010bd4: 7f ff e9 a8 call 200b274 <sparc_disable_interrupts>
2010bd8: 01 00 00 00 nop
*signal_set |= signals;
2010bdc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2010be0: 82 10 40 19 or %g1, %i1, %g1
2010be4: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
_ISR_Enable( _level );
2010be8: 7f ff e9 a7 call 200b284 <sparc_enable_interrupts>
2010bec: 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 ) )
2010bf0: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2010bf4: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2030e20 <_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;
2010bf8: 86 10 20 01 mov 1, %g3
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2010bfc: 80 a0 a0 00 cmp %g2, 0
2010c00: 02 80 00 10 be 2010c40 <rtems_signal_send+0xc0>
2010c04: c6 2c 20 75 stb %g3, [ %l0 + 0x75 ]
2010c08: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2010c0c: c4 00 62 44 ld [ %g1 + 0x244 ], %g2 ! 2030e44 <_Thread_Executing>
2010c10: 80 a4 00 02 cmp %l0, %g2
2010c14: 12 80 00 0b bne 2010c40 <rtems_signal_send+0xc0> <== NEVER TAKEN
2010c18: 03 00 80 c3 sethi %hi(0x2030c00), %g1
_ISR_Signals_to_thread_executing = TRUE;
2010c1c: 10 80 00 09 b 2010c40 <rtems_signal_send+0xc0>
2010c20: c6 28 62 d8 stb %g3, [ %g1 + 0x2d8 ] ! 2030ed8 <_ISR_Signals_to_thread_executing>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2010c24: 7f ff e9 94 call 200b274 <sparc_disable_interrupts>
2010c28: 01 00 00 00 nop
*signal_set |= signals;
2010c2c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2010c30: 82 10 40 19 or %g1, %i1, %g1
2010c34: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
_ISR_Enable( _level );
2010c38: 7f ff e9 93 call 200b284 <sparc_enable_interrupts>
2010c3c: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2010c40: 40 00 10 0b call 2014c6c <_Thread_Enable_dispatch>
2010c44: b0 10 20 00 clr %i0 ! 0 <PROM_START>
2010c48: 81 c7 e0 08 ret
2010c4c: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
2010c50: 40 00 10 07 call 2014c6c <_Thread_Enable_dispatch>
2010c54: b0 10 20 0b mov 0xb, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2010c58: 81 c7 e0 08 ret
2010c5c: 81 e8 00 00 restore
020026c4 <rtems_stack_checker_begin_extension>:
Thread_Control *the_thread
)
{
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
20026c4: c2 02 20 08 ld [ %o0 + 8 ], %g1
20026c8: 80 a0 60 00 cmp %g1, 0
20026cc: 02 80 00 0c be 20026fc <rtems_stack_checker_begin_extension+0x38><== NEVER TAKEN
20026d0: 07 00 80 6c sethi %hi(0x201b000), %g3
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
20026d4: c8 02 20 c8 ld [ %o0 + 0xc8 ], %g4
20026d8: c4 00 e1 88 ld [ %g3 + 0x188 ], %g2
20026dc: 86 10 e1 88 or %g3, 0x188, %g3
20026e0: c4 21 20 08 st %g2, [ %g4 + 8 ]
20026e4: c2 00 e0 04 ld [ %g3 + 4 ], %g1
20026e8: c2 21 20 0c st %g1, [ %g4 + 0xc ]
20026ec: c4 00 e0 08 ld [ %g3 + 8 ], %g2
20026f0: c4 21 20 10 st %g2, [ %g4 + 0x10 ]
20026f4: c2 00 e0 0c ld [ %g3 + 0xc ], %g1
20026f8: c2 21 20 14 st %g1, [ %g4 + 0x14 ]
20026fc: 81 c3 e0 08 retl
02002b34 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running,
Thread_Control *the_thread
)
{
2002b34: 9d e3 bf 98 save %sp, -104, %sp
Stack_check_Initialize();
2002b38: 7f ff ff d7 call 2002a94 <Stack_check_Initialize>
2002b3c: 01 00 00 00 nop
if (the_thread)
2002b40: 80 a6 60 00 cmp %i1, 0
2002b44: 02 80 00 06 be 2002b5c <rtems_stack_checker_create_extension+0x28><== NEVER TAKEN
2002b48: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
2002b4c: d4 06 60 c4 ld [ %i1 + 0xc4 ], %o2
2002b50: d0 06 60 c8 ld [ %i1 + 0xc8 ], %o0
2002b54: 40 00 30 ed call 200ef08 <memset>
2002b58: 92 10 20 a5 mov 0xa5, %o1
return true;
}
2002b5c: 81 c7 e0 08 ret
2002b60: 91 e8 20 01 restore %g0, 1, %o0
02002998 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2002998: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
200299c: 21 00 80 6d sethi %hi(0x201b400), %l0 <== NOT EXECUTED
20029a0: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 ! 201b444 <_Thread_Executing><== NOT EXECUTED
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
20029a4: d0 00 60 c8 ld [ %g1 + 0xc8 ], %o0 <== NOT EXECUTED
20029a8: 80 a7 80 08 cmp %fp, %o0 <== NOT EXECUTED
20029ac: 0a 80 00 07 bcs 20029c8 <rtems_stack_checker_is_blown+0x30><== NOT EXECUTED
20029b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
20029b4: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 <== NOT EXECUTED
20029b8: 82 02 00 01 add %o0, %g1, %g1 <== NOT EXECUTED
20029bc: 80 a0 40 1e cmp %g1, %fp <== NOT EXECUTED
20029c0: 84 60 3f ff subx %g0, -1, %g2 <== NOT EXECUTED
20029c4: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
20029c8: 03 00 80 6b sethi %hi(0x201ac00), %g1 <== NOT EXECUTED
20029cc: c4 00 63 04 ld [ %g1 + 0x304 ], %g2 ! 201af04 <Stack_check_Initialized><== NOT EXECUTED
20029d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20029d4: 12 80 00 0d bne 2002a08 <rtems_stack_checker_is_blown+0x70><== NOT EXECUTED
20029d8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
20029dc: 80 8e 20 ff btst 0xff, %i0 <== NOT EXECUTED
20029e0: 02 80 00 05 be 20029f4 <rtems_stack_checker_is_blown+0x5c><== NOT EXECUTED
20029e4: 92 08 60 ff and %g1, 0xff, %o1 <== NOT EXECUTED
20029e8: 92 88 60 ff andcc %g1, 0xff, %o1 <== NOT EXECUTED
20029ec: 12 80 00 05 bne 2002a00 <rtems_stack_checker_is_blown+0x68><== NOT EXECUTED
20029f0: 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 );
20029f4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED
20029f8: 7f ff ff cf call 2002934 <Stack_check_report_blown_task> <== NOT EXECUTED
20029fc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return true;
}
2002a00: 81 c7 e0 08 ret <== NOT EXECUTED
2002a04: 81 e8 00 00 restore <== NOT EXECUTED
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
pattern_ok = (!memcmp(
2002a08: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
2002a0c: 13 00 80 6c sethi %hi(0x201b000), %o1 <== NOT EXECUTED
2002a10: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
2002a14: 40 00 30 d6 call 200ed6c <memcmp> <== NOT EXECUTED
2002a18: 92 12 61 88 or %o1, 0x188, %o1 <== NOT EXECUTED
2002a1c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
2002a20: 10 bf ff ef b 20029dc <rtems_stack_checker_is_blown+0x44> <== NOT EXECUTED
2002a24: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
02002918 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
2002918: 13 00 80 10 sethi %hi(0x2004000), %o1 <== NOT EXECUTED
200291c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2002920: 92 12 60 5c or %o1, 0x5c, %o1 <== NOT EXECUTED
2002924: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2002928: 7f ff ff e6 call 20028c0 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
200292c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
020028c0 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
20028c0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
print_context = context;
20028c4: 23 00 80 6b sethi %hi(0x201ac00), %l1 <== NOT EXECUTED
print_handler = print;
20028c8: 21 00 80 6b sethi %hi(0x201ac00), %l0 <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
print_context = context;
20028cc: f0 24 63 08 st %i0, [ %l1 + 0x308 ] <== NOT EXECUTED
print_handler = print;
20028d0: f2 24 23 0c st %i1, [ %l0 + 0x30c ] <== NOT EXECUTED
(*print)( context, "Stack usage by thread\n");
20028d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20028d8: 13 00 80 62 sethi %hi(0x2018800), %o1 <== NOT EXECUTED
20028dc: 9f c6 40 00 call %i1 <== NOT EXECUTED
20028e0: 92 12 60 40 or %o1, 0x40, %o1 ! 2018840 <pollCallbacks.4767+0x368><== NOT EXECUTED
(*print)( context,
20028e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20028e8: 13 00 80 62 sethi %hi(0x2018800), %o1 <== NOT EXECUTED
20028ec: 9f c6 40 00 call %i1 <== NOT EXECUTED
20028f0: 92 12 60 58 or %o1, 0x58, %o1 ! 2018858 <pollCallbacks.4767+0x380><== 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 );
20028f4: 11 00 80 09 sethi %hi(0x2002400), %o0 <== NOT EXECUTED
20028f8: 40 00 15 a0 call 2007f78 <rtems_iterate_over_all_threads> <== NOT EXECUTED
20028fc: 90 12 23 68 or %o0, 0x368, %o0 ! 2002768 <Stack_check_Dump_threads_usage><== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
2002900: 7f ff ff 9a call 2002768 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
2002904: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
print_context = NULL;
2002908: c0 24 63 08 clr [ %l1 + 0x308 ] <== NOT EXECUTED
print_handler = NULL;
200290c: c0 24 23 0c clr [ %l0 + 0x30c ] <== NOT EXECUTED
}
2002910: 81 c7 e0 08 ret <== NOT EXECUTED
2002914: 81 e8 00 00 restore <== NOT EXECUTED
02002a28 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running,
Thread_Control *heir
)
{
2002a28: 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;
2002a2c: c4 06 20 c8 ld [ %i0 + 0xc8 ], %g2
)
{
void *sp = __builtin_frame_address(0);
#if defined(__GNUC__)
if ( sp < the_stack->area ) {
2002a30: 80 a7 80 02 cmp %fp, %g2
2002a34: 0a 80 00 07 bcs 2002a50 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
2002a38: 90 00 a0 08 add %g2, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
2002a3c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1
2002a40: 82 00 80 01 add %g2, %g1, %g1
2002a44: 80 a7 80 01 cmp %fp, %g1
2002a48: 28 80 00 0b bleu,a 2002a74 <rtems_stack_checker_switch_extension+0x4c><== ALWAYS TAKEN
2002a4c: 13 00 80 6c sethi %hi(0x201b000), %o1
/*
* 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,
2002a50: 13 00 80 6c sethi %hi(0x201b000), %o1 <== NOT EXECUTED
2002a54: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED
2002a58: 40 00 30 c5 call 200ed6c <memcmp> <== NOT EXECUTED
2002a5c: 92 12 61 88 or %o1, 0x188, %o1 <== NOT EXECUTED
2002a60: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
2002a64: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
2002a68: b2 08 60 01 and %g1, 1, %i1
2002a6c: 7f ff ff b2 call 2002934 <Stack_check_report_blown_task>
2002a70: 81 e8 00 00 restore
/*
* 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,
2002a74: 94 10 20 10 mov 0x10, %o2
2002a78: 40 00 30 bd call 200ed6c <memcmp>
2002a7c: 92 12 61 88 or %o1, 0x188, %o1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
2002a80: 80 a2 20 00 cmp %o0, 0
2002a84: 12 bf ff f9 bne 2002a68 <rtems_stack_checker_switch_extension+0x40>
2002a88: 82 10 20 00 clr %g1
2002a8c: 81 c7 e0 08 ret
2002a90: 81 e8 00 00 restore
02002e40 <rtems_status_text>:
const char *
rtems_status_text(
rtems_status_code status
)
{
2002e40: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
return rtems_assoc_name_by_local(rtems_status_assoc, status);
2002e44: 11 00 80 65 sethi %hi(0x2019400), %o0 <== NOT EXECUTED
2002e48: 90 12 20 d8 or %o0, 0xd8, %o0 ! 20194d8 <rtems_status_assoc><== NOT EXECUTED
2002e4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2002e50: 40 00 25 e4 call 200c5e0 <rtems_assoc_name_by_local> <== NOT EXECUTED
2002e54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02005a2c <rtems_task_create>:
size_t stack_size,
rtems_mode initial_modes,
rtems_attribute attribute_set,
Objects_Id *id
)
{
2005a2c: 9d e3 bf 78 save %sp, -136, %sp
2005a30: a4 10 00 18 mov %i0, %l2
Priority_Control core_priority;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !id )
2005a34: 80 a7 60 00 cmp %i5, 0
2005a38: 02 80 00 38 be 2005b18 <rtems_task_create+0xec> <== NEVER TAKEN
2005a3c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !rtems_is_name_valid( name ) )
2005a40: 80 a4 a0 00 cmp %l2, 0
2005a44: 02 80 00 35 be 2005b18 <rtems_task_create+0xec>
2005a48: 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 ) ) {
2005a4c: 03 00 00 20 sethi %hi(0x8000), %g1
2005a50: 80 8f 00 01 btst %i4, %g1
2005a54: 12 80 00 09 bne 2005a78 <rtems_task_create+0x4c>
2005a58: 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 ) &&
2005a5c: 02 80 00 2f be 2005b18 <rtems_task_create+0xec>
2005a60: b0 10 20 13 mov 0x13, %i0
2005a64: 03 00 80 59 sethi %hi(0x2016400), %g1
2005a68: c4 08 62 34 ldub [ %g1 + 0x234 ], %g2 ! 2016634 <rtems_maximum_priority>
2005a6c: 80 a6 40 02 cmp %i1, %g2
2005a70: 18 80 00 38 bgu 2005b50 <rtems_task_create+0x124> <== NEVER TAKEN
2005a74: 01 00 00 00 nop
*/
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
2005a78: 31 00 80 5d sethi %hi(0x2017400), %i0
2005a7c: d0 06 20 9c ld [ %i0 + 0x9c ], %o0 ! 201749c <_RTEMS_Allocator_Mutex>
2005a80: 40 00 02 07 call 200629c <_API_Mutex_Lock>
2005a84: 23 00 80 5c sethi %hi(0x2017000), %l1
* 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 );
2005a88: 40 00 04 51 call 2006bcc <_Objects_Allocate>
2005a8c: 90 14 62 ec or %l1, 0x2ec, %o0 ! 20172ec <_RTEMS_tasks_Information>
* the event of an error.
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
2005a90: a0 92 20 00 orcc %o0, 0, %l0
2005a94: 02 80 00 2c be 2005b44 <rtems_task_create+0x118>
2005a98: 83 36 e0 08 srl %i3, 8, %g1
/*
* Initialize the core thread for this task.
*/
status = _Thread_Initialize(
2005a9c: 85 36 e0 09 srl %i3, 9, %g2
2005aa0: 82 18 60 01 xor %g1, 1, %g1
2005aa4: 84 08 a0 01 and %g2, 1, %g2
2005aa8: 82 08 60 01 and %g1, 1, %g1
2005aac: c4 23 a0 60 st %g2, [ %sp + 0x60 ]
2005ab0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2005ab4: 84 07 bf f4 add %fp, -12, %g2
2005ab8: 82 0e e0 0f and %i3, 0xf, %g1
2005abc: e4 27 bf f4 st %l2, [ %fp + -12 ]
2005ac0: c0 23 a0 64 clr [ %sp + 0x64 ]
2005ac4: 90 14 62 ec or %l1, 0x2ec, %o0
2005ac8: 96 10 00 1a mov %i2, %o3
2005acc: 98 0f 20 01 and %i4, 1, %o4
2005ad0: 9a 10 00 19 mov %i1, %o5
2005ad4: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
2005ad8: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
2005adc: 92 10 00 10 mov %l0, %o1
2005ae0: 40 00 08 60 call 2007c60 <_Thread_Initialize>
2005ae4: 94 10 20 00 clr %o2
NULL, /* no budget algorithm callout */
_Modes_Get_interrupt_level(initial_modes),
(Objects_Name) name
);
if ( !status ) {
2005ae8: 80 8a 20 ff btst 0xff, %o0
2005aec: 02 80 00 0d be 2005b20 <rtems_task_create+0xf4>
2005af0: d0 06 20 9c ld [ %i0 + 0x9c ], %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;
2005af4: c2 04 20 08 ld [ %l0 + 8 ], %g1
}
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
2005af8: c6 04 21 68 ld [ %l0 + 0x168 ], %g3
2005afc: 85 36 e0 0a srl %i3, 0xa, %g2
2005b00: 84 18 a0 01 xor %g2, 1, %g2
2005b04: 84 08 a0 01 and %g2, 1, %g2
*id = the_thread->Object.id;
2005b08: 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;
2005b0c: c4 28 e0 08 stb %g2, [ %g3 + 8 ]
);
}
#endif
_RTEMS_Unlock_allocator();
2005b10: 40 00 01 f9 call 20062f4 <_API_Mutex_Unlock>
2005b14: b0 10 20 00 clr %i0
2005b18: 81 c7 e0 08 ret
2005b1c: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
Thread_Control *the_task
)
{
_Objects_Free(
2005b20: 40 00 05 4b call 200704c <_Objects_Get_information_id>
2005b24: d0 04 20 08 ld [ %l0 + 8 ], %o0
2005b28: 40 00 05 24 call 2006fb8 <_Objects_Free>
2005b2c: 92 10 00 10 mov %l0, %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();
2005b30: d0 06 20 9c ld [ %i0 + 0x9c ], %o0
2005b34: 40 00 01 f0 call 20062f4 <_API_Mutex_Unlock>
2005b38: b0 10 20 0d mov 0xd, %i0
2005b3c: 81 c7 e0 08 ret
2005b40: 81 e8 00 00 restore
*/
the_thread = _RTEMS_tasks_Allocate();
if ( !the_thread ) {
_RTEMS_Unlock_allocator();
2005b44: d0 06 20 9c ld [ %i0 + 0x9c ], %o0
2005b48: 40 00 01 eb call 20062f4 <_API_Mutex_Unlock>
2005b4c: b0 10 20 05 mov 5, %i0
2005b50: 81 c7 e0 08 ret
2005b54: 81 e8 00 00 restore
020076f8 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
20076f8: 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() )
20076fc: 03 00 80 73 sethi %hi(0x201cc00), %g1
2007700: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 201ccac <_Configuration_Table>
rtems_status_code rtems_task_get_note(
Objects_Id id,
uint32_t notepad,
uint32_t *note
)
{
2007704: 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() )
2007708: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1
200770c: c4 08 60 04 ldub [ %g1 + 4 ], %g2
2007710: 80 a0 a0 00 cmp %g2, 0
2007714: 02 80 00 20 be 2007794 <rtems_task_get_note+0x9c> <== NEVER TAKEN
2007718: b0 10 20 16 mov 0x16, %i0
return RTEMS_NOT_CONFIGURED;
if ( !note )
200771c: 80 a6 a0 00 cmp %i2, 0
2007720: 02 80 00 1d be 2007794 <rtems_task_get_note+0x9c> <== NEVER TAKEN
2007724: 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 )
2007728: 80 a6 60 0f cmp %i1, 0xf
200772c: 18 80 00 1a bgu 2007794 <rtems_task_get_note+0x9c>
2007730: b0 10 20 0a mov 0xa, %i0
2007734: 03 00 80 73 sethi %hi(0x201cc00), %g1
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
2007738: 80 a2 20 00 cmp %o0, 0
200773c: 02 80 00 18 be 200779c <rtems_task_get_note+0xa4>
2007740: 86 10 60 d4 or %g1, 0xd4, %g3
2007744: 03 00 80 73 sethi %hi(0x201cc00), %g1
2007748: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2 ! 201ccd4 <_Thread_Executing>
200774c: 86 10 60 d4 or %g1, 0xd4, %g3
2007750: c2 00 a0 08 ld [ %g2 + 8 ], %g1
2007754: 80 a2 00 01 cmp %o0, %g1
2007758: 22 80 00 12 be,a 20077a0 <rtems_task_get_note+0xa8>
200775c: c4 00 c0 00 ld [ %g3 ], %g2
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
2007760: 40 00 08 d0 call 2009aa0 <_Thread_Get>
2007764: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2007768: c2 07 bf f4 ld [ %fp + -12 ], %g1
200776c: 80 a0 60 00 cmp %g1, 0
2007770: 12 80 00 09 bne 2007794 <rtems_task_get_note+0x9c>
2007774: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
2007778: c2 02 21 68 ld [ %o0 + 0x168 ], %g1
200777c: 84 06 60 08 add %i1, 8, %g2
2007780: 85 28 a0 02 sll %g2, 2, %g2
2007784: c6 00 40 02 ld [ %g1 + %g2 ], %g3
_Thread_Enable_dispatch();
2007788: b0 10 20 00 clr %i0
200778c: 40 00 08 b7 call 2009a68 <_Thread_Enable_dispatch>
2007790: c6 26 80 00 st %g3, [ %i2 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2007794: 81 c7 e0 08 ret
2007798: 81 e8 00 00 restore
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
*note = api->Notepads[ notepad ];
200779c: c4 00 c0 00 ld [ %g3 ], %g2
20077a0: 82 06 60 08 add %i1, 8, %g1
20077a4: c6 00 a1 68 ld [ %g2 + 0x168 ], %g3
20077a8: 83 28 60 02 sll %g1, 2, %g1
20077ac: c4 00 c0 01 ld [ %g3 + %g1 ], %g2
20077b0: c4 26 80 00 st %g2, [ %i2 ]
20077b4: 81 c7 e0 08 ret
20077b8: 91 e8 20 00 restore %g0, 0, %o0
02005bd4 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
rtems_name name,
uint32_t node,
Objects_Id *id
)
{
2005bd4: 9d e3 bf 98 save %sp, -104, %sp
2005bd8: 92 10 00 18 mov %i0, %o1
2005bdc: 96 10 00 1a mov %i2, %o3
2005be0: 94 10 00 19 mov %i1, %o2
Objects_Name_or_id_lookup_errors status;
if ( !id )
2005be4: 80 a6 a0 00 cmp %i2, 0
2005be8: 02 80 00 11 be 2005c2c <rtems_task_ident+0x58> <== NEVER TAKEN
2005bec: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( name == OBJECTS_ID_OF_SELF ) {
2005bf0: 80 a2 60 00 cmp %o1, 0
2005bf4: 12 80 00 07 bne 2005c10 <rtems_task_ident+0x3c>
2005bf8: 03 00 80 5d sethi %hi(0x2017400), %g1
*id = _Thread_Executing->Object.id;
2005bfc: c4 00 60 a4 ld [ %g1 + 0xa4 ], %g2 ! 20174a4 <_Thread_Executing>
2005c00: c2 00 a0 08 ld [ %g2 + 8 ], %g1
2005c04: c2 26 80 00 st %g1, [ %i2 ]
2005c08: 81 c7 e0 08 ret
2005c0c: 91 e8 20 00 restore %g0, 0, %o0
return RTEMS_SUCCESSFUL;
}
status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
2005c10: 11 00 80 5c sethi %hi(0x2017000), %o0
2005c14: 40 00 05 b6 call 20072ec <_Objects_Name_to_id_u32>
2005c18: 90 12 22 ec or %o0, 0x2ec, %o0 ! 20172ec <_RTEMS_tasks_Information>
return _Status_Object_name_errors_to_status[ status ];
2005c1c: 03 00 80 56 sethi %hi(0x2015800), %g1
2005c20: 91 2a 20 02 sll %o0, 2, %o0
2005c24: 82 10 62 30 or %g1, 0x230, %g1
2005c28: f0 00 40 08 ld [ %g1 + %o0 ], %i0
}
2005c2c: 81 c7 e0 08 ret
2005c30: 81 e8 00 00 restore
02006258 <rtems_task_is_suspended>:
*/
rtems_status_code rtems_task_is_suspended(
Objects_Id id
)
{
2006258: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200625c: 90 10 00 18 mov %i0, %o0
2006260: 40 00 07 d4 call 20081b0 <_Thread_Get>
2006264: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2006268: c2 07 bf f4 ld [ %fp + -12 ], %g1
200626c: 80 a0 60 00 cmp %g1, 0
2006270: 12 80 00 08 bne 2006290 <rtems_task_is_suspended+0x38> <== NEVER TAKEN
2006274: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
2006278: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
200627c: 80 88 60 02 btst 2, %g1
2006280: 02 80 00 06 be 2006298 <rtems_task_is_suspended+0x40>
2006284: 01 00 00 00 nop
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
2006288: 40 00 07 bc call 2008178 <_Thread_Enable_dispatch>
200628c: b0 10 20 0f mov 0xf, %i0 ! f <PROM_START+0xf>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2006290: 81 c7 e0 08 ret
2006294: 81 e8 00 00 restore
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( !_States_Is_suspended( the_thread->current_state ) ) {
_Thread_Enable_dispatch();
2006298: 40 00 07 b8 call 2008178 <_Thread_Enable_dispatch>
200629c: b0 10 20 00 clr %i0
20062a0: 81 c7 e0 08 ret
20062a4: 81 e8 00 00 restore
0200c820 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
200c820: 9d e3 bf 98 save %sp, -104, %sp
200c824: 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 )
200c828: 80 a6 a0 00 cmp %i2, 0
200c82c: 02 80 00 44 be 200c93c <rtems_task_mode+0x11c> <== NEVER TAKEN
200c830: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
200c834: 03 00 80 5d sethi %hi(0x2017400), %g1
200c838: e4 00 60 a4 ld [ %g1 + 0xa4 ], %l2 ! 20174a4 <_Thread_Executing>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200c83c: c4 0c a0 76 ldub [ %l2 + 0x76 ], %g2
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200c840: c6 04 a0 7c ld [ %l2 + 0x7c ], %g3
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200c844: 80 a0 00 02 cmp %g0, %g2
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
200c848: e6 04 a1 68 ld [ %l2 + 0x168 ], %l3
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200c84c: 82 60 3f ff subx %g0, -1, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200c850: 80 a0 e0 00 cmp %g3, 0
200c854: 12 80 00 3c bne 200c944 <rtems_task_mode+0x124>
200c858: a3 28 60 08 sll %g1, 8, %l1
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200c85c: c2 0c e0 08 ldub [ %l3 + 8 ], %g1
200c860: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
200c864: 7f ff f3 c4 call 2009774 <_CPU_ISR_Get_level>
200c868: 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;
200c86c: a1 2c 20 0a sll %l0, 0xa, %l0
200c870: a0 14 00 08 or %l0, %o0, %l0
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
200c874: a0 14 00 11 or %l0, %l1, %l0
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
200c878: 80 8e 61 00 btst 0x100, %i1
200c87c: 02 80 00 06 be 200c894 <rtems_task_mode+0x74>
200c880: e0 26 80 00 st %l0, [ %i2 ]
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
200c884: 83 35 20 08 srl %l4, 8, %g1
200c888: 82 18 60 01 xor %g1, 1, %g1
200c88c: 82 08 60 01 and %g1, 1, %g1
200c890: c2 2c a0 76 stb %g1, [ %l2 + 0x76 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
200c894: 80 8e 62 00 btst 0x200, %i1
200c898: 02 80 00 0b be 200c8c4 <rtems_task_mode+0xa4>
200c89c: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
200c8a0: 80 8d 22 00 btst 0x200, %l4
200c8a4: 22 80 00 07 be,a 200c8c0 <rtems_task_mode+0xa0>
200c8a8: c0 24 a0 7c clr [ %l2 + 0x7c ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
200c8ac: 03 00 80 5c sethi %hi(0x2017000), %g1
200c8b0: c4 00 63 38 ld [ %g1 + 0x338 ], %g2 ! 2017338 <_Thread_Ticks_per_timeslice>
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;
200c8b4: 82 10 20 01 mov 1, %g1
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
200c8b8: c4 24 a0 78 st %g2, [ %l2 + 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;
200c8bc: c2 24 a0 7c st %g1, [ %l2 + 0x7c ]
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
200c8c0: 80 8e 60 0f btst 0xf, %i1
200c8c4: 12 80 00 2d bne 200c978 <rtems_task_mode+0x158>
200c8c8: 01 00 00 00 nop
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
200c8cc: 80 8e 64 00 btst 0x400, %i1
200c8d0: 02 80 00 16 be 200c928 <rtems_task_mode+0x108>
200c8d4: a0 10 20 00 clr %l0
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
200c8d8: c4 0c e0 08 ldub [ %l3 + 8 ], %g2
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
200c8dc: 83 35 20 0a srl %l4, 0xa, %g1
200c8e0: 82 18 60 01 xor %g1, 1, %g1
200c8e4: 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 ) {
200c8e8: 80 a0 80 01 cmp %g2, %g1
200c8ec: 22 80 00 10 be,a 200c92c <rtems_task_mode+0x10c>
200c8f0: 03 00 80 5d sethi %hi(0x2017400), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
200c8f4: 7f ff d5 3c call 2001de4 <sparc_disable_interrupts>
200c8f8: c2 2c e0 08 stb %g1, [ %l3 + 8 ]
_signals = information->signals_pending;
200c8fc: c2 04 e0 18 ld [ %l3 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
200c900: c4 04 e0 14 ld [ %l3 + 0x14 ], %g2
information->signals_posted = _signals;
200c904: c2 24 e0 14 st %g1, [ %l3 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
200c908: c4 24 e0 18 st %g2, [ %l3 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
200c90c: 7f ff d5 3a call 2001df4 <sparc_enable_interrupts>
200c910: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
200c914: c2 04 e0 14 ld [ %l3 + 0x14 ], %g1
200c918: 80 a0 60 00 cmp %g1, 0
200c91c: 12 80 00 27 bne 200c9b8 <rtems_task_mode+0x198>
200c920: 82 10 20 01 mov 1, %g1
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
200c924: a0 10 20 00 clr %l0
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
200c928: 03 00 80 5d sethi %hi(0x2017400), %g1
200c92c: c4 00 61 84 ld [ %g1 + 0x184 ], %g2 ! 2017584 <_System_state_Current>
200c930: 80 a0 a0 03 cmp %g2, 3
200c934: 02 80 00 16 be 200c98c <rtems_task_mode+0x16c> <== ALWAYS TAKEN
200c938: b0 10 20 00 clr %i0
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
_Thread_Dispatch();
return RTEMS_SUCCESSFUL;
}
200c93c: 81 c7 e0 08 ret
200c940: 81 e8 00 00 restore
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;
200c944: c2 0c e0 08 ldub [ %l3 + 8 ], %g1
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
200c948: a2 14 62 00 or %l1, 0x200, %l1
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200c94c: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
200c950: 7f ff f3 89 call 2009774 <_CPU_ISR_Get_level>
200c954: 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;
200c958: a1 2c 20 0a sll %l0, 0xa, %l0
200c95c: a0 14 00 08 or %l0, %o0, %l0
old_mode |= _ISR_Get_level();
*previous_mode_set = old_mode;
200c960: a0 14 00 11 or %l0, %l1, %l0
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
200c964: 80 8e 61 00 btst 0x100, %i1
200c968: 02 bf ff cb be 200c894 <rtems_task_mode+0x74>
200c96c: e0 26 80 00 st %l0, [ %i2 ]
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
200c970: 10 bf ff c6 b 200c888 <rtems_task_mode+0x68>
200c974: 83 35 20 08 srl %l4, 8, %g1
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
200c978: 90 0d 20 0f and %l4, 0xf, %o0
200c97c: 7f ff d5 1e call 2001df4 <sparc_enable_interrupts>
200c980: 91 2a 20 08 sll %o0, 8, %o0
*/
is_asr_enabled = FALSE;
needs_asr_dispatching = FALSE;
if ( mask & RTEMS_ASR_MASK ) {
200c984: 10 bf ff d3 b 200c8d0 <rtems_task_mode+0xb0>
200c988: 80 8e 64 00 btst 0x400, %i1
}
}
}
if ( _System_state_Is_up(_System_state_Current) )
if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
200c98c: 40 00 00 7c call 200cb7c <_Thread_Evaluate_mode>
200c990: 01 00 00 00 nop
200c994: 80 8a 20 ff btst 0xff, %o0
200c998: 12 80 00 04 bne 200c9a8 <rtems_task_mode+0x188>
200c99c: 80 8c 20 ff btst 0xff, %l0
200c9a0: 22 bf ff e7 be,a 200c93c <rtems_task_mode+0x11c>
200c9a4: b0 10 20 00 clr %i0
_Thread_Dispatch();
200c9a8: 7f ff ec 0d call 20079dc <_Thread_Dispatch>
200c9ac: b0 10 20 00 clr %i0
200c9b0: 81 c7 e0 08 ret
200c9b4: 81 e8 00 00 restore
if ( is_asr_enabled != asr->is_enabled ) {
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
needs_asr_dispatching = true;
executing->do_post_task_switch_extension = true;
200c9b8: a0 10 20 01 mov 1, %l0
200c9bc: 10 bf ff db b 200c928 <rtems_task_mode+0x108>
200c9c0: c2 2c a0 75 stb %g1, [ %l2 + 0x75 ]
020078c4 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
20078c4: 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() )
20078c8: 03 00 80 73 sethi %hi(0x201cc00), %g1
20078cc: c4 00 60 ac ld [ %g1 + 0xac ], %g2 ! 201ccac <_Configuration_Table>
rtems_status_code rtems_task_set_note(
Objects_Id id,
uint32_t notepad,
uint32_t note
)
{
20078d0: 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() )
20078d4: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1
20078d8: c4 08 60 04 ldub [ %g1 + 4 ], %g2
20078dc: 80 a0 a0 00 cmp %g2, 0
20078e0: 02 80 00 1c be 2007950 <rtems_task_set_note+0x8c> <== NEVER TAKEN
20078e4: 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 )
20078e8: 80 a6 60 0f cmp %i1, 0xf
20078ec: 18 80 00 19 bgu 2007950 <rtems_task_set_note+0x8c>
20078f0: b0 10 20 0a mov 0xa, %i0
20078f4: 03 00 80 73 sethi %hi(0x201cc00), %g1
/*
* Optimize the most likely case to avoid the Thread_Dispatch.
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
20078f8: 80 a2 20 00 cmp %o0, 0
20078fc: 02 80 00 17 be 2007958 <rtems_task_set_note+0x94>
2007900: 86 10 60 d4 or %g1, 0xd4, %g3
2007904: 03 00 80 73 sethi %hi(0x201cc00), %g1
2007908: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2 ! 201ccd4 <_Thread_Executing>
200790c: 86 10 60 d4 or %g1, 0xd4, %g3
2007910: c2 00 a0 08 ld [ %g2 + 8 ], %g1
2007914: 80 a2 00 01 cmp %o0, %g1
2007918: 22 80 00 11 be,a 200795c <rtems_task_set_note+0x98> <== NEVER TAKEN
200791c: c2 00 c0 00 ld [ %g3 ], %g1 <== NOT EXECUTED
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
return RTEMS_SUCCESSFUL;
}
the_thread = _Thread_Get( id, &location );
2007920: 40 00 08 60 call 2009aa0 <_Thread_Get>
2007924: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2007928: c2 07 bf f4 ld [ %fp + -12 ], %g1
200792c: 80 a0 60 00 cmp %g1, 0
2007930: 12 80 00 08 bne 2007950 <rtems_task_set_note+0x8c>
2007934: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
2007938: c4 02 21 68 ld [ %o0 + 0x168 ], %g2
200793c: 82 06 60 08 add %i1, 8, %g1
2007940: 83 28 60 02 sll %g1, 2, %g1
_Thread_Enable_dispatch();
2007944: b0 10 20 00 clr %i0
2007948: 40 00 08 48 call 2009a68 <_Thread_Enable_dispatch>
200794c: f4 20 80 01 st %i2, [ %g2 + %g1 ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2007950: 81 c7 e0 08 ret
2007954: 81 e8 00 00 restore
*/
if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
_Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
api->Notepads[ notepad ] = note;
2007958: c2 00 c0 00 ld [ %g3 ], %g1
200795c: 84 06 60 08 add %i1, 8, %g2
2007960: c6 00 61 68 ld [ %g1 + 0x168 ], %g3
2007964: 85 28 a0 02 sll %g2, 2, %g2
2007968: f4 20 c0 02 st %i2, [ %g3 + %g2 ]
200796c: 81 c7 e0 08 ret
2007970: 91 e8 20 00 restore %g0, 0, %o0
02006e40 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
Objects_Id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
2006e40: 9d e3 bf 90 save %sp, -112, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
2006e44: 80 a6 60 00 cmp %i1, 0
2006e48: 02 80 00 07 be 2006e64 <rtems_task_set_priority+0x24>
2006e4c: 90 10 00 18 mov %i0, %o0
*/
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
2006e50: 03 00 80 69 sethi %hi(0x201a400), %g1
2006e54: c4 08 62 24 ldub [ %g1 + 0x224 ], %g2 ! 201a624 <rtems_maximum_priority>
2006e58: 80 a6 40 02 cmp %i1, %g2
2006e5c: 18 80 00 1c bgu 2006ecc <rtems_task_set_priority+0x8c>
2006e60: b0 10 20 13 mov 0x13, %i0
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
2006e64: 80 a6 a0 00 cmp %i2, 0
2006e68: 02 80 00 19 be 2006ecc <rtems_task_set_priority+0x8c> <== NEVER TAKEN
2006e6c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
2006e70: 40 00 08 29 call 2008f14 <_Thread_Get>
2006e74: 92 07 bf f4 add %fp, -12, %o1
switch ( location ) {
2006e78: c2 07 bf f4 ld [ %fp + -12 ], %g1
2006e7c: 80 a0 60 00 cmp %g1, 0
2006e80: 12 80 00 13 bne 2006ecc <rtems_task_set_priority+0x8c>
2006e84: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
2006e88: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
2006e8c: 80 a6 60 00 cmp %i1, 0
2006e90: 02 80 00 0d be 2006ec4 <rtems_task_set_priority+0x84>
2006e94: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
2006e98: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
2006e9c: 80 a0 60 00 cmp %g1, 0
2006ea0: 02 80 00 06 be 2006eb8 <rtems_task_set_priority+0x78>
2006ea4: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
2006ea8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2006eac: 80 a6 40 01 cmp %i1, %g1
2006eb0: 1a 80 00 05 bcc 2006ec4 <rtems_task_set_priority+0x84> <== ALWAYS TAKEN
2006eb4: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, FALSE );
2006eb8: 92 10 00 19 mov %i1, %o1
2006ebc: 40 00 06 72 call 2008884 <_Thread_Change_priority>
2006ec0: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
2006ec4: 40 00 08 06 call 2008edc <_Thread_Enable_dispatch>
2006ec8: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2006ecc: 81 c7 e0 08 ret
2006ed0: 81 e8 00 00 restore
020075f4 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
rtems_id tid,
void **ptr,
void (*dtor)(void *)
)
{
20075f4: 9d e3 bf 90 save %sp, -112, %sp
20075f8: 90 10 00 18 mov %i0, %o0
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *new;
if ( !ptr )
20075fc: 80 a6 60 00 cmp %i1, 0
2007600: 02 80 00 18 be 2007660 <rtems_task_variable_add+0x6c> <== NEVER TAKEN
2007604: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
2007608: 40 00 08 37 call 20096e4 <_Thread_Get>
200760c: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
2007610: 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);
2007614: a0 10 00 08 mov %o0, %l0
switch (location) {
2007618: 80 a0 60 00 cmp %g1, 0
200761c: 12 80 00 11 bne 2007660 <rtems_task_variable_add+0x6c> <== NEVER TAKEN
2007620: 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;
2007624: c4 02 21 78 ld [ %o0 + 0x178 ], %g2
while (tvp) {
2007628: 80 a0 a0 00 cmp %g2, 0
200762c: 32 80 00 07 bne,a 2007648 <rtems_task_variable_add+0x54>
2007630: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2007634: 30 80 00 0d b,a 2007668 <rtems_task_variable_add+0x74>
2007638: 80 a0 a0 00 cmp %g2, 0
200763c: 02 80 00 0b be 2007668 <rtems_task_variable_add+0x74>
2007640: 01 00 00 00 nop
if (tvp->ptr == ptr) {
2007644: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2007648: 80 a0 40 19 cmp %g1, %i1
200764c: 32 bf ff fb bne,a 2007638 <rtems_task_variable_add+0x44>
2007650: c4 00 80 00 ld [ %g2 ], %g2
tvp->dtor = dtor;
2007654: f4 20 a0 10 st %i2, [ %g2 + 0x10 ]
_Thread_Enable_dispatch();
2007658: 40 00 08 15 call 20096ac <_Thread_Enable_dispatch>
200765c: b0 10 20 00 clr %i0
2007660: 81 c7 e0 08 ret
2007664: 81 e8 00 00 restore
}
/*
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
2007668: 40 00 0e 00 call 200ae68 <_Workspace_Allocate>
200766c: 90 10 20 14 mov 0x14, %o0
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
2007670: 80 a2 20 00 cmp %o0, 0
2007674: 02 80 00 0d be 20076a8 <rtems_task_variable_add+0xb4>
2007678: 01 00 00 00 nop
}
new->gval = *ptr;
new->ptr = ptr;
new->dtor = dtor;
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
200767c: c4 04 21 78 ld [ %l0 + 0x178 ], %g2
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
2007680: 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;
2007684: d0 24 21 78 st %o0, [ %l0 + 0x178 ]
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
return RTEMS_NO_MEMORY;
}
new->gval = *ptr;
2007688: c2 22 20 08 st %g1, [ %o0 + 8 ]
new->ptr = ptr;
200768c: f2 22 20 04 st %i1, [ %o0 + 4 ]
new->dtor = dtor;
2007690: f4 22 20 10 st %i2, [ %o0 + 0x10 ]
new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
2007694: c4 22 00 00 st %g2, [ %o0 ]
the_thread->task_variables = new;
_Thread_Enable_dispatch();
2007698: 40 00 08 05 call 20096ac <_Thread_Enable_dispatch>
200769c: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20076a0: 81 c7 e0 08 ret
20076a4: 81 e8 00 00 restore
* Now allocate memory for this task variable.
*/
new = (rtems_task_variable_t *)
_Workspace_Allocate(sizeof(rtems_task_variable_t));
if (new == NULL) {
_Thread_Enable_dispatch();
20076a8: 40 00 08 01 call 20096ac <_Thread_Enable_dispatch>
20076ac: b0 10 20 1a mov 0x1a, %i0
20076b0: 81 c7 e0 08 ret
20076b4: 81 e8 00 00 restore
020076b8 <rtems_task_variable_delete>:
rtems_status_code rtems_task_variable_delete(
rtems_id tid,
void **ptr
)
{
20076b8: 9d e3 bf 90 save %sp, -112, %sp
20076bc: 90 10 00 18 mov %i0, %o0
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp, *prev;
if ( !ptr )
20076c0: 80 a6 60 00 cmp %i1, 0
20076c4: 02 80 00 1c be 2007734 <rtems_task_variable_delete+0x7c>
20076c8: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
prev = NULL;
the_thread = _Thread_Get (tid, &location);
20076cc: 40 00 08 06 call 20096e4 <_Thread_Get>
20076d0: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
20076d4: c2 07 bf f4 ld [ %fp + -12 ], %g1
20076d8: 80 a0 60 00 cmp %g1, 0
20076dc: 12 80 00 16 bne 2007734 <rtems_task_variable_delete+0x7c> <== NEVER TAKEN
20076e0: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
20076e4: d2 02 21 78 ld [ %o0 + 0x178 ], %o1
while (tvp) {
20076e8: 80 a2 60 00 cmp %o1, 0
20076ec: 02 80 00 10 be 200772c <rtems_task_variable_delete+0x74>
20076f0: 01 00 00 00 nop
if (tvp->ptr == ptr) {
20076f4: c2 02 60 04 ld [ %o1 + 4 ], %g1
20076f8: 80 a0 40 19 cmp %g1, %i1
20076fc: 12 80 00 08 bne 200771c <rtems_task_variable_delete+0x64>
2007700: 84 10 00 09 mov %o1, %g2
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
2007704: 10 80 00 15 b 2007758 <rtems_task_variable_delete+0xa0>
2007708: c2 02 40 00 ld [ %o1 ], %g1
switch (location) {
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
200770c: 80 a0 40 19 cmp %g1, %i1
2007710: 22 80 00 0b be,a 200773c <rtems_task_variable_delete+0x84>
2007714: c2 02 40 00 ld [ %o1 ], %g1
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
2007718: 84 10 00 09 mov %o1, %g2
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
200771c: 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) {
2007720: 80 a2 60 00 cmp %o1, 0
2007724: 32 bf ff fa bne,a 200770c <rtems_task_variable_delete+0x54><== ALWAYS TAKEN
2007728: c2 02 60 04 ld [ %o1 + 4 ], %g1
return RTEMS_SUCCESSFUL;
}
prev = tvp;
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
200772c: 40 00 07 e0 call 20096ac <_Thread_Enable_dispatch>
2007730: b0 10 20 09 mov 9, %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2007734: 81 c7 e0 08 ret
2007738: 81 e8 00 00 restore
case OBJECTS_LOCAL:
tvp = the_thread->task_variables;
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
200773c: c2 20 80 00 st %g1, [ %g2 ]
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
_RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
2007740: 40 00 00 2d call 20077f4 <_RTEMS_Tasks_Invoke_task_variable_dtor>
2007744: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
2007748: 40 00 07 d9 call 20096ac <_Thread_Enable_dispatch>
200774c: 01 00 00 00 nop
2007750: 81 c7 e0 08 ret
2007754: 81 e8 00 00 restore
while (tvp) {
if (tvp->ptr == ptr) {
if (prev)
prev->next = tvp->next;
else
the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
2007758: 10 bf ff fa b 2007740 <rtems_task_variable_delete+0x88>
200775c: c2 22 21 78 st %g1, [ %o0 + 0x178 ]
02007760 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
rtems_id tid,
void **ptr,
void **result
)
{
2007760: 9d e3 bf 90 save %sp, -112, %sp
Thread_Control *the_thread;
Objects_Locations location;
rtems_task_variable_t *tvp;
if ( !ptr )
2007764: 80 a6 60 00 cmp %i1, 0
2007768: 02 80 00 1d be 20077dc <rtems_task_variable_get+0x7c>
200776c: 90 10 00 18 mov %i0, %o0
return RTEMS_INVALID_ADDRESS;
if ( !result )
2007770: 80 a6 a0 00 cmp %i2, 0
2007774: 02 80 00 18 be 20077d4 <rtems_task_variable_get+0x74>
2007778: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get (tid, &location);
200777c: 40 00 07 da call 20096e4 <_Thread_Get>
2007780: 92 07 bf f4 add %fp, -12, %o1
switch (location) {
2007784: c2 07 bf f4 ld [ %fp + -12 ], %g1
2007788: 80 a0 60 00 cmp %g1, 0
200778c: 12 80 00 12 bne 20077d4 <rtems_task_variable_get+0x74> <== NEVER TAKEN
2007790: 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;
2007794: d0 02 21 78 ld [ %o0 + 0x178 ], %o0
while (tvp) {
2007798: 80 a2 20 00 cmp %o0, 0
200779c: 32 80 00 07 bne,a 20077b8 <rtems_task_variable_get+0x58>
20077a0: c2 02 20 04 ld [ %o0 + 4 ], %g1
20077a4: 30 80 00 10 b,a 20077e4 <rtems_task_variable_get+0x84>
20077a8: 80 a2 20 00 cmp %o0, 0
20077ac: 02 80 00 0e be 20077e4 <rtems_task_variable_get+0x84> <== NEVER TAKEN
20077b0: 01 00 00 00 nop
if (tvp->ptr == ptr) {
20077b4: c2 02 20 04 ld [ %o0 + 4 ], %g1
20077b8: 80 a0 40 19 cmp %g1, %i1
20077bc: 32 bf ff fb bne,a 20077a8 <rtems_task_variable_get+0x48>
20077c0: 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;
20077c4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
20077c8: b0 10 20 00 clr %i0
20077cc: 40 00 07 b8 call 20096ac <_Thread_Enable_dispatch>
20077d0: c2 26 80 00 st %g1, [ %i2 ]
20077d4: 81 c7 e0 08 ret
20077d8: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20077dc: 81 c7 e0 08 ret
20077e0: 91 e8 20 09 restore %g0, 9, %o0
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
tvp = (rtems_task_variable_t *)tvp->next;
}
_Thread_Enable_dispatch();
20077e4: 40 00 07 b2 call 20096ac <_Thread_Enable_dispatch>
20077e8: b0 10 20 09 mov 9, %i0
20077ec: 81 c7 e0 08 ret
20077f0: 81 e8 00 00 restore
02007358 <rtems_task_wake_when>:
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
2007358: 9d e3 bf 98 save %sp, -104, %sp
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
200735c: 03 00 80 6b sethi %hi(0x201ac00), %g1
2007360: c4 08 61 b4 ldub [ %g1 + 0x1b4 ], %g2 ! 201adb4 <_TOD_Is_set>
*/
rtems_status_code rtems_task_wake_when(
rtems_time_of_day *time_buffer
)
{
2007364: a0 10 00 18 mov %i0, %l0
Watchdog_Interval seconds;
if ( !_TOD_Is_set )
2007368: 80 a0 a0 00 cmp %g2, 0
200736c: 02 80 00 2e be 2007424 <rtems_task_wake_when+0xcc>
2007370: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !time_buffer )
2007374: 80 a4 20 00 cmp %l0, 0
2007378: 02 80 00 2b be 2007424 <rtems_task_wake_when+0xcc> <== NEVER TAKEN
200737c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
time_buffer->ticks = 0;
2007380: c0 24 20 18 clr [ %l0 + 0x18 ]
if ( !_TOD_Validate( time_buffer ) )
2007384: 7f ff fc bd call 2006678 <_TOD_Validate>
2007388: 90 10 00 10 mov %l0, %o0
200738c: 80 8a 20 ff btst 0xff, %o0
2007390: 12 80 00 04 bne 20073a0 <rtems_task_wake_when+0x48>
2007394: 01 00 00 00 nop
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
2007398: 81 c7 e0 08 ret
200739c: 91 e8 20 14 restore %g0, 0x14, %o0
time_buffer->ticks = 0;
if ( !_TOD_Validate( time_buffer ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( time_buffer );
20073a0: 7f ff fc 81 call 20065a4 <_TOD_To_seconds>
20073a4: 90 10 00 10 mov %l0, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
20073a8: 23 00 80 6b sethi %hi(0x201ac00), %l1
20073ac: c2 04 62 34 ld [ %l1 + 0x234 ], %g1 ! 201ae34 <_TOD_Now>
20073b0: 80 a2 00 01 cmp %o0, %g1
20073b4: 08 bf ff f9 bleu 2007398 <rtems_task_wake_when+0x40>
20073b8: b0 10 00 08 mov %o0, %i0
20073bc: 05 00 80 6b sethi %hi(0x201ac00), %g2
20073c0: c2 00 a1 a0 ld [ %g2 + 0x1a0 ], %g1 ! 201ada0 <_Thread_Dispatch_disable_level>
20073c4: 82 00 60 01 inc %g1
20073c8: c2 20 a1 a0 st %g1, [ %g2 + 0x1a0 ]
return RTEMS_INVALID_CLOCK;
_Thread_Disable_dispatch();
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
20073cc: 21 00 80 6b sethi %hi(0x201ac00), %l0
20073d0: d0 04 22 64 ld [ %l0 + 0x264 ], %o0 ! 201ae64 <_Thread_Executing>
20073d4: 40 00 0a 26 call 2009c6c <_Thread_Set_state>
20073d8: 92 10 20 10 mov 0x10, %o1
_Watchdog_Initialize(
20073dc: c4 04 22 64 ld [ %l0 + 0x264 ], %g2
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
20073e0: 11 00 80 6b sethi %hi(0x201ac00), %o0
20073e4: c6 00 a0 08 ld [ %g2 + 8 ], %g3
20073e8: 90 12 22 78 or %o0, 0x278, %o0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
20073ec: c6 20 a0 68 st %g3, [ %g2 + 0x68 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20073f0: c2 04 62 34 ld [ %l1 + 0x234 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
20073f4: 92 00 a0 48 add %g2, 0x48, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20073f8: 82 26 00 01 sub %i0, %g1, %g1
20073fc: c2 20 a0 54 st %g1, [ %g2 + 0x54 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2007400: 03 00 80 24 sethi %hi(0x2009000), %g1
2007404: 82 10 60 18 or %g1, 0x18, %g1 ! 2009018 <_Thread_Delay_ended>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2007408: c0 20 a0 50 clr [ %g2 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
200740c: c0 20 a0 6c clr [ %g2 + 0x6c ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2007410: c2 20 a0 64 st %g1, [ %g2 + 0x64 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
2007414: 40 00 0c 5e call 200a58c <_Watchdog_Insert>
2007418: b0 10 20 00 clr %i0
);
_Watchdog_Insert_seconds(
&_Thread_Executing->Timer,
seconds - _TOD_Seconds_since_epoch
);
_Thread_Enable_dispatch();
200741c: 40 00 07 76 call 20091f4 <_Thread_Enable_dispatch>
2007420: 01 00 00 00 nop
2007424: 81 c7 e0 08 ret
2007428: 81 e8 00 00 restore
02003054 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
2003054: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
2003058: 05 00 80 5a sethi %hi(0x2016800), %g2 <== NOT EXECUTED
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
200305c: d0 20 62 94 st %o0, [ %g1 + 0x294 ] <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input;
2003060: d2 20 a2 98 st %o1, [ %g2 + 0x298 ] <== NOT EXECUTED
rtems_termios_raw_output_size = raw_output;
2003064: 03 00 80 5a sethi %hi(0x2016800), %g1 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
2003068: 90 10 20 00 clr %o0 <== NOT EXECUTED
200306c: 81 c3 e0 08 retl <== NOT EXECUTED
2003070: d4 20 62 9c st %o2, [ %g1 + 0x29c ] <== NOT EXECUTED
02004790 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
2004790: 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);
2004794: 23 00 80 5c sethi %hi(0x2017000), %l1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2004798: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200479c: d0 04 62 a0 ld [ %l1 + 0x2a0 ], %o0
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20047a0: e0 00 60 28 ld [ %g1 + 0x28 ], %l0
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20047a4: 92 10 20 00 clr %o1
20047a8: 40 00 04 2e call 2005860 <rtems_semaphore_obtain>
20047ac: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20047b0: 80 a2 20 00 cmp %o0, 0
20047b4: 12 80 00 52 bne 20048fc <rtems_termios_close+0x16c> <== NEVER TAKEN
20047b8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
20047bc: c2 04 20 08 ld [ %l0 + 8 ], %g1
20047c0: 82 00 7f ff add %g1, -1, %g1
20047c4: 80 a0 60 00 cmp %g1, 0
20047c8: 12 80 00 3a bne 20048b0 <rtems_termios_close+0x120>
20047cc: c2 24 20 08 st %g1, [ %l0 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
20047d0: c4 04 20 cc ld [ %l0 + 0xcc ], %g2
20047d4: 03 00 80 5b sethi %hi(0x2016c00), %g1
20047d8: 85 28 a0 05 sll %g2, 5, %g2
20047dc: 82 10 63 b4 or %g1, 0x3b4, %g1
20047e0: 82 00 40 02 add %g1, %g2, %g1
20047e4: c2 00 60 04 ld [ %g1 + 4 ], %g1
20047e8: 80 a0 60 00 cmp %g1, 0
20047ec: 02 80 00 46 be 2004904 <rtems_termios_close+0x174> <== ALWAYS TAKEN
20047f0: 01 00 00 00 nop
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
20047f4: 9f c0 40 00 call %g1 <== NOT EXECUTED
20047f8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
* default: just flush output buffer
*/
drainOutput (tty);
}
if (tty->device.outputUsesInterrupts
20047fc: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED
2004800: 80 a0 60 02 cmp %g1, 2
2004804: 22 80 00 33 be,a 20048d0 <rtems_termios_close+0x140> <== NEVER TAKEN
2004808: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
200480c: c2 04 20 9c ld [ %l0 + 0x9c ], %g1
2004810: 80 a0 60 00 cmp %g1, 0
2004814: 22 80 00 07 be,a 2004830 <rtems_termios_close+0xa0> <== ALWAYS TAKEN
2004818: c4 04 00 00 ld [ %l0 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
200481c: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED
2004820: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED
2004824: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004828: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
200482c: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED
2004830: 80 a0 a0 00 cmp %g2, 0
2004834: 22 80 00 38 be,a 2004914 <rtems_termios_close+0x184> <== ALWAYS TAKEN
2004838: c4 04 20 04 ld [ %l0 + 4 ], %g2
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
}
else {
tty->forw->back = tty->back;
200483c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
2004840: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
}
if (tty->back == NULL) {
2004844: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED
2004848: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200484c: 22 80 00 39 be,a 2004930 <rtems_termios_close+0x1a0> <== NOT EXECUTED
2004850: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
}
else {
tty->back->forw = tty->forw;
2004854: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
2004858: 40 00 03 d5 call 20057ac <rtems_semaphore_delete>
200485c: d0 04 20 14 ld [ %l0 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
2004860: 40 00 03 d3 call 20057ac <rtems_semaphore_delete>
2004864: d0 04 20 18 ld [ %l0 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
2004868: 40 00 03 d1 call 20057ac <rtems_semaphore_delete>
200486c: d0 04 20 8c ld [ %l0 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
2004870: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1
2004874: 80 a0 60 00 cmp %g1, 0
2004878: 02 80 00 13 be 20048c4 <rtems_termios_close+0x134> <== NEVER TAKEN
200487c: 01 00 00 00 nop
2004880: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
2004884: 80 a0 60 02 cmp %g1, 2
2004888: 02 80 00 0f be 20048c4 <rtems_termios_close+0x134> <== NEVER TAKEN
200488c: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
2004890: 40 00 18 18 call 200a8f0 <free>
2004894: d0 04 20 58 ld [ %l0 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
2004898: 40 00 18 16 call 200a8f0 <free>
200489c: d0 04 20 7c ld [ %l0 + 0x7c ], %o0
free (tty->cbuf);
20048a0: 40 00 18 14 call 200a8f0 <free>
20048a4: d0 04 20 1c ld [ %l0 + 0x1c ], %o0
free (tty);
20048a8: 40 00 18 12 call 200a8f0 <free>
20048ac: 90 10 00 10 mov %l0, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
20048b0: d0 04 62 a0 ld [ %l1 + 0x2a0 ], %o0
20048b4: 40 00 04 33 call 2005980 <rtems_semaphore_release>
20048b8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
20048bc: 81 c7 e0 08 ret
20048c0: 81 e8 00 00 restore
rtems_semaphore_delete (tty->isem);
rtems_semaphore_delete (tty->osem);
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
20048c4: 40 00 03 ba call 20057ac <rtems_semaphore_delete> <== NOT EXECUTED
20048c8: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
20048cc: 30 bf ff f1 b,a 2004890 <rtems_termios_close+0x100> <== NOT EXECUTED
if (tty->device.outputUsesInterrupts
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
20048d0: 40 00 02 90 call 2005310 <rtems_event_send> <== NOT EXECUTED
20048d4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
20048d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20048dc: 12 80 00 08 bne 20048fc <rtems_termios_close+0x16c> <== NOT EXECUTED
20048e0: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send(
20048e4: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED
20048e8: 40 00 02 8a call 2005310 <rtems_event_send> <== NOT EXECUTED
20048ec: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
20048f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20048f4: 22 bf ff c7 be,a 2004810 <rtems_termios_close+0x80> <== NOT EXECUTED
20048f8: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
20048fc: 40 00 05 9a call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004900: 01 00 00 00 nop <== NOT EXECUTED
}
else {
/*
* default: just flush output buffer
*/
drainOutput (tty);
2004904: 7f ff fd 6e call 2003ebc <drainOutput>
2004908: 90 10 00 10 mov %l0, %o0
}
if (tty->device.outputUsesInterrupts
200490c: 10 bf ff bd b 2004800 <rtems_termios_close+0x70>
2004910: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
2004914: 03 00 80 5c sethi %hi(0x2017000), %g1
if ( rtems_termios_ttyTail != NULL ) {
2004918: 80 a0 a0 00 cmp %g2, 0
200491c: 02 80 00 0a be 2004944 <rtems_termios_close+0x1b4> <== ALWAYS TAKEN
2004920: c4 20 62 a4 st %g2, [ %g1 + 0x2a4 ]
rtems_termios_ttyTail->forw = NULL;
2004924: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED
2004928: 10 bf ff c7 b 2004844 <rtems_termios_close+0xb4> <== NOT EXECUTED
200492c: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
2004930: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2004934: 02 bf ff c9 be 2004858 <rtems_termios_close+0xc8> <== NOT EXECUTED
2004938: c4 20 62 a8 st %g2, [ %g1 + 0x2a8 ] <== NOT EXECUTED
rtems_termios_ttyHead->back = NULL;
200493c: 10 bf ff c7 b 2004858 <rtems_termios_close+0xc8> <== NOT EXECUTED
2004940: c0 20 a0 04 clr [ %g2 + 4 ] <== NOT EXECUTED
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
2004944: 03 00 80 5c sethi %hi(0x2017000), %g1
2004948: 10 bf ff c4 b 2004858 <rtems_termios_close+0xc8>
200494c: c0 20 62 a8 clr [ %g1 + 0x2a8 ] ! 20172a8 <rtems_termios_ttyHead>
02003288 <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)
{
2003288: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
200328c: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2003290: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2003294: 82 00 40 19 add %g1, %i1, %g1 <== NOT EXECUTED
2003298: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
200329c: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED
20032a0: 02 80 00 10 be 20032e0 <rtems_termios_dequeue_characters+0x58><== NOT EXECUTED
20032a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
20032a8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
20032ac: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED
20032b0: 12 80 00 0a bne 20032d8 <rtems_termios_dequeue_characters+0x50><== NOT EXECUTED
20032b4: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
20032b8: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 2017068 <rtems_termios_linesw+0xb4><== NOT EXECUTED
20032bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20032c0: 02 80 00 04 be 20032d0 <rtems_termios_dequeue_characters+0x48><== NOT EXECUTED
20032c4: 01 00 00 00 nop <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
20032c8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20032cc: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
}
}
20032d0: 81 c7 e0 08 ret <== NOT EXECUTED
20032d4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
20032d8: 7f ff ff 6d call 200308c <rtems_termios_refill_transmitter><== NOT EXECUTED
20032dc: 81 e8 00 00 restore <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
20032e0: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED
20032e4: 40 00 08 0b call 2005310 <rtems_event_send> <== NOT EXECUTED
20032e8: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
20032ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20032f0: 02 bf ff f8 be 20032d0 <rtems_termios_dequeue_characters+0x48><== NOT EXECUTED
20032f4: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
20032f8: 40 00 0b 1b call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
02003304 <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)
{
2003304: 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) {
2003308: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
200330c: 05 00 80 5b sethi %hi(0x2016c00), %g2 <== NOT EXECUTED
2003310: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2003314: a2 10 a3 b4 or %g2, 0x3b4, %l1 <== NOT EXECUTED
2003318: 82 00 60 10 add %g1, 0x10, %g1 <== NOT EXECUTED
200331c: c2 04 40 01 ld [ %l1 + %g1 ], %g1 <== NOT EXECUTED
2003320: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2003324: 02 80 00 22 be 20033ac <rtems_termios_enqueue_raw_characters+0xa8><== NOT EXECUTED
2003328: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
while (len--) {
200332c: 22 80 00 0f be,a 2003368 <rtems_termios_enqueue_raw_characters+0x64><== NOT EXECUTED
2003330: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED
2003334: 10 80 00 05 b 2003348 <rtems_termios_enqueue_raw_characters+0x44><== NOT EXECUTED
2003338: a0 10 20 00 clr %l0 <== NOT EXECUTED
200333c: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2003340: 82 00 60 10 add %g1, 0x10, %g1 <== NOT EXECUTED
2003344: c2 04 40 01 ld [ %l1 + %g1 ], %g1 <== NOT EXECUTED
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
2003348: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
200334c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2003350: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2003354: a0 04 20 01 inc %l0 <== 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--) {
2003358: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
200335c: 32 bf ff f8 bne,a 200333c <rtems_termios_enqueue_raw_characters+0x38><== NOT EXECUTED
2003360: 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 )) {
2003364: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED
2003368: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200336c: 12 80 00 0e bne 20033a4 <rtems_termios_enqueue_raw_characters+0xa0><== NOT EXECUTED
2003370: a6 10 20 00 clr %l3 <== NOT EXECUTED
2003374: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED
2003378: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200337c: 02 80 00 0a be 20033a4 <rtems_termios_enqueue_raw_characters+0xa0><== NOT EXECUTED
2003380: 01 00 00 00 nop <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2003384: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED
2003388: 9f c0 40 00 call %g1 <== NOT EXECUTED
200338c: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2003390: a6 10 20 00 clr %l3 <== NOT EXECUTED
2003394: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2003398: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED
}
}
tty->rawInBufDropped += dropped;
rtems_semaphore_release (tty->rawInBuf.Semaphore);
return dropped;
}
200339c: 81 c7 e0 08 ret <== NOT EXECUTED
20033a0: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED
20033a4: 81 c7 e0 08 ret <== NOT EXECUTED
20033a8: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
20033ac: b4 06 bf ff add %i2, -1, %i2 <== 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,
20033b0: 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);
20033b4: aa 06 20 30 add %i0, 0x30, %l5 <== NOT EXECUTED
20033b8: a6 10 20 00 clr %l3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
20033bc: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
20033c0: 02 80 00 1c be 2003430 <rtems_termios_enqueue_raw_characters+0x12c><== NOT EXECUTED
20033c4: a2 10 20 00 clr %l1 <== NOT EXECUTED
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
20033c8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20033cc: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
20033d0: 02 80 00 0b be 20033fc <rtems_termios_enqueue_raw_characters+0xf8><== NOT EXECUTED
20033d4: e4 0e 40 00 ldub [ %i1 ], %l2 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
20033d8: c4 0e 20 4a ldub [ %i0 + 0x4a ], %g2 <== NOT EXECUTED
20033dc: 83 2c a0 18 sll %l2, 0x18, %g1 <== NOT EXECUTED
20033e0: 87 38 60 18 sra %g1, 0x18, %g3 <== NOT EXECUTED
20033e4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
20033e8: 02 80 00 64 be 2003578 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
20033ec: c2 0e 20 49 ldub [ %i0 + 0x49 ], %g1 <== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
20033f0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
20033f4: 02 80 00 68 be 2003594 <rtems_termios_enqueue_raw_characters+0x290><== NOT EXECUTED
20033f8: 01 00 00 00 nop <== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
20033fc: 80 8c 60 ff btst 0xff, %l1 <== NOT EXECUTED
2003400: 02 80 00 24 be 2003490 <rtems_termios_enqueue_raw_characters+0x18c><== NOT EXECUTED
2003404: 01 00 00 00 nop <== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
2003408: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
200340c: 82 08 60 30 and %g1, 0x30, %g1 <== NOT EXECUTED
2003410: 80 a0 60 20 cmp %g1, 0x20 <== NOT EXECUTED
2003414: 02 80 00 0f be 2003450 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
2003418: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
200341c: b2 06 60 01 inc %i1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2003420: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
2003424: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
2003428: 12 bf ff e8 bne 20033c8 <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
200342c: 01 00 00 00 nop <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
2003430: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2003434: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
}
}
}
tty->rawInBufDropped += dropped;
2003438: 82 00 40 13 add %g1, %l3, %g1 <== NOT EXECUTED
200343c: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2003440: 40 00 09 50 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003444: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED
return dropped;
}
2003448: 81 c7 e0 08 ret <== NOT EXECUTED
200344c: 81 e8 00 00 restore <== 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);
2003450: 7f ff fa 65 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
2003454: 01 00 00 00 nop <== NOT EXECUTED
2003458: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
200345c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2003460: 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;
2003464: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2003468: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
200346c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2003470: 12 80 00 53 bne 20035bc <rtems_termios_enqueue_raw_characters+0x2b8><== NOT EXECUTED
2003474: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2003478: a2 10 20 01 mov 1, %l1 ! 1 <PROM_START+0x1> <== NOT EXECUTED
200347c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2003480: 7f ff fa 5d call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2003484: b2 06 60 01 inc %i1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2003488: 10 bf ff e7 b 2003424 <rtems_termios_enqueue_raw_characters+0x120><== NOT EXECUTED
200348c: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
2003490: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED
2003494: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED
2003498: 40 00 41 e2 call 2013c20 <.urem> <== NOT EXECUTED
200349c: 90 02 20 01 inc %o0 <== NOT EXECUTED
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
20034a0: 7f ff fa 51 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20034a4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
20034a8: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
20034ac: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
20034b0: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED
20034b4: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED
20034b8: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
20034bc: 40 00 41 d9 call 2013c20 <.urem> <== NOT EXECUTED
20034c0: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED
20034c4: c2 06 20 c0 ld [ %i0 + 0xc0 ], %g1 <== NOT EXECUTED
20034c8: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
20034cc: 08 80 00 13 bleu 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
20034d0: 01 00 00 00 nop <== NOT EXECUTED
20034d4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20034d8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
20034dc: 12 80 00 0f bne 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
20034e0: 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;
20034e4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20034e8: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
20034ec: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
20034f0: c4 06 20 b8 ld [ %i0 + 0xb8 ], %g2 <== NOT EXECUTED
20034f4: 84 08 a4 02 and %g2, 0x402, %g2 <== NOT EXECUTED
20034f8: 80 a0 a4 00 cmp %g2, 0x400 <== NOT EXECUTED
20034fc: 02 80 00 38 be 20035dc <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
2003500: 01 00 00 00 nop <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]),
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
2003504: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2003508: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
200350c: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2003510: 02 80 00 44 be 2003620 <rtems_termios_enqueue_raw_characters+0x31c><== NOT EXECUTED
2003514: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2003518: 7f ff fa 37 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200351c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
2003520: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
2003524: 80 a0 40 10 cmp %g1, %l0 <== NOT EXECUTED
2003528: 22 80 00 1f be,a 20035a4 <rtems_termios_enqueue_raw_characters+0x2a0><== NOT EXECUTED
200352c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
2003530: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED
2003534: e4 28 40 10 stb %l2, [ %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 )) {
2003538: c4 06 20 e4 ld [ %i0 + 0xe4 ], %g2 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
200353c: 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 )) {
2003540: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2003544: 32 bf ff b7 bne,a 2003420 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
2003548: b2 06 60 01 inc %i1 <== NOT EXECUTED
200354c: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED
2003550: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2003554: 22 bf ff b3 be,a 2003420 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
2003558: b2 06 60 01 inc %i1 <== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
200355c: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED
2003560: 9f c0 40 00 call %g1 <== NOT EXECUTED
2003564: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2003568: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
200356c: b2 06 60 01 inc %i1 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
tty->tty_rcvwakeup = 1;
2003570: 10 bf ff ac b 2003420 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
2003574: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
2003578: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
200357c: 02 80 00 0c be 20035ac <rtems_termios_enqueue_raw_characters+0x2a8><== NOT EXECUTED
2003580: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
2003584: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2003588: 82 10 60 10 or %g1, 0x10, %g1 <== NOT EXECUTED
200358c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
2003590: 30 bf ff 9e b,a 2003408 <rtems_termios_enqueue_raw_characters+0x104><== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2003594: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2003598: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
200359c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
20035a0: 30 bf ff 9a b,a 2003408 <rtems_termios_enqueue_raw_characters+0x104><== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
20035a4: 10 bf ff 9f b 2003420 <rtems_termios_enqueue_raw_characters+0x11c><== NOT EXECUTED
20035a8: b2 06 60 01 inc %i1 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
20035ac: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20035b0: 82 18 60 10 xor %g1, 0x10, %g1 <== NOT EXECUTED
20035b4: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
20035b8: 30 bf ff 94 b,a 2003408 <rtems_termios_enqueue_raw_characters+0x104><== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
20035bc: d2 06 20 84 ld [ %i0 + 0x84 ], %o1 <== NOT EXECUTED
20035c0: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
20035c4: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED
20035c8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
20035cc: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
20035d0: 9f c0 80 00 call %g2 <== NOT EXECUTED
20035d4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20035d8: 30 bf ff a8 b,a 2003478 <rtems_termios_enqueue_raw_characters+0x174><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
20035dc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20035e0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
20035e4: 12 80 00 06 bne 20035fc <rtems_termios_enqueue_raw_characters+0x2f8><== NOT EXECUTED
20035e8: 01 00 00 00 nop <== NOT EXECUTED
20035ec: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
20035f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20035f4: 12 bf ff c9 bne 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
20035f8: 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;
20035fc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2003600: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED
2003604: 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;
2003608: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
200360c: 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;
2003610: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2003614: 9f c0 80 00 call %g2 <== NOT EXECUTED
2003618: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
200361c: 30 bf ff bf b,a 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
2003620: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2003624: 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;
2003628: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
200362c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2003630: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2003634: 02 bf ff b9 be 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
2003638: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
200363c: 9f c0 80 00 call %g2 <== NOT EXECUTED
2003640: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2003644: 30 bf ff b5 b,a 2003518 <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
02003004 <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
2003004: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
2003008: 03 00 80 5c sethi %hi(0x2017000), %g1
200300c: c4 00 62 a0 ld [ %g1 + 0x2a0 ], %g2 ! 20172a0 <rtems_termios_ttyMutex>
2003010: 80 a0 a0 00 cmp %g2, 0
2003014: 02 80 00 04 be 2003024 <rtems_termios_initialize+0x20> <== ALWAYS TAKEN
2003018: 98 10 62 a0 or %g1, 0x2a0, %o4
200301c: 81 c7 e0 08 ret
2003020: 81 e8 00 00 restore
sc = rtems_semaphore_create (
2003024: 11 15 14 9b sethi %hi(0x54526c00), %o0
2003028: 92 10 20 01 mov 1, %o1
200302c: 90 12 21 69 or %o0, 0x169, %o0
2003030: 94 10 20 54 mov 0x54, %o2
2003034: 40 00 09 64 call 20055c4 <rtems_semaphore_create>
2003038: 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)
200303c: 80 a2 20 00 cmp %o0, 0
2003040: 02 bf ff f7 be 200301c <rtems_termios_initialize+0x18> <== ALWAYS TAKEN
2003044: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
2003048: 40 00 0b c7 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
0200437c <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
200437c: 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;
2004380: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
2004384: 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;
2004388: e2 00 60 28 ld [ %g1 + 0x28 ], %l1 <== NOT EXECUTED
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
200438c: 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);
2004390: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
2004394: 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);
2004398: 92 10 20 00 clr %o1 <== NOT EXECUTED
200439c: 40 00 05 31 call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
20043a0: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
20043a4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20043a8: 32 80 00 12 bne,a 20043f0 <rtems_termios_ioctl+0x74> <== NOT EXECUTED
20043ac: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
20043b0: c4 04 a0 04 ld [ %l2 + 4 ], %g2 <== NOT EXECUTED
20043b4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED
20043b8: 22 80 00 27 be,a 2004454 <rtems_termios_ioctl+0xd8> <== NOT EXECUTED
20043bc: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
20043c0: 18 80 00 0e bgu 20043f8 <rtems_termios_ioctl+0x7c> <== NOT EXECUTED
20043c4: 03 10 01 19 sethi %hi(0x40046400), %g1 <== NOT EXECUTED
20043c8: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED
20043cc: 22 80 00 61 be,a 2004550 <rtems_termios_ioctl+0x1d4> <== NOT EXECUTED
20043d0: d2 04 a0 08 ld [ %l2 + 8 ], %o1 <== NOT EXECUTED
20043d4: 08 80 00 4c bleu 2004504 <rtems_termios_ioctl+0x188> <== NOT EXECUTED
20043d8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
20043dc: 7f ff fe b8 call 2003ebc <drainOutput> <== NOT EXECUTED
20043e0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
}
break;
}
rtems_semaphore_release (tty->osem);
20043e4: 40 00 05 67 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
20043e8: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED
args->ioctl_return = sc;
20043ec: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED
return sc;
}
20043f0: 81 c7 e0 08 ret <== NOT EXECUTED
20043f4: 81 e8 00 00 restore <== 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) {
20043f8: 82 10 62 7f or %g1, 0x27f, %g1 <== NOT EXECUTED
20043fc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2004400: 02 80 00 48 be 2004520 <rtems_termios_ioctl+0x1a4> <== NOT EXECUTED
2004404: 01 00 00 00 nop <== NOT EXECUTED
2004408: 18 80 00 1b bgu 2004474 <rtems_termios_ioctl+0xf8> <== NOT EXECUTED
200440c: 03 10 01 1d sethi %hi(0x40047400), %g1 <== NOT EXECUTED
2004410: 80 a0 a0 05 cmp %g2, 5 <== NOT EXECUTED
2004414: 22 80 00 14 be,a 2004464 <rtems_termios_ioctl+0xe8> <== NOT EXECUTED
2004418: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
200441c: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED
2004420: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED
2004424: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED
2004428: 82 10 63 b4 or %g1, 0x3b4, %g1 <== NOT EXECUTED
200442c: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
2004430: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
2004434: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004438: 02 bf ff eb be 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
200443c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
2004440: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2004444: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004448: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
200444c: 10 bf ff e6 b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
2004450: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
2004454: c2 24 60 dc st %g1, [ %l1 + 0xdc ] <== NOT EXECUTED
2004458: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED
200445c: 10 bf ff e2 b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
2004460: c4 24 60 e0 st %g2, [ %l1 + 0xe0 ] <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2004464: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] <== NOT EXECUTED
2004468: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED
200446c: 10 bf ff de b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
2004470: c4 24 60 d8 st %g2, [ %l1 + 0xd8 ] <== 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) {
2004474: 82 10 60 1a or %g1, 0x1a, %g1 <== NOT EXECUTED
2004478: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200447c: 02 80 00 1e be 20044f4 <rtems_termios_ioctl+0x178> <== NOT EXECUTED
2004480: 03 20 01 1d sethi %hi(0x80047400), %g1 <== NOT EXECUTED
2004484: 82 10 60 1b or %g1, 0x1b, %g1 ! 8004741b <RAM_END+0x7dc4741b><== NOT EXECUTED
2004488: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200448c: 32 bf ff e5 bne,a 2004420 <rtems_termios_ioctl+0xa4> <== NOT EXECUTED
2004490: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2004494: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED
2004498: 05 00 80 5b sethi %hi(0x2016c00), %g2 <== NOT EXECUTED
200449c: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
20044a0: a0 10 a3 b4 or %g2, 0x3b4, %l0 <== NOT EXECUTED
20044a4: 82 04 00 01 add %l0, %g1, %g1 <== NOT EXECUTED
20044a8: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
20044ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20044b0: 22 80 00 06 be,a 20044c8 <rtems_termios_ioctl+0x14c> <== NOT EXECUTED
20044b4: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
20044b8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20044bc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20044c0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
tty->t_line=*(int*)(args->buffer);
20044c4: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
20044c8: 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);
20044cc: 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) {
20044d0: 85 28 e0 05 sll %g3, 5, %g2 <== NOT EXECUTED
20044d4: c2 04 00 02 ld [ %l0 + %g2 ], %g1 <== NOT EXECUTED
20044d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20044dc: 02 bf ff c2 be 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
20044e0: c6 24 60 cc st %g3, [ %l1 + 0xcc ] <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
20044e4: 9f c0 40 00 call %g1 <== NOT EXECUTED
20044e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
20044ec: 10 bf ff be b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
20044f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
20044f4: c4 04 a0 08 ld [ %l2 + 8 ], %g2 <== NOT EXECUTED
20044f8: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED
20044fc: 10 bf ff ba b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
2004500: c2 20 80 00 st %g1, [ %g2 ] <== 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) {
2004504: 32 bf ff c7 bne,a 2004420 <rtems_termios_ioctl+0xa4> <== NOT EXECUTED
2004508: 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;
200450c: d0 04 a0 08 ld [ %l2 + 8 ], %o0 <== NOT EXECUTED
2004510: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED
2004514: 40 00 24 3e call 200d60c <memcpy> <== NOT EXECUTED
2004518: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED
200451c: 30 bf ff b2 b,a 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
2004520: c4 04 60 60 ld [ %l1 + 0x60 ], %g2 <== NOT EXECUTED
2004524: c2 04 60 5c ld [ %l1 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
2004528: 88 a0 80 01 subcc %g2, %g1, %g4 <== NOT EXECUTED
200452c: 0c 80 00 82 bneg 2004734 <rtems_termios_ioctl+0x3b8> <== NOT EXECUTED
2004530: 01 00 00 00 nop <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
2004534: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED
2004538: c4 04 60 24 ld [ %l1 + 0x24 ], %g2 <== NOT EXECUTED
200453c: c6 04 a0 08 ld [ %l2 + 8 ], %g3 <== NOT EXECUTED
2004540: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
2004544: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED
2004548: 10 bf ff a7 b 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
200454c: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
2004550: a6 04 60 30 add %l1, 0x30, %l3 <== NOT EXECUTED
2004554: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED
2004558: 40 00 24 2d call 200d60c <memcpy> <== NOT EXECUTED
200455c: 90 10 00 13 mov %l3, %o0 <== 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) &&
2004560: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004564: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
2004568: 02 80 00 19 be 20045cc <rtems_termios_ioctl+0x250> <== NOT EXECUTED
200456c: 01 00 00 00 nop <== NOT EXECUTED
2004570: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED
2004574: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED
2004578: 12 80 00 15 bne 20045cc <rtems_termios_ioctl+0x250> <== NOT EXECUTED
200457c: 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);
2004580: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004584: 82 08 7d ef and %g1, -529, %g1 <== NOT EXECUTED
2004588: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
200458c: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED
2004590: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED
2004594: 02 80 00 0e be 20045cc <rtems_termios_ioctl+0x250> <== NOT EXECUTED
2004598: 01 00 00 00 nop <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
200459c: 7f ff f6 12 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20045a0: 01 00 00 00 nop <== NOT EXECUTED
20045a4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
20045a8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
20045ac: 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;
20045b0: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
20045b4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
20045b8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20045bc: 12 80 00 6d bne 2004770 <rtems_termios_ioctl+0x3f4> <== NOT EXECUTED
20045c0: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
20045c4: 7f ff f6 0c call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20045c8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
20045cc: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
20045d0: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED
20045d4: 02 80 00 0c be 2004604 <rtems_termios_ioctl+0x288> <== NOT EXECUTED
20045d8: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
20045dc: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
20045e0: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
20045e4: 12 80 00 08 bne 2004604 <rtems_termios_ioctl+0x288> <== NOT EXECUTED
20045e8: 01 00 00 00 nop <== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
20045ec: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
20045f0: 82 08 7b ff and %g1, -1025, %g1 <== NOT EXECUTED
20045f4: 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);
20045f8: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED
20045fc: 84 08 bf fd and %g2, -3, %g2 <== NOT EXECUTED
2004600: c4 24 60 b8 st %g2, [ %l1 + 0xb8 ] <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
2004604: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004608: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
200460c: 12 80 00 22 bne 2004694 <rtems_termios_ioctl+0x318> <== NOT EXECUTED
2004610: c6 04 60 38 ld [ %l1 + 0x38 ], %g3 <== 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) {
2004614: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2004618: 06 80 00 4a bl 2004740 <rtems_termios_ioctl+0x3c4> <== NOT EXECUTED
200461c: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
2004620: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
2004624: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
2004628: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED
200462c: 02 80 00 06 be 2004644 <rtems_termios_ioctl+0x2c8> <== NOT EXECUTED
2004630: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXOF;
2004634: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004638: 82 10 64 00 or %g1, 0x400, %g1 <== NOT EXECUTED
200463c: 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) {
2004640: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED
2004644: 22 80 00 06 be,a 200465c <rtems_termios_ioctl+0x2e0> <== NOT EXECUTED
2004648: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_MDXON;
200464c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004650: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED
2004654: 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) {
2004658: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED
200465c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2004660: 02 80 00 23 be 20046ec <rtems_termios_ioctl+0x370> <== NOT EXECUTED
2004664: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2004668: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
200466c: c0 24 60 70 clr [ %l1 + 0x70 ] <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2004670: c0 24 60 74 clr [ %l1 + 0x74 ] <== NOT EXECUTED
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
2004674: c2 04 60 a8 ld [ %l1 + 0xa8 ], %g1 <== NOT EXECUTED
2004678: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200467c: 02 bf ff 5a be 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
2004680: 01 00 00 00 nop <== NOT EXECUTED
(*tty->device.setAttributes)(tty->minor, &tty->termios);
2004684: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
2004688: 9f c0 40 00 call %g1 <== NOT EXECUTED
200468c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2004690: 30 bf ff 55 b,a 20043e4 <rtems_termios_ioctl+0x68> <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
2004694: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2004698: 06 80 00 2a bl 2004740 <rtems_termios_ioctl+0x3c4> <== NOT EXECUTED
200469c: 01 00 00 00 nop <== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
20046a0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
20046a4: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
20046a8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
20046ac: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED
20046b0: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED
20046b4: 02 80 00 09 be 20046d8 <rtems_termios_ioctl+0x35c> <== NOT EXECUTED
20046b8: 01 00 00 00 nop <== NOT EXECUTED
20046bc: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED
20046c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20046c4: 02 80 00 05 be 20046d8 <rtems_termios_ioctl+0x35c> <== NOT EXECUTED
20046c8: 01 00 00 00 nop <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
20046cc: 9f c0 40 00 call %g1 <== NOT EXECUTED
20046d0: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
20046d4: c6 04 60 38 ld [ %l1 + 0x38 ], %g3 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
20046d8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
20046dc: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
20046e0: 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) {
20046e4: 10 bf ff cd b 2004618 <rtems_termios_ioctl+0x29c> <== NOT EXECUTED
20046e8: 80 a0 e0 00 cmp %g3, 0 <== 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);
20046ec: 40 00 01 ff call 2004ee8 <rtems_clock_get> <== NOT EXECUTED
20046f0: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
20046f4: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
20046f8: e0 0c 60 46 ldub [ %l1 + 0x46 ], %l0 <== NOT EXECUTED
20046fc: 40 00 3c 63 call 2013888 <.umul> <== NOT EXECUTED
2004700: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2004704: 40 00 3c 9b call 2013970 <.udiv> <== NOT EXECUTED
2004708: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
if (tty->termios.c_cc[VTIME]) {
200470c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2004710: 02 80 00 11 be 2004754 <rtems_termios_ioctl+0x3d8> <== NOT EXECUTED
2004714: d0 24 60 54 st %o0, [ %l1 + 0x54 ] <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2004718: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED
else {
rtems_interval ticksPerSecond;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond);
tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
200471c: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2004720: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004724: 12 bf ff d3 bne 2004670 <rtems_termios_ioctl+0x2f4> <== NOT EXECUTED
2004728: d0 24 60 70 st %o0, [ %l1 + 0x70 ] <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
200472c: 10 bf ff d2 b 2004674 <rtems_termios_ioctl+0x2f8> <== NOT EXECUTED
2004730: d0 24 60 74 st %o0, [ %l1 + 0x74 ] <== NOT EXECUTED
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
if ( rawnc < 0 )
rawnc += tty->rawInBuf.Size;
2004734: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 <== NOT EXECUTED
2004738: 10 bf ff 7f b 2004534 <rtems_termios_ioctl+0x1b8> <== NOT EXECUTED
200473c: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
2004740: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED
2004744: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
2004748: 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) {
200474c: 10 bf ff b6 b 2004624 <rtems_termios_ioctl+0x2a8> <== NOT EXECUTED
2004750: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
2004754: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED
2004758: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200475c: 32 bf ff c4 bne,a 200466c <rtems_termios_ioctl+0x2f0> <== NOT EXECUTED
2004760: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
2004764: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2004768: 10 bf ff c3 b 2004674 <rtems_termios_ioctl+0x2f8> <== NOT EXECUTED
200476c: c2 24 60 6c st %g1, [ %l1 + 0x6c ] <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
2004770: d2 04 60 84 ld [ %l1 + 0x84 ], %o1 <== NOT EXECUTED
2004774: c2 04 60 7c ld [ %l1 + 0x7c ], %g1 <== NOT EXECUTED
2004778: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 <== NOT EXECUTED
200477c: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED
2004780: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
2004784: 9f c0 80 00 call %g2 <== NOT EXECUTED
2004788: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
200478c: 30 bf ff 8e b,a 20045c4 <rtems_termios_ioctl+0x248> <== NOT EXECUTED
02004950 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
2004950: 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,
2004954: 29 00 80 5c sethi %hi(0x2017000), %l4
2004958: d0 05 22 a0 ld [ %l4 + 0x2a0 ], %o0 ! 20172a0 <rtems_termios_ttyMutex>
200495c: 92 10 20 00 clr %o1
2004960: 40 00 03 c0 call 2005860 <rtems_semaphore_obtain>
2004964: 94 10 20 00 clr %o2
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2004968: a4 92 20 00 orcc %o0, 0, %l2
200496c: 32 80 00 29 bne,a 2004a10 <rtems_termios_open+0xc0> <== NEVER TAKEN
2004970: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
2004974: 27 00 80 5c sethi %hi(0x2017000), %l3
2004978: e0 04 e2 a8 ld [ %l3 + 0x2a8 ], %l0 ! 20172a8 <rtems_termios_ttyHead>
200497c: 80 a4 20 00 cmp %l0, 0
2004980: 32 80 00 08 bne,a 20049a0 <rtems_termios_open+0x50>
2004984: c2 04 20 0c ld [ %l0 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
2004988: 10 80 00 24 b 2004a18 <rtems_termios_open+0xc8>
200498c: 90 10 20 01 mov 1, %o0
*/
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) {
2004990: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2004994: 02 80 00 21 be 2004a18 <rtems_termios_open+0xc8> <== NOT EXECUTED
2004998: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
if ((tty->major == major) && (tty->minor == minor))
200499c: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED
20049a0: 80 a0 40 18 cmp %g1, %i0
20049a4: 32 bf ff fb bne,a 2004990 <rtems_termios_open+0x40> <== NEVER TAKEN
20049a8: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
20049ac: c2 04 20 10 ld [ %l0 + 0x10 ], %g1
20049b0: 80 a0 40 19 cmp %g1, %i1
20049b4: 32 bf ff f7 bne,a 2004990 <rtems_termios_open+0x40> <== NEVER TAKEN
20049b8: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
20049bc: c2 04 20 08 ld [ %l0 + 8 ], %g1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
20049c0: c4 06 80 00 ld [ %i2 ], %g2
if (!tty->refcount++) {
20049c4: 86 00 60 01 add %g1, 1, %g3
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
20049c8: e0 20 a0 28 st %l0, [ %g2 + 0x28 ]
if (!tty->refcount++) {
20049cc: 80 a0 60 00 cmp %g1, 0
20049d0: 12 80 00 0d bne 2004a04 <rtems_termios_open+0xb4>
20049d4: c6 24 20 08 st %g3, [ %l0 + 8 ]
if (tty->device.firstOpen)
20049d8: c2 04 20 98 ld [ %l0 + 0x98 ], %g1
20049dc: 80 a0 60 00 cmp %g1, 0
20049e0: 02 80 00 05 be 20049f4 <rtems_termios_open+0xa4> <== ALWAYS TAKEN
20049e4: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
20049e8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20049ec: 9f c0 40 00 call %g1 <== NOT EXECUTED
20049f0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20049f4: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1
20049f8: 80 a0 60 02 cmp %g1, 2
20049fc: 22 80 00 a0 be,a 2004c7c <rtems_termios_open+0x32c> <== NEVER TAKEN
2004a00: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2004a04: 40 00 03 df call 2005980 <rtems_semaphore_release>
2004a08: d0 05 22 a0 ld [ %l4 + 0x2a0 ], %o0
return RTEMS_SUCCESSFUL;
}
2004a0c: b0 10 00 12 mov %l2, %i0
2004a10: 81 c7 e0 08 ret
2004a14: 81 e8 00 00 restore
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
2004a18: 40 00 17 70 call 200a7d8 <calloc>
2004a1c: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
2004a20: a2 92 20 00 orcc %o0, 0, %l1
2004a24: 02 80 00 a8 be 2004cc4 <rtems_termios_open+0x374> <== NEVER TAKEN
2004a28: a0 10 00 11 mov %l1, %l0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
2004a2c: 03 00 80 5a sethi %hi(0x2016800), %g1
2004a30: c4 00 62 98 ld [ %g1 + 0x298 ], %g2 ! 2016a98 <rtems_termios_raw_input_size>
2004a34: c4 24 60 64 st %g2, [ %l1 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
2004a38: d0 04 60 64 ld [ %l1 + 0x64 ], %o0
2004a3c: 40 00 19 24 call 200aecc <malloc>
2004a40: 01 00 00 00 nop
if (tty->rawInBuf.theBuf == NULL) {
2004a44: 80 a2 20 00 cmp %o0, 0
2004a48: 02 80 00 9d be 2004cbc <rtems_termios_open+0x36c> <== NEVER TAKEN
2004a4c: d0 24 60 58 st %o0, [ %l1 + 0x58 ]
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
2004a50: 03 00 80 5a sethi %hi(0x2016800), %g1
2004a54: c4 00 62 9c ld [ %g1 + 0x29c ], %g2 ! 2016a9c <rtems_termios_raw_output_size>
2004a58: c4 24 60 88 st %g2, [ %l1 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
2004a5c: d0 04 60 88 ld [ %l1 + 0x88 ], %o0
2004a60: 40 00 19 1b call 200aecc <malloc>
2004a64: 01 00 00 00 nop
if (tty->rawOutBuf.theBuf == NULL) {
2004a68: 80 a2 20 00 cmp %o0, 0
2004a6c: 02 80 00 9b be 2004cd8 <rtems_termios_open+0x388> <== NEVER TAKEN
2004a70: d0 24 60 7c st %o0, [ %l1 + 0x7c ]
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
2004a74: 03 00 80 5a sethi %hi(0x2016800), %g1
2004a78: 40 00 19 15 call 200aecc <malloc>
2004a7c: d0 00 62 94 ld [ %g1 + 0x294 ], %o0 ! 2016a94 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
2004a80: 80 a2 20 00 cmp %o0, 0
2004a84: 02 80 00 ab be 2004d30 <rtems_termios_open+0x3e0> <== NEVER TAKEN
2004a88: d0 24 60 1c st %o0, [ %l1 + 0x1c ]
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2004a8c: c2 04 e2 a8 ld [ %l3 + 0x2a8 ], %g1
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
2004a90: c0 24 60 d4 clr [ %l1 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
2004a94: c0 24 60 d8 clr [ %l1 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
2004a98: c0 24 60 dc clr [ %l1 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
2004a9c: c0 24 60 e0 clr [ %l1 + 0xe0 ]
tty->tty_rcvwakeup = 0;
2004aa0: c0 24 60 e4 clr [ %l1 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2004aa4: c2 24 40 00 st %g1, [ %l1 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
2004aa8: 80 a0 60 00 cmp %g1, 0
2004aac: 02 80 00 03 be 2004ab8 <rtems_termios_open+0x168> <== ALWAYS TAKEN
2004ab0: c0 24 60 04 clr [ %l1 + 4 ]
rtems_termios_ttyHead->back = tty;
2004ab4: e2 20 60 04 st %l1, [ %g1 + 4 ] <== NOT EXECUTED
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
2004ab8: 05 00 80 5c sethi %hi(0x2017000), %g2
2004abc: c2 00 a2 a4 ld [ %g2 + 0x2a4 ], %g1 ! 20172a4 <rtems_termios_ttyTail>
2004ac0: 80 a0 60 00 cmp %g1, 0
2004ac4: 02 80 00 b8 be 2004da4 <rtems_termios_open+0x454> <== ALWAYS TAKEN
2004ac8: e2 24 e2 a8 st %l1, [ %l3 + 0x2a8 ]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
2004acc: 27 00 80 5a sethi %hi(0x2016800), %l3
2004ad0: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1 ! 2016aa0 <c.6057>
2004ad4: 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;
2004ad8: f2 24 60 10 st %i1, [ %l1 + 0x10 ]
tty->major = major;
2004adc: f0 24 60 0c st %i0, [ %l1 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
2004ae0: 90 12 21 00 or %o0, 0x100, %o0
2004ae4: 92 10 20 01 mov 1, %o1
2004ae8: 90 10 40 08 or %g1, %o0, %o0
2004aec: 94 10 20 54 mov 0x54, %o2
2004af0: 96 10 20 00 clr %o3
2004af4: 40 00 02 b4 call 20055c4 <rtems_semaphore_create>
2004af8: 98 04 60 14 add %l1, 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)
2004afc: 80 a2 20 00 cmp %o0, 0
2004b00: 12 80 00 6d bne 2004cb4 <rtems_termios_open+0x364> <== NEVER TAKEN
2004b04: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2004b08: 11 15 14 9b sethi %hi(0x54526c00), %o0
2004b0c: 92 10 20 01 mov 1, %o1
2004b10: 90 12 23 00 or %o0, 0x300, %o0
2004b14: 94 10 20 54 mov 0x54, %o2
2004b18: 90 10 40 08 or %g1, %o0, %o0
2004b1c: 96 10 20 00 clr %o3
2004b20: 40 00 02 a9 call 20055c4 <rtems_semaphore_create>
2004b24: 98 04 60 18 add %l1, 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)
2004b28: 80 a2 20 00 cmp %o0, 0
2004b2c: 12 80 00 62 bne 2004cb4 <rtems_termios_open+0x364> <== NEVER TAKEN
2004b30: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2004b34: 11 15 14 9e sethi %hi(0x54527800), %o0
2004b38: 92 10 20 00 clr %o1
2004b3c: 90 10 40 08 or %g1, %o0, %o0
2004b40: 94 10 20 20 mov 0x20, %o2
2004b44: 96 10 20 00 clr %o3
2004b48: 40 00 02 9f call 20055c4 <rtems_semaphore_create>
2004b4c: 98 04 60 8c add %l1, 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)
2004b50: 80 a2 20 00 cmp %o0, 0
2004b54: 12 80 00 58 bne 2004cb4 <rtems_termios_open+0x364> <== NEVER TAKEN
2004b58: 92 10 00 1b mov %i3, %o1
rtems_fatal_error_occurred (sc);
tty->rawOutBufState = rob_idle;
2004b5c: c0 24 60 94 clr [ %l1 + 0x94 ]
/*
* Set callbacks
*/
tty->device = *callbacks;
2004b60: 90 04 60 98 add %l1, 0x98, %o0
2004b64: 40 00 22 aa call 200d60c <memcpy>
2004b68: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2004b6c: c2 04 60 b4 ld [ %l1 + 0xb4 ], %g1
2004b70: 80 a0 60 02 cmp %g1, 2
2004b74: 02 80 00 74 be 2004d44 <rtems_termios_open+0x3f4> <== NEVER TAKEN
2004b78: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
2004b7c: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1
2004b80: 80 a0 60 00 cmp %g1, 0
2004b84: 02 80 00 5e be 2004cfc <rtems_termios_open+0x3ac> <== NEVER TAKEN
2004b88: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1
2004b8c: c2 04 60 b4 ld [ %l1 + 0xb4 ], %g1
2004b90: 80 a0 60 02 cmp %g1, 2
2004b94: 02 80 00 5a be 2004cfc <rtems_termios_open+0x3ac> <== NEVER TAKEN
2004b98: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1
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;
2004b9c: c0 24 60 b8 clr [ %l1 + 0xb8 ]
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
2004ba0: c2 04 60 64 ld [ %l1 + 0x64 ], %g1
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
2004ba4: c8 0c e2 a0 ldub [ %l3 + 0x2a0 ], %g4
/* 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;
2004ba8: 83 30 60 01 srl %g1, 1, %g1
2004bac: c2 24 60 bc st %g1, [ %l1 + 0xbc ]
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
2004bb0: 03 00 00 09 sethi %hi(0x2400), %g1
2004bb4: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
2004bb8: 05 00 00 06 sethi %hi(0x1800), %g2
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
2004bbc: c2 24 60 30 st %g1, [ %l1 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
2004bc0: 84 10 a0 05 or %g2, 5, %g2
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
2004bc4: 03 00 00 20 sethi %hi(0x8000), %g1
2004bc8: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
2004bcc: c4 24 60 34 st %g2, [ %l1 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
2004bd0: c2 24 60 3c st %g1, [ %l1 + 0x3c ]
tty->termios.c_cc[VINTR] = '\003';
2004bd4: 84 10 20 03 mov 3, %g2
tty->termios.c_cc[VQUIT] = '\034';
2004bd8: 82 10 20 1c mov 0x1c, %g1
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';
2004bdc: c4 2c 60 41 stb %g2, [ %l1 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
2004be0: c2 2c 60 42 stb %g1, [ %l1 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
2004be4: 84 10 20 7f mov 0x7f, %g2
tty->termios.c_cc[VKILL] = '\025';
2004be8: 82 10 20 15 mov 0x15, %g1
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
2004bec: c4 2c 60 43 stb %g2, [ %l1 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
2004bf0: c2 2c 60 44 stb %g1, [ %l1 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
2004bf4: 84 10 20 04 mov 4, %g2
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2004bf8: 82 10 20 11 mov 0x11, %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;
2004bfc: da 04 60 64 ld [ %l1 + 0x64 ], %o5
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';
2004c00: c4 2c 60 45 stb %g2, [ %l1 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2004c04: c2 2c 60 49 stb %g1, [ %l1 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
2004c08: 84 10 20 13 mov 0x13, %g2
tty->termios.c_cc[VSUSP] = '\032';
2004c0c: 82 10 20 1a mov 0x1a, %g1
/*
* 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;
2004c10: 86 10 28 bd mov 0x8bd, %g3
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
2004c14: c4 2c 60 4a stb %g2, [ %l1 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
2004c18: c2 2c 60 4b stb %g1, [ %l1 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
2004c1c: 84 10 20 12 mov 0x12, %g2
tty->termios.c_cc[VDISCARD] = '\017';
2004c20: 82 10 20 0f mov 0xf, %g1
/*
* 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;
2004c24: c6 24 60 38 st %g3, [ %l1 + 0x38 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
2004c28: c4 2c 60 4d stb %g2, [ %l1 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
2004c2c: c2 2c 60 4e stb %g1, [ %l1 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
2004c30: 84 10 20 17 mov 0x17, %g2
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';
2004c34: c0 2c 60 4c clrb [ %l1 + 0x4c ]
tty->termios.c_cc[VSTART] = '\021';
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
2004c38: c4 2c 60 4f stb %g2, [ %l1 + 0x4f ]
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
2004c3c: c0 2c 60 51 clrb [ %l1 + 0x51 ]
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
2004c40: 86 10 20 16 mov 0x16, %g3
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;
2004c44: 83 2b 60 01 sll %o5, 1, %g1
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
2004c48: c6 2c 60 50 stb %g3, [ %l1 + 0x50 ]
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;
2004c4c: 82 00 40 0d add %g1, %o5, %g1
2004c50: 83 30 60 02 srl %g1, 2, %g1
2004c54: c2 24 60 c0 st %g1, [ %l1 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
2004c58: 84 01 20 01 add %g4, 1, %g2
2004c5c: 89 29 20 18 sll %g4, 0x18, %g4
2004c60: 89 39 20 18 sra %g4, 0x18, %g4
2004c64: 80 a1 20 7a cmp %g4, 0x7a
2004c68: 12 bf ff 55 bne 20049bc <rtems_termios_open+0x6c> <== ALWAYS TAKEN
2004c6c: c4 2c e2 a0 stb %g2, [ %l3 + 0x2a0 ]
c = 'a';
2004c70: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED
2004c74: 10 bf ff 52 b 20049bc <rtems_termios_open+0x6c> <== NOT EXECUTED
2004c78: c2 2c e2 a0 stb %g1, [ %l3 + 0x2a0 ] <== NOT EXECUTED
(*tty->device.firstOpen)(major, minor, arg);
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(tty->rxTaskId,
2004c7c: 13 00 80 13 sethi %hi(0x2004c00), %o1 <== NOT EXECUTED
2004c80: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2004c84: 40 00 04 14 call 2005cd4 <rtems_task_start> <== NOT EXECUTED
2004c88: 92 12 62 44 or %o1, 0x244, %o1 <== NOT EXECUTED
rtems_termios_rxdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2004c8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004c90: 12 80 00 09 bne 2004cb4 <rtems_termios_open+0x364> <== NOT EXECUTED
2004c94: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
2004c98: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED
2004c9c: 13 00 80 13 sethi %hi(0x2004c00), %o1 <== NOT EXECUTED
2004ca0: 40 00 04 0d call 2005cd4 <rtems_task_start> <== NOT EXECUTED
2004ca4: 92 12 61 ac or %o1, 0x1ac, %o1 ! 2004dac <rtems_termios_txdaemon><== NOT EXECUTED
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2004ca8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004cac: 02 bf ff 56 be 2004a04 <rtems_termios_open+0xb4> <== NOT EXECUTED
2004cb0: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
2004cb4: 40 00 04 ac call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004cb8: 01 00 00 00 nop <== NOT EXECUTED
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
2004cbc: 40 00 17 0d call 200a8f0 <free> <== NOT EXECUTED
2004cc0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
2004cc4: d0 05 22 a0 ld [ %l4 + 0x2a0 ], %o0 <== NOT EXECUTED
2004cc8: 40 00 03 2e call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2004ccc: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
return RTEMS_SUCCESSFUL;
}
2004cd0: 81 c7 e0 08 ret <== NOT EXECUTED
2004cd4: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
2004cd8: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
2004cdc: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
2004ce0: 40 00 17 04 call 200a8f0 <free> <== NOT EXECUTED
2004ce4: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
free(tty);
2004ce8: 40 00 17 02 call 200a8f0 <free> <== NOT EXECUTED
2004cec: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
2004cf0: 40 00 03 24 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2004cf4: d0 05 22 a0 ld [ %l4 + 0x2a0 ], %o0 <== NOT EXECUTED
2004cf8: 30 bf ff 46 b,a 2004a10 <rtems_termios_open+0xc0> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
2004cfc: 11 15 14 9c sethi %hi(0x54527000), %o0 <== NOT EXECUTED
2004d00: 92 10 20 00 clr %o1 <== NOT EXECUTED
2004d04: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
2004d08: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED
2004d0c: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
2004d10: 96 10 20 00 clr %o3 <== NOT EXECUTED
2004d14: 40 00 02 2c call 20055c4 <rtems_semaphore_create> <== NOT EXECUTED
2004d18: 98 04 60 68 add %l1, 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)
2004d1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004d20: 02 bf ff 9f be 2004b9c <rtems_termios_open+0x24c> <== NOT EXECUTED
2004d24: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_task_start(tty->txTaskId,
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
2004d28: 40 00 04 8f call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004d2c: 01 00 00 00 nop <== NOT EXECUTED
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
2004d30: d0 04 60 7c ld [ %l1 + 0x7c ], %o0 <== NOT EXECUTED
2004d34: 40 00 16 ef call 200a8f0 <free> <== NOT EXECUTED
2004d38: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
2004d3c: 10 bf ff e9 b 2004ce0 <rtems_termios_open+0x390> <== NOT EXECUTED
2004d40: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
2004d44: 11 15 1e 15 sethi %hi(0x54785400), %o0 <== NOT EXECUTED
2004d48: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2004d4c: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
2004d50: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED
2004d54: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED
2004d58: 98 10 20 00 clr %o4 <== NOT EXECUTED
2004d5c: 40 00 03 34 call 2005a2c <rtems_task_create> <== NOT EXECUTED
2004d60: 9a 04 60 c8 add %l1, 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)
2004d64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004d68: 12 bf ff d3 bne 2004cb4 <rtems_termios_open+0x364> <== NOT EXECUTED
2004d6c: c2 4c e2 a0 ldsb [ %l3 + 0x2a0 ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
2004d70: 11 14 9e 15 sethi %hi(0x52785400), %o0 <== NOT EXECUTED
2004d74: 92 10 20 09 mov 9, %o1 <== NOT EXECUTED
2004d78: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED
2004d7c: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED
2004d80: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED
2004d84: 98 10 20 00 clr %o4 <== NOT EXECUTED
2004d88: 40 00 03 29 call 2005a2c <rtems_task_create> <== NOT EXECUTED
2004d8c: 9a 04 60 c4 add %l1, 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)
2004d90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004d94: 22 bf ff 7b be,a 2004b80 <rtems_termios_open+0x230> <== NOT EXECUTED
2004d98: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED
sc = rtems_task_start(tty->txTaskId,
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
2004d9c: 40 00 04 72 call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004da0: 01 00 00 00 nop <== NOT EXECUTED
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
2004da4: 10 bf ff 4a b 2004acc <rtems_termios_open+0x17c>
2004da8: e2 20 a2 a4 st %l1, [ %g2 + 0x2a4 ]
02003648 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
2003648: 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) {
200364c: 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)
{
2003650: 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) {
2003654: 80 a0 60 00 cmp %g1, 0
2003658: 02 80 00 44 be 2003768 <rtems_termios_puts+0x120> <== ALWAYS TAKEN
200365c: a6 10 00 18 mov %i0, %l3
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
2003660: e4 06 a0 80 ld [ %i2 + 0x80 ], %l2 <== NOT EXECUTED
while (len) {
2003664: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2003668: 02 80 00 44 be 2003778 <rtems_termios_puts+0x130> <== NOT EXECUTED
200366c: a2 10 20 02 mov 2, %l1 <== NOT EXECUTED
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
}
tty->rawOutBufState = rob_busy;
2003670: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
2003674: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1 <== NOT EXECUTED
2003678: 40 00 41 6a call 2013c20 <.urem> <== NOT EXECUTED
200367c: 90 04 a0 01 add %l2, 1, %o0 <== NOT EXECUTED
rtems_interrupt_disable (level);
2003680: 7f ff f9 d9 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
2003684: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
2003688: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
while (newHead == tty->rawOutBuf.Tail) {
200368c: e0 06 a0 84 ld [ %i2 + 0x84 ], %l0 <== NOT EXECUTED
2003690: 80 a4 00 12 cmp %l0, %l2 <== NOT EXECUTED
2003694: 12 80 00 13 bne 20036e0 <rtems_termios_puts+0x98> <== NOT EXECUTED
2003698: 01 00 00 00 nop <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
200369c: e2 26 a0 94 st %l1, [ %i2 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable (level);
20036a0: 7f ff f9 d5 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20036a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
20036a8: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0 <== NOT EXECUTED
20036ac: 92 10 20 00 clr %o1 <== NOT EXECUTED
20036b0: 40 00 08 6c call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
20036b4: 94 10 20 00 clr %o2 <== NOT EXECUTED
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20036b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20036bc: 12 80 00 20 bne 200373c <rtems_termios_puts+0xf4> <== NOT EXECUTED
20036c0: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
20036c4: 7f ff f9 c8 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20036c8: 01 00 00 00 nop <== NOT EXECUTED
20036cc: 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) {
20036d0: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1 <== NOT EXECUTED
20036d4: 80 a0 40 10 cmp %g1, %l0 <== NOT EXECUTED
20036d8: 22 bf ff f2 be,a 20036a0 <rtems_termios_puts+0x58> <== NOT EXECUTED
20036dc: e2 26 a0 94 st %l1, [ %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++;
20036e0: c8 06 a0 80 ld [ %i2 + 0x80 ], %g4 <== NOT EXECUTED
20036e4: c4 0c c0 00 ldub [ %l3 ], %g2 <== NOT EXECUTED
20036e8: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED
20036ec: c4 28 40 04 stb %g2, [ %g1 + %g4 ] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
20036f0: c6 06 a0 94 ld [ %i2 + 0x94 ], %g3 <== 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;
20036f4: e4 26 a0 80 st %l2, [ %i2 + 0x80 ] <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
20036f8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20036fc: 12 80 00 0a bne 2003724 <rtems_termios_puts+0xdc> <== NOT EXECUTED
2003700: 01 00 00 00 nop <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
2003704: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2003708: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
200370c: 02 80 00 0e be 2003744 <rtems_termios_puts+0xfc> <== NOT EXECUTED
2003710: 01 00 00 00 nop <== 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;
2003714: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2003718: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
200371c: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
2003720: e8 26 a0 94 st %l4, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
2003724: 7f ff f9 b4 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2003728: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
200372c: b2 86 7f ff addcc %i1, -1, %i1 <== NOT EXECUTED
2003730: 02 80 00 12 be 2003778 <rtems_termios_puts+0x130> <== NOT EXECUTED
2003734: a6 04 e0 01 inc %l3 <== NOT EXECUTED
2003738: 30 bf ff cf b,a 2003674 <rtems_termios_puts+0x2c> <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
200373c: 40 00 0a 0a call 2005f64 <rtems_fatal_error_occurred> <== NOT EXECUTED
2003740: 01 00 00 00 nop <== NOT EXECUTED
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
2003744: d2 06 a0 84 ld [ %i2 + 0x84 ], %o1 <== NOT EXECUTED
2003748: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED
200374c: c4 06 a0 a4 ld [ %i2 + 0xa4 ], %g2 <== NOT EXECUTED
2003750: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 <== NOT EXECUTED
2003754: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
2003758: 9f c0 80 00 call %g2 <== NOT EXECUTED
200375c: 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;
2003760: 10 bf ff f1 b 2003724 <rtems_termios_puts+0xdc> <== NOT EXECUTED
2003764: e8 26 a0 94 st %l4, [ %i2 + 0x94 ] <== NOT EXECUTED
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
2003768: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
200376c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2003770: 9f c0 40 00 call %g1
2003774: 94 10 00 19 mov %i1, %o2
2003778: 81 c7 e0 08 ret
200377c: 81 e8 00 00 restore
02003f50 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2003f50: 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;
2003f54: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
uint32_t count = args->count;
2003f58: e4 06 20 0c ld [ %i0 + 0xc ], %l2 <== 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;
2003f5c: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
2003f60: e6 06 20 08 ld [ %i0 + 8 ], %l3 <== NOT EXECUTED
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2003f64: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2003f68: 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);
2003f6c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2003f70: 40 00 06 3c call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
2003f74: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2003f78: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2003f7c: 12 80 00 10 bne 2003fbc <rtems_termios_read+0x6c> <== NOT EXECUTED
2003f80: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
2003f84: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 <== NOT EXECUTED
2003f88: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED
2003f8c: 82 10 63 b4 or %g1, 0x3b4, %g1 <== NOT EXECUTED
2003f90: 84 00 a0 08 add %g2, 8, %g2 <== NOT EXECUTED
2003f94: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED
2003f98: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2003f9c: 02 80 00 0a be 2003fc4 <rtems_termios_read+0x74> <== NOT EXECUTED
2003fa0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
2003fa4: 9f c0 40 00 call %g1 <== NOT EXECUTED
2003fa8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2003fac: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2003fb0: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
2003fb4: 40 00 06 73 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003fb8: c0 24 20 e4 clr [ %l0 + 0xe4 ] <== NOT EXECUTED
2003fbc: 81 c7 e0 08 ret <== NOT EXECUTED
2003fc0: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
if (tty->cindex == tty->ccount) {
2003fc4: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
2003fc8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
2003fcc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2003fd0: 22 80 00 20 be,a 2004050 <rtems_termios_read+0x100> <== NOT EXECUTED
2003fd4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2003fd8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2003fdc: 22 80 00 16 be,a 2004034 <rtems_termios_read+0xe4> <== NOT EXECUTED
2003fe0: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
2003fe4: c6 04 20 24 ld [ %l0 + 0x24 ], %g3 <== NOT EXECUTED
2003fe8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
2003fec: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
2003ff0: 26 80 00 09 bl,a 2004014 <rtems_termios_read+0xc4> <== NOT EXECUTED
2003ff4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
2003ff8: 10 80 00 0f b 2004034 <rtems_termios_read+0xe4> <== NOT EXECUTED
2003ffc: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2004000: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
2004004: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2004008: 24 80 00 0b ble,a 2004034 <rtems_termios_read+0xe4> <== NOT EXECUTED
200400c: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
2004010: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2004014: a4 84 bf ff addcc %l2, -1, %l2 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
2004018: c4 08 40 03 ldub [ %g1 + %g3 ], %g2 <== NOT EXECUTED
200401c: 86 00 e0 01 inc %g3 <== NOT EXECUTED
2004020: c4 2c c0 00 stb %g2, [ %l3 ] <== NOT EXECUTED
2004024: c6 24 20 24 st %g3, [ %l0 + 0x24 ] <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2004028: 12 bf ff f6 bne 2004000 <rtems_termios_read+0xb0> <== NOT EXECUTED
200402c: a6 04 e0 01 inc %l3 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
2004030: c2 05 a0 0c ld [ %l6 + 0xc ], %g1 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
2004034: 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;
2004038: 82 20 40 12 sub %g1, %l2, %g1 <== NOT EXECUTED
200403c: c2 25 a0 14 st %g1, [ %l6 + 0x14 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2004040: 40 00 06 50 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2004044: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED
return sc;
}
2004048: 81 c7 e0 08 ret <== NOT EXECUTED
200404c: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
2004050: 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;
2004054: 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;
2004058: c0 24 20 20 clr [ %l0 + 0x20 ] <== NOT EXECUTED
200405c: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
2004060: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2004064: 02 80 00 06 be 200407c <rtems_termios_read+0x12c> <== NOT EXECUTED
2004068: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
200406c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED
2004070: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004074: 22 80 00 69 be,a 2004218 <rtems_termios_read+0x2c8> <== NOT EXECUTED
2004078: c2 04 20 3c ld [ %l0 + 0x3c ], %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;
200407c: e2 04 20 74 ld [ %l0 + 0x74 ], %l1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2004080: 03 00 80 5a sethi %hi(0x2016800), %g1 <== 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,
2004084: ae 04 20 49 add %l0, 0x49, %l7 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2004088: aa 10 62 94 or %g1, 0x294, %l5 <== 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,
200408c: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2004090: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED
2004094: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED
2004098: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200409c: 02 80 00 3e be 2004194 <rtems_termios_read+0x244> <== NOT EXECUTED
20040a0: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
20040a4: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
20040a8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
20040ac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20040b0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20040b4: 16 80 00 38 bge 2004194 <rtems_termios_read+0x244> <== NOT EXECUTED
20040b8: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
20040bc: d0 04 20 5c ld [ %l0 + 0x5c ], %o0 <== NOT EXECUTED
20040c0: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED
20040c4: 40 00 3e d7 call 2013c20 <.urem> <== NOT EXECUTED
20040c8: 90 02 20 01 inc %o0 <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
20040cc: 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;
20040d0: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
20040d4: e2 08 40 08 ldub [ %g1 + %o0 ], %l1 <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
20040d8: d0 24 20 5c st %o0, [ %l0 + 0x5c ] <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
20040dc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED
20040e0: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED
20040e4: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED
20040e8: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
20040ec: 40 00 3e cd call 2013c20 <.urem> <== NOT EXECUTED
20040f0: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED
20040f4: c2 04 20 bc ld [ %l0 + 0xbc ], %g1 <== NOT EXECUTED
20040f8: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
20040fc: 3a 80 00 18 bcc,a 200415c <rtems_termios_read+0x20c> <== NOT EXECUTED
2004100: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
2004104: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
2004108: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED
200410c: 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))
2004110: c4 04 20 b8 ld [ %l0 + 0xb8 ], %g2 <== NOT EXECUTED
2004114: 84 08 a2 02 and %g2, 0x202, %g2 <== NOT EXECUTED
2004118: 80 a0 a2 02 cmp %g2, 0x202 <== NOT EXECUTED
200411c: 22 80 00 31 be,a 20041e0 <rtems_termios_read+0x290> <== NOT EXECUTED
2004120: c2 04 20 94 ld [ %l0 + 0x94 ], %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) {
2004124: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
2004128: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
200412c: 22 80 00 0c be,a 200415c <rtems_termios_read+0x20c> <== NOT EXECUTED
2004130: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
2004134: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
2004138: 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;
200413c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2004140: c2 24 20 b8 st %g1, [ %l0 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
2004144: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2004148: 22 80 00 05 be,a 200415c <rtems_termios_read+0x20c> <== NOT EXECUTED
200414c: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2004150: 9f c0 80 00 call %g2 <== NOT EXECUTED
2004154: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2004158: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
200415c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2004160: 02 80 00 17 be 20041bc <rtems_termios_read+0x26c> <== NOT EXECUTED
2004164: 90 0c 60 ff and %l1, 0xff, %o0 <== NOT EXECUTED
if (siproc (c, tty))
2004168: 7f ff ff 0c call 2003d98 <siproc> <== NOT EXECUTED
200416c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2004170: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004174: 32 80 00 02 bne,a 200417c <rtems_termios_read+0x22c> <== NOT EXECUTED
2004178: a8 10 20 00 clr %l4 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
200417c: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED
2004180: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED
2004184: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2004188: 12 bf ff c7 bne 20040a4 <rtems_termios_read+0x154> <== NOT EXECUTED
200418c: e2 04 20 70 ld [ %l0 + 0x70 ], %l1 <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
2004190: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
2004194: 02 bf ff 92 be 2003fdc <rtems_termios_read+0x8c> <== NOT EXECUTED
2004198: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
200419c: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
20041a0: d2 04 20 6c ld [ %l0 + 0x6c ], %o1 <== NOT EXECUTED
20041a4: 40 00 05 af call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
20041a8: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
tty->rawInBufSemaphoreOptions,
timeout);
if (sc != RTEMS_SUCCESSFUL)
20041ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20041b0: 02 bf ff b8 be 2004090 <rtems_termios_read+0x140> <== NOT EXECUTED
20041b4: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
20041b8: 30 bf ff 89 b,a 2003fdc <rtems_termios_read+0x8c> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
}
else {
siproc (c, tty);
20041bc: 7f ff fe f7 call 2003d98 <siproc> <== NOT EXECUTED
20041c0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
20041c4: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED
20041c8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
20041cc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20041d0: 06 bf ff eb bl 200417c <rtems_termios_read+0x22c> <== NOT EXECUTED
20041d4: 01 00 00 00 nop <== NOT EXECUTED
20041d8: 10 bf ff e9 b 200417c <rtems_termios_read+0x22c> <== NOT EXECUTED
20041dc: a8 10 20 00 clr %l4 ! 0 <PROM_START> <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
20041e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20041e4: 22 80 00 07 be,a 2004200 <rtems_termios_read+0x2b0> <== NOT EXECUTED
20041e8: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED
20041ec: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED
20041f0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
20041f4: 02 bf ff cc be 2004124 <rtems_termios_read+0x1d4> <== NOT EXECUTED
20041f8: 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,
20041fc: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED
2004200: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
2004204: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
2004208: 9f c0 40 00 call %g1 <== NOT EXECUTED
200420c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2004210: 10 bf ff d3 b 200415c <rtems_termios_read+0x20c> <== NOT EXECUTED
2004214: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
2004218: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
200421c: 12 80 00 37 bne 20042f8 <rtems_termios_read+0x3a8> <== NOT EXECUTED
2004220: 01 00 00 00 nop <== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
2004224: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED
2004228: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200422c: 12 80 00 07 bne 2004248 <rtems_termios_read+0x2f8> <== NOT EXECUTED
2004230: a8 07 bf f4 add %fp, -12, %l4 <== NOT EXECUTED
2004234: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED
2004238: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200423c: 12 80 00 3f bne 2004338 <rtems_termios_read+0x3e8> <== NOT EXECUTED
2004240: 90 10 20 02 mov 2, %o0 <== 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);
2004244: a8 07 bf f4 add %fp, -12, %l4 <== NOT EXECUTED
}
}
else {
if (!tty->termios.c_cc[VTIME])
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
2004248: 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);
200424c: 9f c0 80 00 call %g2 <== NOT EXECUTED
2004250: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
if (n < 0) {
2004254: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004258: 36 80 00 16 bge,a 20042b0 <rtems_termios_read+0x360> <== NOT EXECUTED
200425c: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
if (tty->termios.c_cc[VMIN]) {
2004260: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED
2004264: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004268: 02 80 00 38 be 2004348 <rtems_termios_read+0x3f8> <== NOT EXECUTED
200426c: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED
if (tty->termios.c_cc[VTIME] && tty->ccount) {
2004270: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004274: 02 80 00 06 be 200428c <rtems_termios_read+0x33c> <== NOT EXECUTED
2004278: 01 00 00 00 nop <== NOT EXECUTED
200427c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
2004280: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004284: 12 80 00 34 bne 2004354 <rtems_termios_read+0x404> <== NOT EXECUTED
2004288: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
200428c: 40 00 06 ad call 2005d40 <rtems_task_wake_after> <== NOT EXECUTED
2004290: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
2004294: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== 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);
2004298: 9f c0 80 00 call %g2 <== NOT EXECUTED
200429c: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
if (n < 0) {
20042a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20042a4: 26 bf ff f0 bl,a 2004264 <rtems_termios_read+0x314> <== NOT EXECUTED
20042a8: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED
}
}
rtems_task_wake_after (1);
}
else {
siproc (n, tty);
20042ac: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
20042b0: 7f ff fe ba call 2003d98 <siproc> <== NOT EXECUTED
20042b4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
20042b8: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED
20042bc: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED
20042c0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20042c4: 16 bf ff 45 bge 2003fd8 <rtems_termios_read+0x88> <== NOT EXECUTED
20042c8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
20042cc: 22 bf ff e0 be,a 200424c <rtems_termios_read+0x2fc> <== NOT EXECUTED
20042d0: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED
20042d4: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED
20042d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20042dc: 12 80 00 13 bne 2004328 <rtems_termios_read+0x3d8> <== NOT EXECUTED
20042e0: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
20042e4: 10 bf ff da b 200424c <rtems_termios_read+0x2fc> <== NOT EXECUTED
20042e8: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
20042ec: 40 00 06 95 call 2005d40 <rtems_task_wake_after> <== NOT EXECUTED
20042f0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
20042f4: c6 04 20 a0 ld [ %l0 + 0xa0 ], %g3 <== NOT EXECUTED
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
20042f8: 9f c0 c0 00 call %g3 <== NOT EXECUTED
20042fc: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED
if (n < 0) {
2004300: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004304: 06 bf ff fa bl 20042ec <rtems_termios_read+0x39c> <== NOT EXECUTED
2004308: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
200430c: 7f ff fe a3 call 2003d98 <siproc> <== NOT EXECUTED
2004310: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2004314: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004318: 12 bf ff 31 bne 2003fdc <rtems_termios_read+0x8c> <== NOT EXECUTED
200431c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
2004320: 10 bf ff f6 b 20042f8 <rtems_termios_read+0x3a8> <== NOT EXECUTED
2004324: c6 04 20 a0 ld [ %l0 + 0xa0 ], %g3 <== 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);
2004328: 40 00 02 f0 call 2004ee8 <rtems_clock_get> <== NOT EXECUTED
200432c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2004330: 10 bf ff c7 b 200424c <rtems_termios_read+0x2fc> <== NOT EXECUTED
2004334: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== 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);
2004338: 40 00 02 ec call 2004ee8 <rtems_clock_get> <== NOT EXECUTED
200433c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2004340: 10 bf ff c1 b 2004244 <rtems_termios_read+0x2f4> <== NOT EXECUTED
2004344: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
2004348: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200434c: 02 bf ff 23 be 2003fd8 <rtems_termios_read+0x88> <== NOT EXECUTED
2004350: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED
break;
rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now);
2004354: 40 00 02 e5 call 2004ee8 <rtems_clock_get> <== NOT EXECUTED
2004358: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
200435c: c6 04 20 54 ld [ %l0 + 0x54 ], %g3 <== NOT EXECUTED
2004360: c4 07 bf f4 ld [ %fp + -12 ], %g2 <== NOT EXECUTED
2004364: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2004368: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
200436c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2004370: 08 bf ff c7 bleu 200428c <rtems_termios_read+0x33c> <== NOT EXECUTED
2004374: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2004378: 30 bf ff 19 b,a 2003fdc <rtems_termios_read+0x8c> <== NOT EXECUTED
0200308c <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)
{
200308c: 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))
2003090: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2003094: 82 08 64 03 and %g1, 0x403, %g1 <== NOT EXECUTED
2003098: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED
200309c: 22 80 00 3e be,a 2003194 <rtems_termios_refill_transmitter+0x108><== NOT EXECUTED
20030a0: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
20030a4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20030a8: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
20030ac: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
20030b0: 22 80 00 49 be,a 20031d4 <rtems_termios_refill_transmitter+0x148><== NOT EXECUTED
20030b4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
20030b8: c4 06 20 80 ld [ %i0 + 0x80 ], %g2 <== NOT EXECUTED
20030bc: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 <== NOT EXECUTED
20030c0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20030c4: 22 80 00 2f be,a 2003180 <rtems_termios_refill_transmitter+0xf4><== NOT EXECUTED
20030c8: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
}
rtems_interrupt_disable(level);
20030cc: 7f ff fb 46 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20030d0: 01 00 00 00 nop <== NOT EXECUTED
len = tty->t_dqlen;
20030d4: e0 06 20 90 ld [ %i0 + 0x90 ], %l0 <== NOT EXECUTED
tty->t_dqlen = 0;
20030d8: c0 26 20 90 clr [ %i0 + 0x90 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
20030dc: 7f ff fb 46 call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20030e0: 01 00 00 00 nop <== NOT EXECUTED
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
20030e4: d0 06 20 84 ld [ %i0 + 0x84 ], %o0 <== NOT EXECUTED
20030e8: d2 06 20 88 ld [ %i0 + 0x88 ], %o1 <== NOT EXECUTED
20030ec: 40 00 42 cd call 2013c20 <.urem> <== NOT EXECUTED
20030f0: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
20030f4: 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;
20030f8: d0 26 20 84 st %o0, [ %i0 + 0x84 ] <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
20030fc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
2003100: 02 80 00 54 be 2003250 <rtems_termios_refill_transmitter+0x1c4><== NOT EXECUTED
2003104: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
2003108: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
200310c: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED
2003110: 22 80 00 41 be,a 2003214 <rtems_termios_refill_transmitter+0x188><== NOT EXECUTED
2003114: c2 06 20 d4 ld [ %i0 + 0xd4 ], %g1 <== 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))
2003118: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
200311c: 82 08 62 10 and %g1, 0x210, %g1 <== NOT EXECUTED
2003120: 80 a0 62 10 cmp %g1, 0x210 <== NOT EXECUTED
2003124: 02 80 00 4e be 200325c <rtems_termios_refill_transmitter+0x1d0><== NOT EXECUTED
2003128: 01 00 00 00 nop <== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
200312c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2003130: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED
2003134: 08 80 00 41 bleu 2003238 <rtems_termios_refill_transmitter+0x1ac><== NOT EXECUTED
2003138: 01 00 00 00 nop <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
200313c: c2 06 20 88 ld [ %i0 + 0x88 ], %g1 <== NOT EXECUTED
2003140: a0 20 40 11 sub %g1, %l1, %l0 <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
2003144: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2003148: 80 88 66 00 btst 0x600, %g1 <== NOT EXECUTED
200314c: 32 80 00 02 bne,a 2003154 <rtems_termios_refill_transmitter+0xc8><== NOT EXECUTED
2003150: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
2003154: d2 06 20 7c ld [ %i0 + 0x7c ], %o1 <== NOT EXECUTED
2003158: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED
200315c: d0 06 20 10 ld [ %i0 + 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*/
2003160: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2003164: 92 02 40 11 add %o1, %l1, %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*/
2003168: c2 26 20 94 st %g1, [ %i0 + 0x94 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
200316c: 9f c0 80 00 call %g2 <== NOT EXECUTED
2003170: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2003174: e2 26 20 84 st %l1, [ %i0 + 0x84 ] <== NOT EXECUTED
}
return nToSend;
}
2003178: 81 c7 e0 08 ret <== NOT EXECUTED
200317c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
2003180: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
2003184: 02 80 00 30 be 2003244 <rtems_termios_refill_transmitter+0x1b8><== NOT EXECUTED
2003188: a0 10 20 00 clr %l0 <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
200318c: 81 c7 e0 08 ret <== NOT EXECUTED
2003190: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
2003194: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2003198: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
200319c: 9f c0 40 00 call %g1 <== NOT EXECUTED
20031a0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
20031a4: 7f ff fb 10 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20031a8: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
20031ac: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
20031b0: 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--;
20031b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
20031b8: 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--;
20031bc: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
20031c0: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
20031c4: 7f ff fb 0c call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
20031c8: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
20031cc: 81 c7 e0 08 ret <== NOT EXECUTED
20031d0: 91 e8 00 10 restore %g0, %l0, %o0 <== 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,
20031d4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
20031d8: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED
20031dc: 9f c0 40 00 call %g1 <== NOT EXECUTED
20031e0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
20031e4: 7f ff fb 00 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
20031e8: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
20031ec: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
20031f0: 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--;
20031f4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
20031f8: 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--;
20031fc: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
2003200: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
2003204: 7f ff fa fc call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
2003208: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
}
return nToSend;
}
200320c: 81 c7 e0 08 ret <== NOT EXECUTED
2003210: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
2003214: c0 26 20 94 clr [ %i0 + 0x94 ] <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2003218: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200321c: 02 bf ff d6 be 2003174 <rtems_termios_refill_transmitter+0xe8><== NOT EXECUTED
2003220: a0 10 20 00 clr %l0 <== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
2003224: d2 06 20 d8 ld [ %i0 + 0xd8 ], %o1 <== NOT EXECUTED
2003228: 9f c0 40 00 call %g1 <== NOT EXECUTED
200322c: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2003230: e2 26 20 84 st %l1, [ %i0 + 0x84 ] <== NOT EXECUTED
2003234: 30 bf ff d1 b,a 2003178 <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
2003238: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
200323c: 10 bf ff c2 b 2003144 <rtems_termios_refill_transmitter+0xb8><== NOT EXECUTED
2003240: a0 20 40 11 sub %g1, %l1, %l0 <== NOT EXECUTED
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2003244: 40 00 09 cf call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003248: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
200324c: 30 bf ff d0 b,a 200318c <rtems_termios_refill_transmitter+0x100><== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2003250: 40 00 09 cc call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003254: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
2003258: 30 bf ff ac b,a 2003108 <rtems_termios_refill_transmitter+0x7c><== NOT EXECUTED
/* check, whether output should stop due to received XOFF */
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);
200325c: 7f ff fa e2 call 2001de4 <sparc_disable_interrupts> <== NOT EXECUTED
2003260: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
2003264: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
2003268: 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;
200326c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
2003270: c4 26 20 94 st %g2, [ %i0 + 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;
2003274: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
rtems_interrupt_enable(level);
2003278: 7f ff fa df call 2001df4 <sparc_enable_interrupts> <== NOT EXECUTED
200327c: a0 10 20 00 clr %l0 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[newTail],
nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2003280: e2 26 20 84 st %l1, [ %i0 + 0x84 ] <== NOT EXECUTED
2003284: 30 bf ff bd b,a 2003178 <rtems_termios_refill_transmitter+0xec><== NOT EXECUTED
02004e44 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
2004e44: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
2004e48: a0 07 bf f0 add %fp, -16, %l0 <== NOT EXECUTED
2004e4c: a2 07 bf f7 add %fp, -9, %l1 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
2004e50: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2004e54: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2004e58: 94 10 20 00 clr %o2 <== NOT EXECUTED
2004e5c: 40 00 00 c3 call 2005168 <rtems_event_receive> <== NOT EXECUTED
2004e60: 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) {
2004e64: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2004e68: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2004e6c: 32 80 00 16 bne,a 2004ec4 <rtems_termios_rxdaemon+0x80> <== NOT EXECUTED
2004e70: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2004e74: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
2004e78: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004e7c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
if (c != EOF) {
2004e80: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2004e84: 02 bf ff f3 be 2004e50 <rtems_termios_rxdaemon+0xc> <== NOT EXECUTED
2004e88: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
2004e8c: d0 2f bf f7 stb %o0, [ %fp + -9 ] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
2004e90: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2004e94: 7f ff f9 1c call 2003304 <rtems_termios_enqueue_raw_characters><== NOT EXECUTED
2004e98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
2004e9c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2004ea0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2004ea4: 94 10 20 00 clr %o2 <== NOT EXECUTED
2004ea8: 40 00 00 b0 call 2005168 <rtems_event_receive> <== NOT EXECUTED
2004eac: 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) {
2004eb0: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
2004eb4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2004eb8: 22 bf ff f0 be,a 2004e78 <rtems_termios_rxdaemon+0x34> <== NOT EXECUTED
2004ebc: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
tty->rxTaskId = 0;
2004ec0: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2004ec4: 40 00 03 25 call 2005b58 <rtems_task_delete> <== NOT EXECUTED
2004ec8: 90 10 20 00 clr %o0 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
2004ecc: 10 bf ff e2 b 2004e54 <rtems_termios_rxdaemon+0x10> <== NOT EXECUTED
2004ed0: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
02003074 <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);
2003074: d0 02 20 c4 ld [ %o0 + 0xc4 ], %o0 <== NOT EXECUTED
2003078: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200307c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2003080: 40 00 08 a4 call 2005310 <rtems_event_send> <== NOT EXECUTED
2003084: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004dac <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
2004dac: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
2004db0: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED
2004db4: a0 07 bf f4 add %fp, -12, %l0 <== NOT EXECUTED
2004db8: a2 10 63 b4 or %g1, 0x3b4, %l1 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
2004dbc: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2004dc0: 94 10 20 00 clr %o2 <== NOT EXECUTED
2004dc4: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2004dc8: 40 00 00 e8 call 2005168 <rtems_event_receive> <== NOT EXECUTED
2004dcc: 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) {
2004dd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
2004dd4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2004dd8: 12 80 00 16 bne 2004e30 <rtems_termios_txdaemon+0x84> <== NOT EXECUTED
2004ddc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2004de0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
2004de4: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2004de8: 82 04 40 01 add %l1, %g1, %g1 <== NOT EXECUTED
2004dec: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
2004df0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004df4: 02 80 00 04 be 2004e04 <rtems_termios_txdaemon+0x58> <== NOT EXECUTED
2004df8: 01 00 00 00 nop <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
2004dfc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2004e00: 01 00 00 00 nop <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
2004e04: 7f ff f8 a2 call 200308c <rtems_termios_refill_transmitter><== NOT EXECUTED
2004e08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
2004e0c: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2004e10: 94 10 20 00 clr %o2 <== NOT EXECUTED
2004e14: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2004e18: 40 00 00 d4 call 2005168 <rtems_event_receive> <== NOT EXECUTED
2004e1c: 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) {
2004e20: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
2004e24: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2004e28: 02 bf ff ee be 2004de0 <rtems_termios_txdaemon+0x34> <== NOT EXECUTED
2004e2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
tty->txTaskId = 0;
2004e30: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2004e34: 40 00 03 49 call 2005b58 <rtems_task_delete> <== NOT EXECUTED
2004e38: 90 10 20 00 clr %o0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
2004e3c: 10 bf ff e1 b 2004dc0 <rtems_termios_txdaemon+0x14> <== NOT EXECUTED
2004e40: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
02003de4 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
2003de4: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2003de8: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
2003dec: a8 10 00 18 mov %i0, %l4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2003df0: e2 00 60 28 ld [ %g1 + 0x28 ], %l1
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2003df4: 92 10 20 00 clr %o1
2003df8: d0 04 60 18 ld [ %l1 + 0x18 ], %o0
2003dfc: 40 00 06 99 call 2005860 <rtems_semaphore_obtain>
2003e00: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2003e04: b0 92 20 00 orcc %o0, 0, %i0
2003e08: 12 80 00 0f bne 2003e44 <rtems_termios_write+0x60> <== NEVER TAKEN
2003e0c: 03 00 80 5b sethi %hi(0x2016c00), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
2003e10: c4 04 60 cc ld [ %l1 + 0xcc ], %g2
2003e14: 85 28 a0 05 sll %g2, 5, %g2
2003e18: 82 10 63 b4 or %g1, 0x3b4, %g1
2003e1c: 82 00 40 02 add %g1, %g2, %g1
2003e20: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2003e24: 80 a0 60 00 cmp %g1, 0
2003e28: 02 80 00 13 be 2003e74 <rtems_termios_write+0x90> <== ALWAYS TAKEN
2003e2c: 92 10 00 14 mov %l4, %o1
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
2003e30: 9f c0 40 00 call %g1 <== NOT EXECUTED
2003e34: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2003e38: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
2003e3c: 40 00 06 d1 call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003e40: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED
2003e44: 81 c7 e0 08 ret <== NOT EXECUTED
2003e48: 81 e8 00 00 restore <== NOT EXECUTED
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
2003e4c: d0 05 20 08 ld [ %l4 + 8 ], %o0 <== NOT EXECUTED
2003e50: d2 05 20 0c ld [ %l4 + 0xc ], %o1 <== NOT EXECUTED
2003e54: 7f ff fd fd call 2003648 <rtems_termios_puts> <== NOT EXECUTED
2003e58: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
2003e5c: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED
2003e60: c2 25 20 14 st %g1, [ %l4 + 0x14 ]
}
rtems_semaphore_release (tty->osem);
2003e64: 40 00 06 c7 call 2005980 <rtems_semaphore_release>
2003e68: d0 04 60 18 ld [ %l1 + 0x18 ], %o0
return sc;
}
2003e6c: 81 c7 e0 08 ret
2003e70: 81 e8 00 00 restore
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
2003e74: c2 04 60 34 ld [ %l1 + 0x34 ], %g1
2003e78: 80 88 60 01 btst 1, %g1
2003e7c: 02 bf ff f4 be 2003e4c <rtems_termios_write+0x68> <== NEVER TAKEN
2003e80: a0 10 20 00 clr %l0
uint32_t count = args->count;
2003e84: e6 05 20 0c ld [ %l4 + 0xc ], %l3
char *buffer = args->buffer;
2003e88: e4 05 20 08 ld [ %l4 + 8 ], %l2
while (count--)
2003e8c: 80 a4 e0 00 cmp %l3, 0
2003e90: 02 bf ff f4 be 2003e60 <rtems_termios_write+0x7c> <== NEVER TAKEN
2003e94: 82 10 20 00 clr %g1
oproc (*buffer++, tty);
2003e98: d0 0c 80 10 ldub [ %l2 + %l0 ], %o0
2003e9c: 7f ff fe 39 call 2003780 <oproc>
2003ea0: 92 10 00 11 mov %l1, %o1
2003ea4: a0 04 20 01 inc %l0
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2003ea8: 80 a4 c0 10 cmp %l3, %l0
2003eac: 32 bf ff fc bne,a 2003e9c <rtems_termios_write+0xb8>
2003eb0: d0 0c 80 10 ldub [ %l2 + %l0 ], %o0
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
2003eb4: 10 bf ff eb b 2003e60 <rtems_termios_write+0x7c>
2003eb8: c2 05 20 0c ld [ %l4 + 0xc ], %g1
020113e4 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
Objects_Id id
)
{
20113e4: 9d e3 bf 90 save %sp, -112, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
20113e8: 11 00 80 c4 sethi %hi(0x2031000), %o0
20113ec: 92 10 00 18 mov %i0, %o1
20113f0: 90 12 20 a0 or %o0, 0xa0, %o0
20113f4: 40 00 0b 9b call 2014260 <_Objects_Get>
20113f8: 94 07 bf f4 add %fp, -12, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
20113fc: c2 07 bf f4 ld [ %fp + -12 ], %g1
2011400: 80 a0 60 00 cmp %g1, 0
2011404: 12 80 00 0a bne 201142c <rtems_timer_cancel+0x48>
2011408: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
201140c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2011410: 80 a0 60 04 cmp %g1, 4
2011414: 02 80 00 04 be 2011424 <rtems_timer_cancel+0x40> <== NEVER TAKEN
2011418: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
201141c: 40 00 14 9e call 2016694 <_Watchdog_Remove>
2011420: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
2011424: 40 00 0e 12 call 2014c6c <_Thread_Enable_dispatch>
2011428: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
201142c: 81 c7 e0 08 ret
2011430: 81 e8 00 00 restore
02011434 <rtems_timer_create>:
rtems_status_code rtems_timer_create(
rtems_name name,
Objects_Id *id
)
{
2011434: 9d e3 bf 98 save %sp, -104, %sp
Timer_Control *the_timer;
if ( !rtems_is_name_valid( name ) )
2011438: a2 96 20 00 orcc %i0, 0, %l1
201143c: 02 80 00 20 be 20114bc <rtems_timer_create+0x88>
2011440: b0 10 20 03 mov 3, %i0
return RTEMS_INVALID_NAME;
if ( !id )
2011444: 80 a6 60 00 cmp %i1, 0
2011448: 02 80 00 1d be 20114bc <rtems_timer_create+0x88> <== NEVER TAKEN
201144c: b0 10 20 09 mov 9, %i0
2011450: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2011454: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1 ! 2030d80 <_Thread_Dispatch_disable_level>
2011458: 82 00 60 01 inc %g1
201145c: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
* 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 );
2011460: 21 00 80 c4 sethi %hi(0x2031000), %l0
2011464: 40 00 0a 05 call 2013c78 <_Objects_Allocate>
2011468: 90 14 20 a0 or %l0, 0xa0, %o0 ! 20310a0 <_Timer_Information>
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
201146c: 80 a2 20 00 cmp %o0, 0
2011470: 02 80 00 15 be 20114c4 <rtems_timer_create+0x90>
2011474: 82 14 20 a0 or %l0, 0xa0, %g1
2011478: c6 02 20 08 ld [ %o0 + 8 ], %g3
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
201147c: e2 22 20 0c st %l1, [ %o0 + 0xc ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2011480: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
2011484: c0 22 20 30 clr [ %o0 + 0x30 ]
&_Timer_Information,
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
2011488: c6 26 40 00 st %g3, [ %i1 ]
if ( !the_timer ) {
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
the_timer->the_class = TIMER_DORMANT;
201148c: 84 10 20 04 mov 4, %g2
2011490: 03 00 00 3f sethi %hi(0xfc00), %g1
2011494: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2011498: 86 08 c0 01 and %g3, %g1, %g3
201149c: 87 28 e0 02 sll %g3, 2, %g3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20114a0: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
20114a4: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20114a8: c0 22 20 34 clr [ %o0 + 0x34 ]
20114ac: c4 22 20 38 st %g2, [ %o0 + 0x38 ]
20114b0: d0 21 00 03 st %o0, [ %g4 + %g3 ]
&the_timer->Object,
(Objects_Name) name
);
*id = the_timer->Object.id;
_Thread_Enable_dispatch();
20114b4: 40 00 0d ee call 2014c6c <_Thread_Enable_dispatch>
20114b8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
20114bc: 81 c7 e0 08 ret
20114c0: 81 e8 00 00 restore
_Thread_Disable_dispatch(); /* to prevent deletion */
the_timer = _Timer_Allocate();
if ( !the_timer ) {
_Thread_Enable_dispatch();
20114c4: 40 00 0d ea call 2014c6c <_Thread_Enable_dispatch>
20114c8: b0 10 20 05 mov 5, %i0
20114cc: 81 c7 e0 08 ret
20114d0: 81 e8 00 00 restore
02011534 <rtems_timer_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2011534: 9d e3 bf 90 save %sp, -112, %sp
2011538: a4 10 00 18 mov %i0, %l2
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( ticks == 0 )
201153c: 80 a6 60 00 cmp %i1, 0
2011540: 02 80 00 26 be 20115d8 <rtems_timer_fire_after+0xa4>
2011544: b0 10 20 0a mov 0xa, %i0
return RTEMS_INVALID_NUMBER;
if ( !routine )
2011548: 80 a6 a0 00 cmp %i2, 0
201154c: 02 80 00 23 be 20115d8 <rtems_timer_fire_after+0xa4> <== NEVER TAKEN
2011550: b0 10 20 09 mov 9, %i0
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2011554: 11 00 80 c4 sethi %hi(0x2031000), %o0
2011558: 92 10 00 12 mov %l2, %o1
201155c: 90 12 20 a0 or %o0, 0xa0, %o0
2011560: 40 00 0b 40 call 2014260 <_Objects_Get>
2011564: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2011568: c2 07 bf f4 ld [ %fp + -12 ], %g1
201156c: a0 10 00 08 mov %o0, %l0
2011570: 80 a0 60 00 cmp %g1, 0
2011574: 12 80 00 19 bne 20115d8 <rtems_timer_fire_after+0xa4>
2011578: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
201157c: a2 02 20 10 add %o0, 0x10, %l1
2011580: 40 00 14 45 call 2016694 <_Watchdog_Remove>
2011584: 90 10 00 11 mov %l1, %o0
_ISR_Disable( level );
2011588: 7f ff e7 3b call 200b274 <sparc_disable_interrupts>
201158c: 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 ) {
2011590: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
2011594: 80 a0 60 00 cmp %g1, 0
2011598: 12 80 00 12 bne 20115e0 <rtems_timer_fire_after+0xac> <== NEVER TAKEN
201159c: 01 00 00 00 nop
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20115a0: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
20115a4: e4 24 20 30 st %l2, [ %l0 + 0x30 ]
the_watchdog->user_data = user_data;
20115a8: 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;
20115ac: c0 24 20 38 clr [ %l0 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20115b0: c0 24 20 18 clr [ %l0 + 0x18 ]
_Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
_ISR_Enable( level );
20115b4: 7f ff e7 34 call 200b284 <sparc_enable_interrupts>
20115b8: b0 10 20 00 clr %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20115bc: 92 10 00 11 mov %l1, %o1
20115c0: 11 00 80 c3 sethi %hi(0x2030c00), %o0
20115c4: 90 12 22 64 or %o0, 0x264, %o0 ! 2030e64 <_Watchdog_Ticks_chain>
20115c8: 40 00 13 c8 call 20164e8 <_Watchdog_Insert>
20115cc: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
_Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
_Thread_Enable_dispatch();
20115d0: 40 00 0d a7 call 2014c6c <_Thread_Enable_dispatch>
20115d4: 01 00 00 00 nop
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20115d8: 81 c7 e0 08 ret
20115dc: 81 e8 00 00 restore
* 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 ) {
_ISR_Enable( level );
20115e0: 7f ff e7 29 call 200b284 <sparc_enable_interrupts> <== NOT EXECUTED
20115e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
_Thread_Enable_dispatch();
20115e8: 40 00 0d a1 call 2014c6c <_Thread_Enable_dispatch> <== NOT EXECUTED
20115ec: 01 00 00 00 nop <== NOT EXECUTED
20115f0: 81 c7 e0 08 ret <== NOT EXECUTED
20115f4: 81 e8 00 00 restore <== NOT EXECUTED
020115f8 <rtems_timer_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
20115f8: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
20115fc: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2011600: c4 08 61 94 ldub [ %g1 + 0x194 ], %g2 ! 2030d94 <_TOD_Is_set>
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2011604: a4 10 00 18 mov %i0, %l2
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_TOD_Is_set )
2011608: 80 a0 a0 00 cmp %g2, 0
201160c: 02 80 00 2f be 20116c8 <rtems_timer_fire_when+0xd0>
2011610: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !_TOD_Validate( wall_time ) )
2011614: 7f ff f5 10 call 200ea54 <_TOD_Validate>
2011618: 90 10 00 19 mov %i1, %o0
201161c: 80 8a 20 ff btst 0xff, %o0
2011620: 02 80 00 0b be 201164c <rtems_timer_fire_when+0x54>
2011624: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_CLOCK;
if ( !routine )
2011628: 02 80 00 28 be 20116c8 <rtems_timer_fire_when+0xd0> <== NEVER TAKEN
201162c: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
seconds = _TOD_To_seconds( wall_time );
2011630: 7f ff f4 d4 call 200e980 <_TOD_To_seconds>
2011634: 90 10 00 19 mov %i1, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
2011638: 27 00 80 c3 sethi %hi(0x2030c00), %l3
201163c: c2 04 e2 14 ld [ %l3 + 0x214 ], %g1 ! 2030e14 <_TOD_Now>
2011640: 80 a2 00 01 cmp %o0, %g1
2011644: 18 80 00 04 bgu 2011654 <rtems_timer_fire_when+0x5c>
2011648: a2 10 00 08 mov %o0, %l1
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
201164c: 81 c7 e0 08 ret
2011650: 91 e8 20 14 restore %g0, 0x14, %o0
2011654: 11 00 80 c4 sethi %hi(0x2031000), %o0
2011658: 92 10 00 12 mov %l2, %o1
201165c: 90 12 20 a0 or %o0, 0xa0, %o0
2011660: 40 00 0b 00 call 2014260 <_Objects_Get>
2011664: 94 07 bf f4 add %fp, -12, %o2
seconds = _TOD_To_seconds( wall_time );
if ( seconds <= _TOD_Seconds_since_epoch )
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2011668: c2 07 bf f4 ld [ %fp + -12 ], %g1
201166c: b2 10 00 08 mov %o0, %i1
2011670: 80 a0 60 00 cmp %g1, 0
2011674: 12 80 00 15 bne 20116c8 <rtems_timer_fire_when+0xd0>
2011678: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
201167c: a0 02 20 10 add %o0, 0x10, %l0
2011680: 40 00 14 05 call 2016694 <_Watchdog_Remove>
2011684: 90 10 00 10 mov %l0, %o0
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
2011688: e4 26 60 30 st %l2, [ %i1 + 0x30 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
201168c: c2 04 e2 14 ld [ %l3 + 0x214 ], %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
2011690: 92 10 00 10 mov %l0, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2011694: 82 24 40 01 sub %l1, %g1, %g1
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
2011698: 11 00 80 c3 sethi %hi(0x2030c00), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
201169c: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
20116a0: 90 12 22 58 or %o0, 0x258, %o0
the_timer->the_class = TIMER_TIME_OF_DAY;
20116a4: 82 10 20 02 mov 2, %g1
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20116a8: f4 26 60 2c st %i2, [ %i1 + 0x2c ]
20116ac: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20116b0: f6 26 60 34 st %i3, [ %i1 + 0x34 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20116b4: c0 26 60 18 clr [ %i1 + 0x18 ]
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
20116b8: 40 00 13 8c call 20164e8 <_Watchdog_Insert>
20116bc: 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();
20116c0: 40 00 0d 6b call 2014c6c <_Thread_Enable_dispatch>
20116c4: 01 00 00 00 nop
20116c8: 81 c7 e0 08 ret
20116cc: 81 e8 00 00 restore
020116d0 <rtems_timer_get_information>:
rtems_status_code rtems_timer_get_information(
Objects_Id id,
rtems_timer_information *the_info
)
{
20116d0: 9d e3 bf 90 save %sp, -112, %sp
20116d4: 92 10 00 18 mov %i0, %o1
Timer_Control *the_timer;
Objects_Locations location;
if ( !the_info )
20116d8: 80 a6 60 00 cmp %i1, 0
20116dc: 02 80 00 14 be 201172c <rtems_timer_get_information+0x5c> <== NEVER TAKEN
20116e0: b0 10 20 09 mov 9, %i0
20116e4: 11 00 80 c4 sethi %hi(0x2031000), %o0
20116e8: 94 07 bf f4 add %fp, -12, %o2
20116ec: 40 00 0a dd call 2014260 <_Objects_Get>
20116f0: 90 12 20 a0 or %o0, 0xa0, %o0
return RTEMS_INVALID_ADDRESS;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
20116f4: c2 07 bf f4 ld [ %fp + -12 ], %g1
20116f8: 80 a0 60 00 cmp %g1, 0
20116fc: 12 80 00 0c bne 201172c <rtems_timer_get_information+0x5c>
2011700: 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;
2011704: 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;
2011708: c6 02 20 38 ld [ %o0 + 0x38 ], %g3
the_info->initial = the_timer->Ticker.initial;
201170c: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->start_time = the_timer->Ticker.start_time;
2011710: c4 02 20 24 ld [ %o0 + 0x24 ], %g2
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
the_info->the_class = the_timer->the_class;
2011714: c6 26 40 00 st %g3, [ %i1 ]
the_info->initial = the_timer->Ticker.initial;
the_info->start_time = the_timer->Ticker.start_time;
2011718: c4 26 60 08 st %g2, [ %i1 + 8 ]
the_info->stop_time = the_timer->Ticker.stop_time;
201171c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1
_Thread_Enable_dispatch();
2011720: b0 10 20 00 clr %i0
2011724: 40 00 0d 52 call 2014c6c <_Thread_Enable_dispatch>
2011728: c2 26 60 0c st %g1, [ %i1 + 0xc ]
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
201172c: 81 c7 e0 08 ret
2011730: 81 e8 00 00 restore
020119ec <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
uint32_t priority,
uint32_t stack_size,
rtems_attribute attribute_set
)
{
20119ec: 9d e3 bf 90 save %sp, -112, %sp
20119f0: 92 96 20 00 orcc %i0, 0, %o1
20119f4: 12 80 00 05 bne 2011a08 <rtems_timer_initiate_server+0x1c>
20119f8: 03 00 80 af sethi %hi(0x202bc00), %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;
20119fc: 90 10 20 13 mov 0x13, %o0
}
return status;
}
2011a00: 81 c7 e0 08 ret
2011a04: 91 e8 00 08 restore %g0, %o0, %o0
2011a08: c4 08 60 34 ldub [ %g1 + 0x34 ], %g2
2011a0c: 80 a2 40 02 cmp %o1, %g2
2011a10: 18 80 00 56 bgu 2011b68 <rtems_timer_initiate_server+0x17c><== ALWAYS TAKEN
2011a14: 80 a2 7f ff cmp %o1, -1
2011a18: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
2011a1c: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2011a20: c2 00 a1 80 ld [ %g2 + 0x180 ], %g1 ! 2030d80 <_Thread_Dispatch_disable_level>
2011a24: 82 00 60 01 inc %g1
2011a28: c2 20 a1 80 st %g1, [ %g2 + 0x180 ]
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
2011a2c: 23 00 80 b1 sethi %hi(0x202c400), %l1
initialized = true;
2011a30: 82 10 20 01 mov 1, %g1
/*
* Just to make sure this is only called once.
*/
_Thread_Disable_dispatch();
tmpInitialized = initialized;
2011a34: e0 0c 62 f4 ldub [ %l1 + 0x2f4 ], %l0
initialized = true;
_Thread_Enable_dispatch();
2011a38: 40 00 0c 8d call 2014c6c <_Thread_Enable_dispatch>
2011a3c: c2 2c 62 f4 stb %g1, [ %l1 + 0x2f4 ]
if ( tmpInitialized )
2011a40: 80 a4 20 00 cmp %l0, 0
2011a44: 12 bf ff ef bne 2011a00 <rtems_timer_initiate_server+0x14>
2011a48: 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);
2011a4c: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2011a50: 82 10 a0 94 or %g2, 0x94, %g1 ! 2030c94 <_Timer_To_be_inserted>
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2011a54: 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;
2011a58: 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);
2011a5c: 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(
2011a60: 92 10 00 18 mov %i0, %o1
2011a64: 94 10 00 19 mov %i1, %o2
2011a68: 19 00 00 20 sethi %hi(0x8000), %o4
2011a6c: c2 20 a0 94 st %g1, [ %g2 + 0x94 ]
2011a70: 98 16 80 0c or %i2, %o4, %o4
2011a74: 11 15 12 53 sethi %hi(0x54494c00), %o0
2011a78: 96 10 21 00 mov 0x100, %o3
2011a7c: 90 12 21 45 or %o0, 0x145, %o0
2011a80: 7f ff fc 78 call 2010c60 <rtems_task_create>
2011a84: 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) {
2011a88: 80 a2 20 00 cmp %o0, 0
2011a8c: 12 80 00 34 bne 2011b5c <rtems_timer_initiate_server+0x170>
2011a90: 03 00 80 c3 sethi %hi(0x2030c00), %g1
* 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(
2011a94: 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 )
2011a98: 86 10 60 34 or %g1, 0x34, %g3
2011a9c: c4 10 e0 10 lduh [ %g3 + 0x10 ], %g2
2011aa0: 03 00 00 3f sethi %hi(0xfc00), %g1
2011aa4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2011aa8: 82 0a c0 01 and %o3, %g1, %g1
2011aac: 80 a0 40 02 cmp %g1, %g2
2011ab0: 18 80 00 05 bgu 2011ac4 <rtems_timer_initiate_server+0xd8><== NEVER TAKEN
2011ab4: 98 10 20 00 clr %o4
2011ab8: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2
2011abc: 83 28 60 02 sll %g1, 2, %g1
2011ac0: d8 00 80 01 ld [ %g2 + %g1 ], %o4
2011ac4: 09 00 80 c3 sethi %hi(0x2030c00), %g4
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2011ac8: 1b 00 80 c3 sethi %hi(0x2030c00), %o5
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
2011acc: 84 11 20 74 or %g4, 0x74, %g2
the_chain->permanent_null = NULL;
the_chain->last = _Chain_Head(the_chain);
2011ad0: 82 13 60 88 or %o5, 0x88, %g1
2011ad4: 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;
2011ad8: c0 20 a0 04 clr [ %g2 + 4 ]
the_chain->last = _Chain_Head(the_chain);
2011adc: 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;
2011ae0: 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);
2011ae4: 84 00 a0 04 add %g2, 4, %g2
2011ae8: 82 00 60 04 add %g1, 4, %g1
the_watchdog->routine = routine;
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2011aec: c0 23 20 6c clr [ %o4 + 0x6c ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2011af0: c0 23 20 50 clr [ %o4 + 0x50 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
2011af4: d6 23 20 68 st %o3, [ %o4 + 0x68 ]
2011af8: c4 21 20 74 st %g2, [ %g4 + 0x74 ]
2011afc: c2 23 60 88 st %g1, [ %o5 + 0x88 ]
2011b00: 05 00 80 c4 sethi %hi(0x2031000), %g2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2011b04: 07 00 80 52 sethi %hi(0x2014800), %g3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2011b08: 03 00 80 c3 sethi %hi(0x2030c00), %g1
the_watchdog->routine = routine;
2011b0c: 86 10 e2 90 or %g3, 0x290, %g3
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2011b10: 82 10 60 a0 or %g1, 0xa0, %g1
the_watchdog->routine = routine;
2011b14: c6 23 20 64 st %g3, [ %o4 + 0x64 ]
2011b18: d8 20 a0 e4 st %o4, [ %g2 + 0xe4 ]
2011b1c: c6 20 60 1c st %g3, [ %g1 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2011b20: c0 20 60 24 clr [ %g1 + 0x24 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2011b24: c0 20 60 08 clr [ %g1 + 8 ]
the_watchdog->routine = routine;
the_watchdog->id = id;
2011b28: 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;
2011b2c: 05 00 80 46 sethi %hi(0x2011800), %g2
2011b30: 03 00 80 c4 sethi %hi(0x2031000), %g1
2011b34: 84 10 a3 78 or %g2, 0x378, %g2
/*
* Start the timer server
*/
status = rtems_task_start(
2011b38: 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;
2011b3c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ]
/*
* Start the timer server
*/
status = rtems_task_start(
2011b40: 13 00 80 47 sethi %hi(0x2011c00), %o1
2011b44: 94 10 20 00 clr %o2
2011b48: 7f ff fd 9e call 20111c0 <rtems_task_start>
2011b4c: 92 12 60 4c or %o1, 0x4c, %o1
id, /* the id from create */
(rtems_task_entry) _Timer_Server_body, /* the timer server entry point */
0 /* there is no argument */
);
if (status) {
2011b50: 80 a2 20 00 cmp %o0, 0
2011b54: 02 bf ff ab be 2011a00 <rtems_timer_initiate_server+0x14> <== ALWAYS TAKEN
2011b58: 01 00 00 00 nop
* 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;
2011b5c: c0 2c 62 f4 clrb [ %l1 + 0x2f4 ]
}
return status;
}
2011b60: 81 c7 e0 08 ret
2011b64: 91 e8 00 08 restore %g0, %o0, %o0
* structured so we check it is invalid before looking for
* a specific invalid value as the default.
*/
_priority = priority;
if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
2011b68: 02 bf ff ad be 2011a1c <rtems_timer_initiate_server+0x30>
2011b6c: b0 10 20 00 clr %i0
* 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;
2011b70: 10 bf ff a4 b 2011a00 <rtems_timer_initiate_server+0x14>
2011b74: 90 10 20 13 mov 0x13, %o0
0201176c <rtems_timer_reset>:
*/
rtems_status_code rtems_timer_reset(
Objects_Id id
)
{
201176c: 9d e3 bf 90 save %sp, -112, %sp
2011770: 11 00 80 c4 sethi %hi(0x2031000), %o0
2011774: 92 10 00 18 mov %i0, %o1
2011778: 90 12 20 a0 or %o0, 0xa0, %o0
201177c: 40 00 0a b9 call 2014260 <_Objects_Get>
2011780: 94 07 bf f4 add %fp, -12, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2011784: c2 07 bf f4 ld [ %fp + -12 ], %g1
2011788: a0 10 00 08 mov %o0, %l0
201178c: 80 a0 60 00 cmp %g1, 0
2011790: 12 80 00 11 bne 20117d4 <rtems_timer_reset+0x68>
2011794: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
2011798: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201179c: 80 a0 60 01 cmp %g1, 1
20117a0: 22 80 00 15 be,a 20117f4 <rtems_timer_reset+0x88>
20117a4: 31 00 80 c4 sethi %hi(0x2031000), %i0
20117a8: 1a 80 00 0d bcc 20117dc <rtems_timer_reset+0x70>
20117ac: 80 a0 60 04 cmp %g1, 4
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
20117b0: a0 02 20 10 add %o0, 0x10, %l0
20117b4: 40 00 13 b8 call 2016694 <_Watchdog_Remove>
20117b8: 90 10 00 10 mov %l0, %o0
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
20117bc: 11 00 80 c3 sethi %hi(0x2030c00), %o0
20117c0: 92 10 00 10 mov %l0, %o1
20117c4: 40 00 13 49 call 20164e8 <_Watchdog_Insert>
20117c8: 90 12 22 64 or %o0, 0x264, %o0
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
return RTEMS_NOT_DEFINED;
}
_Thread_Enable_dispatch();
20117cc: 40 00 0d 28 call 2014c6c <_Thread_Enable_dispatch>
20117d0: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20117d4: 81 c7 e0 08 ret
20117d8: 81 e8 00 00 restore
the_timer = _Timer_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
switch ( the_timer->the_class ) {
20117dc: 18 bf ff fc bgu 20117cc <rtems_timer_reset+0x60> <== NEVER TAKEN
20117e0: 01 00 00 00 nop
(*_Timer_Server_schedule_operation)( the_timer );
break;
case TIMER_TIME_OF_DAY:
case TIMER_TIME_OF_DAY_ON_TASK:
case TIMER_DORMANT:
_Thread_Enable_dispatch();
20117e4: 40 00 0d 22 call 2014c6c <_Thread_Enable_dispatch>
20117e8: b0 10 20 0b mov 0xb, %i0 ! b <PROM_START+0xb>
20117ec: 81 c7 e0 08 ret
20117f0: 81 e8 00 00 restore
case TIMER_INTERVAL:
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
20117f4: c2 06 20 e0 ld [ %i0 + 0xe0 ], %g1
20117f8: 80 a0 60 00 cmp %g1, 0
20117fc: 02 80 00 08 be 201181c <rtems_timer_reset+0xb0> <== NEVER TAKEN
2011800: 01 00 00 00 nop
_Thread_Enable_dispatch();
return RTEMS_INCORRECT_STATE;
}
_Watchdog_Remove( &the_timer->Ticker );
2011804: 40 00 13 a4 call 2016694 <_Watchdog_Remove>
2011808: 90 02 20 10 add %o0, 0x10, %o0
(*_Timer_Server_schedule_operation)( the_timer );
201180c: c2 06 20 e0 ld [ %i0 + 0xe0 ], %g1
2011810: 9f c0 40 00 call %g1
2011814: 90 10 00 10 mov %l0, %o0
2011818: 30 bf ff ed b,a 20117cc <rtems_timer_reset+0x60>
_Watchdog_Remove( &the_timer->Ticker );
_Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
break;
case TIMER_INTERVAL_ON_TASK:
if ( !_Timer_Server_schedule_operation ) {
_Thread_Enable_dispatch();
201181c: 40 00 0d 14 call 2014c6c <_Thread_Enable_dispatch> <== NOT EXECUTED
2011820: b0 10 20 0e mov 0xe, %i0 <== NOT EXECUTED
2011824: 81 c7 e0 08 ret <== NOT EXECUTED
2011828: 81 e8 00 00 restore <== NOT EXECUTED
0201182c <rtems_timer_server_fire_after>:
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
201182c: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
2011830: 03 00 80 c4 sethi %hi(0x2031000), %g1
2011834: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 20310e4 <_Timer_Server>
Objects_Id id,
rtems_interval ticks,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2011838: a2 10 00 18 mov %i0, %l1
Timer_Control *the_timer;
Objects_Locations location;
ISR_Level level;
if ( !_Timer_Server )
201183c: 80 a0 a0 00 cmp %g2, 0
2011840: 02 80 00 28 be 20118e0 <rtems_timer_server_fire_after+0xb4>
2011844: b0 10 20 0e mov 0xe, %i0
return RTEMS_INCORRECT_STATE;
if ( !routine )
2011848: 80 a6 a0 00 cmp %i2, 0
201184c: 02 80 00 25 be 20118e0 <rtems_timer_server_fire_after+0xb4><== NEVER TAKEN
2011850: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( ticks == 0 )
2011854: 80 a6 60 00 cmp %i1, 0
2011858: 02 80 00 22 be 20118e0 <rtems_timer_server_fire_after+0xb4>
201185c: b0 10 20 0a mov 0xa, %i0
2011860: 11 00 80 c4 sethi %hi(0x2031000), %o0
2011864: 92 10 00 11 mov %l1, %o1
2011868: 90 12 20 a0 or %o0, 0xa0, %o0
201186c: 40 00 0a 7d call 2014260 <_Objects_Get>
2011870: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_NUMBER;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2011874: c2 07 bf f4 ld [ %fp + -12 ], %g1
2011878: a0 10 00 08 mov %o0, %l0
201187c: 80 a0 60 00 cmp %g1, 0
2011880: 12 80 00 18 bne 20118e0 <rtems_timer_server_fire_after+0xb4>
2011884: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
2011888: 40 00 13 83 call 2016694 <_Watchdog_Remove>
201188c: 90 02 20 10 add %o0, 0x10, %o0
_ISR_Disable( level );
2011890: 7f ff e6 79 call 200b274 <sparc_disable_interrupts>
2011894: 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 ) {
2011898: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
201189c: 80 a0 60 00 cmp %g1, 0
20118a0: 12 80 00 12 bne 20118e8 <rtems_timer_server_fire_after+0xbc><== NEVER TAKEN
20118a4: 82 10 20 01 mov 1, %g1
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20118a8: f4 24 20 2c st %i2, [ %l0 + 0x2c ]
the_watchdog->id = id;
20118ac: e2 24 20 30 st %l1, [ %l0 + 0x30 ]
the_watchdog->user_data = user_data;
20118b0: 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;
20118b4: f2 24 20 1c st %i1, [ %l0 + 0x1c ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20118b8: 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;
20118bc: 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 );
20118c0: 7f ff e6 71 call 200b284 <sparc_enable_interrupts>
20118c4: 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 );
20118c8: 03 00 80 c4 sethi %hi(0x2031000), %g1
20118cc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 20310e0 <_Timer_Server_schedule_operation>
20118d0: 9f c0 80 00 call %g2
20118d4: 90 10 00 10 mov %l0, %o0
_Thread_Enable_dispatch();
20118d8: 40 00 0c e5 call 2014c6c <_Thread_Enable_dispatch>
20118dc: 01 00 00 00 nop
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20118e0: 81 c7 e0 08 ret
20118e4: 81 e8 00 00 restore
* 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 ) {
_ISR_Enable( level );
20118e8: 7f ff e6 67 call 200b284 <sparc_enable_interrupts> <== NOT EXECUTED
20118ec: b0 10 20 00 clr %i0 <== NOT EXECUTED
_Thread_Enable_dispatch();
20118f0: 40 00 0c df call 2014c6c <_Thread_Enable_dispatch> <== NOT EXECUTED
20118f4: 01 00 00 00 nop <== NOT EXECUTED
20118f8: 81 c7 e0 08 ret <== NOT EXECUTED
20118fc: 81 e8 00 00 restore <== NOT EXECUTED
02011900 <rtems_timer_server_fire_when>:
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2011900: 9d e3 bf 90 save %sp, -112, %sp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
2011904: 03 00 80 c4 sethi %hi(0x2031000), %g1
2011908: c4 00 60 e4 ld [ %g1 + 0xe4 ], %g2 ! 20310e4 <_Timer_Server>
Objects_Id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
201190c: a2 10 00 18 mov %i0, %l1
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
if ( !_Timer_Server )
2011910: 80 a0 a0 00 cmp %g2, 0
2011914: 02 80 00 34 be 20119e4 <rtems_timer_server_fire_when+0xe4>
2011918: b0 10 20 0e mov 0xe, %i0
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
201191c: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2011920: c4 08 61 94 ldub [ %g1 + 0x194 ], %g2 ! 2030d94 <_TOD_Is_set>
2011924: 80 a0 a0 00 cmp %g2, 0
2011928: 02 80 00 2f be 20119e4 <rtems_timer_server_fire_when+0xe4><== NEVER TAKEN
201192c: b0 10 20 0b mov 0xb, %i0
return RTEMS_NOT_DEFINED;
if ( !routine )
2011930: 80 a6 a0 00 cmp %i2, 0
2011934: 02 80 00 2c be 20119e4 <rtems_timer_server_fire_when+0xe4><== NEVER TAKEN
2011938: b0 10 20 09 mov 9, %i0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
201193c: 7f ff f4 46 call 200ea54 <_TOD_Validate>
2011940: 90 10 00 19 mov %i1, %o0
2011944: 80 8a 20 ff btst 0xff, %o0
2011948: 12 80 00 04 bne 2011958 <rtems_timer_server_fire_when+0x58>
201194c: 01 00 00 00 nop
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2011950: 81 c7 e0 08 ret
2011954: 91 e8 20 14 restore %g0, 0x14, %o0
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
2011958: 7f ff f4 0a call 200e980 <_TOD_To_seconds>
201195c: 90 10 00 19 mov %i1, %o0
if ( seconds <= _TOD_Seconds_since_epoch )
2011960: 25 00 80 c3 sethi %hi(0x2030c00), %l2
2011964: c2 04 a2 14 ld [ %l2 + 0x214 ], %g1 ! 2030e14 <_TOD_Now>
2011968: 80 a2 00 01 cmp %o0, %g1
201196c: 08 bf ff f9 bleu 2011950 <rtems_timer_server_fire_when+0x50>
2011970: a0 10 00 08 mov %o0, %l0
2011974: 11 00 80 c4 sethi %hi(0x2031000), %o0
2011978: 92 10 00 11 mov %l1, %o1
201197c: 90 12 20 a0 or %o0, 0xa0, %o0
2011980: 40 00 0a 38 call 2014260 <_Objects_Get>
2011984: 94 07 bf f4 add %fp, -12, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2011988: c2 07 bf f4 ld [ %fp + -12 ], %g1
201198c: b2 10 00 08 mov %o0, %i1
2011990: 80 a0 60 00 cmp %g1, 0
2011994: 12 80 00 14 bne 20119e4 <rtems_timer_server_fire_when+0xe4>
2011998: b0 10 20 04 mov 4, %i0
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
201199c: 40 00 13 3e call 2016694 <_Watchdog_Remove>
20119a0: 90 02 20 10 add %o0, 0x10, %o0
the_watchdog->routine = routine;
the_watchdog->id = id;
20119a4: e2 26 60 30 st %l1, [ %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;
20119a8: c4 04 a2 14 ld [ %l2 + 0x214 ], %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 );
20119ac: 03 00 80 c4 sethi %hi(0x2031000), %g1
20119b0: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 ! 20310e0 <_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;
20119b4: 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;
20119b8: 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 );
20119bc: 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;
20119c0: 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;
20119c4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20119c8: f4 26 60 2c st %i2, [ %i1 + 0x2c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20119cc: f6 26 60 34 st %i3, [ %i1 + 0x34 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20119d0: 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 );
20119d4: 9f c0 c0 00 call %g3
20119d8: b0 10 20 00 clr %i0
_Thread_Enable_dispatch();
20119dc: 40 00 0c a4 call 2014c6c <_Thread_Enable_dispatch>
20119e0: 01 00 00 00 nop
20119e4: 81 c7 e0 08 ret
20119e8: 81 e8 00 00 restore
02002e5c <rtems_verror>:
static int rtems_verror(
uint32_t error_flag,
const char *printf_format,
va_list arglist
)
{
2002e5c: 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)
2002e60: 03 08 00 00 sethi %hi(0x20000000), %g1 <== NOT EXECUTED
2002e64: a8 8e 00 01 andcc %i0, %g1, %l4 <== NOT EXECUTED
2002e68: 02 80 00 10 be 2002ea8 <rtems_verror+0x4c> <== NOT EXECUTED
2002e6c: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
2002e70: 07 00 80 8d sethi %hi(0x2023400), %g3 <== NOT EXECUTED
2002e74: c4 00 e2 74 ld [ %g3 + 0x274 ], %g2 ! 2023674 <rtems_panic_in_progress><== NOT EXECUTED
2002e78: 82 00 a0 01 add %g2, 1, %g1 <== NOT EXECUTED
2002e7c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2002e80: 02 80 00 06 be 2002e98 <rtems_verror+0x3c> <== NOT EXECUTED
2002e84: c2 20 e2 74 st %g1, [ %g3 + 0x274 ] <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
2002e88: 05 00 80 8e sethi %hi(0x2023800), %g2 <== NOT EXECUTED
2002e8c: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1 ! 2023850 <_Thread_Dispatch_disable_level><== NOT EXECUTED
2002e90: 82 00 60 01 inc %g1 <== NOT EXECUTED
2002e94: c2 20 a0 50 st %g1, [ %g2 + 0x50 ] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
2002e98: c2 00 e2 74 ld [ %g3 + 0x274 ], %g1 <== NOT EXECUTED
2002e9c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
2002ea0: 34 80 00 3b bg,a 2002f8c <rtems_verror+0x130> <== NOT EXECUTED
2002ea4: b0 10 20 00 clr %i0 <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2002ea8: 25 00 80 6c sethi %hi(0x201b000), %l2 <== NOT EXECUTED
2002eac: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 ! 201b210 <_impure_ptr><== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2002eb0: a2 10 20 00 clr %l1 <== NOT EXECUTED
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2002eb4: 40 00 2f f1 call 200ee78 <fflush> <== NOT EXECUTED
2002eb8: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
2002ebc: 03 1c 00 00 sethi %hi(0x70000000), %g1 <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
2002ec0: 05 10 00 00 sethi %hi(0x40000000), %g2 <== NOT EXECUTED
2002ec4: 80 8c c0 02 btst %l3, %g2 <== NOT EXECUTED
2002ec8: 12 80 00 42 bne 2002fd0 <rtems_verror+0x174> <== NOT EXECUTED
2002ecc: a0 2c c0 01 andn %l3, %g1, %l0 <== 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);
2002ed0: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
2002ed4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2002ed8: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2002edc: 40 00 43 f2 call 2013ea4 <vfprintf> <== NOT EXECUTED
2002ee0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
if (status)
2002ee4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2002ee8: 12 80 00 2b bne 2002f94 <rtems_verror+0x138> <== NOT EXECUTED
2002eec: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno)
2002ef0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
2002ef4: 02 80 00 12 be 2002f3c <rtems_verror+0xe0> <== NOT EXECUTED
2002ef8: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
2002efc: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
2002f00: 04 80 00 08 ble 2002f20 <rtems_verror+0xc4> <== NOT EXECUTED
2002f04: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
2002f08: 40 00 35 30 call 20103c8 <strerror> <== NOT EXECUTED
2002f0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2002f10: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED
2002f14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2002f18: 12 80 00 3b bne 2003004 <rtems_verror+0x1a8> <== NOT EXECUTED
2002f1c: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
2002f20: 13 00 80 64 sethi %hi(0x2019000), %o1 <== NOT EXECUTED
2002f24: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2002f28: 92 12 61 78 or %o1, 0x178, %o1 <== NOT EXECUTED
2002f2c: 40 00 30 c6 call 200f244 <fprintf> <== NOT EXECUTED
2002f30: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2002f34: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
2002f38: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
2002f3c: 13 00 80 63 sethi %hi(0x2018c00), %o1 <== NOT EXECUTED
2002f40: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2002f44: 40 00 30 c0 call 200f244 <fprintf> <== NOT EXECUTED
2002f48: 92 12 63 68 or %o1, 0x368, %o1 <== NOT EXECUTED
(void) fflush(stderr);
2002f4c: c2 04 a2 10 ld [ %l2 + 0x210 ], %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");
2002f50: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
(void) fflush(stderr);
2002f54: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2002f58: 40 00 2f c8 call 200ee78 <fflush> <== NOT EXECUTED
2002f5c: b0 04 00 18 add %l0, %i0, %i0 <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
2002f60: 03 0c 00 00 sethi %hi(0x30000000), %g1 <== NOT EXECUTED
2002f64: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED
2002f68: 02 80 00 09 be 2002f8c <rtems_verror+0x130> <== NOT EXECUTED
2002f6c: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
2002f70: 02 80 00 2f be 200302c <rtems_verror+0x1d0> <== NOT EXECUTED
2002f74: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
2002f78: 13 00 80 64 sethi %hi(0x2019000), %o1 <== NOT EXECUTED
2002f7c: 40 00 00 3f call 2003078 <rtems_error> <== NOT EXECUTED
2002f80: 92 12 61 90 or %o1, 0x190, %o1 ! 2019190 <pollCallbacks.4767+0x438><== NOT EXECUTED
_exit(local_errno);
2002f84: 40 00 01 c7 call 20036a0 <_exit> <== NOT EXECUTED
2002f88: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rtems_error(0, "fatal error, aborting");
abort();
}
}
return chars_written;
}
2002f8c: 81 c7 e0 08 ret <== NOT EXECUTED
2002f90: 81 e8 00 00 restore <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
2002f94: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
2002f98: 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));
2002f9c: 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);
2002fa0: 11 00 80 65 sethi %hi(0x2019400), %o0 <== NOT EXECUTED
2002fa4: 40 00 25 8f call 200c5e0 <rtems_assoc_name_by_local> <== NOT EXECUTED
2002fa8: 90 12 20 d8 or %o0, 0xd8, %o0 ! 20194d8 <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));
2002fac: 13 00 80 64 sethi %hi(0x2019000), %o1 <== NOT EXECUTED
const char *
rtems_status_text(
rtems_status_code status
)
{
return rtems_assoc_name_by_local(rtems_status_assoc, status);
2002fb0: 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));
2002fb4: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
2002fb8: 40 00 30 a3 call 200f244 <fprintf> <== NOT EXECUTED
2002fbc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if (local_errno)
2002fc0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
2002fc4: 02 bf ff dd be 2002f38 <rtems_verror+0xdc> <== NOT EXECUTED
2002fc8: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED
2002fcc: 30 bf ff cd b,a 2002f00 <rtems_verror+0xa4> <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
2002fd0: 40 00 2e d9 call 200eb34 <__errno> <== NOT EXECUTED
2002fd4: 01 00 00 00 nop <== 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);
2002fd8: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
2002fdc: e2 02 00 00 ld [ %o0 ], %l1 <== 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);
2002fe0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2002fe4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2002fe8: 40 00 43 af call 2013ea4 <vfprintf> <== NOT EXECUTED
2002fec: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
if (status)
2002ff0: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
2002ff4: 02 bf ff bf be 2002ef0 <rtems_verror+0x94> <== NOT EXECUTED
2002ff8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
2002ffc: 10 bf ff e7 b 2002f98 <rtems_verror+0x13c> <== NOT EXECUTED
2003000: c2 04 a2 10 ld [ %l2 + 0x210 ], %g1 <== NOT EXECUTED
if (local_errno)
{
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
2003004: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2003008: 40 00 34 f0 call 20103c8 <strerror> <== NOT EXECUTED
200300c: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED
2003010: 13 00 80 64 sethi %hi(0x2019000), %o1 <== NOT EXECUTED
2003014: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2003018: 92 12 61 68 or %o1, 0x168, %o1 <== NOT EXECUTED
200301c: 40 00 30 8a call 200f244 <fprintf> <== NOT EXECUTED
2003020: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2003024: 10 bf ff c5 b 2002f38 <rtems_verror+0xdc> <== NOT EXECUTED
2003028: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(local_errno);
}
else
{
rtems_error(0, "fatal error, aborting");
200302c: 13 00 80 64 sethi %hi(0x2019000), %o1 <== NOT EXECUTED
2003030: 40 00 00 12 call 2003078 <rtems_error> <== NOT EXECUTED
2003034: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 20191a8 <pollCallbacks.4767+0x450><== NOT EXECUTED
abort();
2003038: 40 00 2e b1 call 200eafc <abort> <== NOT EXECUTED
02003d98 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
2003d98: 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)) {
2003d9c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
2003da0: 80 88 6e 78 btst 0xe78, %g1 <== NOT EXECUTED
2003da4: 32 80 00 05 bne,a 2003db8 <siproc+0x20> <== NOT EXECUTED
2003da8: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== 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);
2003dac: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
2003db0: 7f ff ff 7d call 2003ba4 <iproc> <== NOT EXECUTED
2003db4: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2003db8: 94 10 20 00 clr %o2 <== NOT EXECUTED
2003dbc: 40 00 06 a9 call 2005860 <rtems_semaphore_obtain> <== NOT EXECUTED
2003dc0: 92 10 20 00 clr %o1 <== NOT EXECUTED
i = iproc (c, tty);
2003dc4: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED
2003dc8: 7f ff ff 77 call 2003ba4 <iproc> <== NOT EXECUTED
2003dcc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003dd0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
2003dd4: 40 00 06 eb call 2005980 <rtems_semaphore_release> <== NOT EXECUTED
2003dd8: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
2003ddc: 81 c7 e0 08 ret <== NOT EXECUTED
2003de0: 81 e8 00 00 restore <== NOT EXECUTED
02002c24 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
2002c24: 9d e3 bf 80 save %sp, -128, %sp
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002c28: d0 0e 00 00 ldub [ %i0 ], %o0
2002c2c: 91 2a 20 18 sll %o0, 0x18, %o0
2002c30: 80 a2 20 00 cmp %o0, 0
2002c34: 02 80 00 44 be 2002d44 <vprintk+0x120> <== NEVER TAKEN
2002c38: 03 00 80 59 sethi %hi(0x2016400), %g1
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
2002c3c: 05 00 80 0a sethi %hi(0x2002800), %g2
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
2002c40: a8 10 62 8c or %g1, 0x28c, %l4
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
2002c44: b4 10 a3 50 or %g2, 0x350, %i2
2002c48: 03 00 80 56 sethi %hi(0x2015800), %g1
count = 0;
while ((n = num / base) > 0) {
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
2002c4c: b6 07 bf f8 add %fp, -8, %i3
2002c50: b8 10 60 70 or %g1, 0x70, %i4
2002c54: ae 07 bf e0 add %fp, -32, %l7
base = 0;
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
2002c58: 91 3a 20 18 sra %o0, 0x18, %o0
2002c5c: 80 a2 20 25 cmp %o0, 0x25
2002c60: 32 80 00 3b bne,a 2002d4c <vprintk+0x128>
2002c64: c2 05 00 00 ld [ %l4 ], %g1
fmt++;
if (*fmt == '0' ) {
2002c68: d0 0e 20 01 ldub [ %i0 + 1 ], %o0
sign = 0;
width = 0;
minus = 0;
lead = ' ';
if (*fmt == '%') {
fmt++;
2002c6c: 88 06 20 01 add %i0, 1, %g4
if (*fmt == '0' ) {
2002c70: 87 2a 20 18 sll %o0, 0x18, %g3
2002c74: 83 38 e0 18 sra %g3, 0x18, %g1
2002c78: 80 a0 60 30 cmp %g1, 0x30
2002c7c: 02 80 00 b7 be 2002f58 <vprintk+0x334>
2002c80: ba 10 20 20 mov 0x20, %i5
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
2002c84: 83 38 e0 18 sra %g3, 0x18, %g1
2002c88: 80 a0 60 2d cmp %g1, 0x2d
2002c8c: 02 80 00 ae be 2002f44 <vprintk+0x320>
2002c90: ac 10 20 00 clr %l6
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
2002c94: 82 02 3f d0 add %o0, -48, %g1
2002c98: a0 10 20 00 clr %l0
2002c9c: 82 08 60 ff and %g1, 0xff, %g1
2002ca0: b0 10 00 04 mov %g4, %i0
2002ca4: 80 a0 60 09 cmp %g1, 9
2002ca8: 08 80 00 05 bleu 2002cbc <vprintk+0x98>
2002cac: aa 10 20 00 clr %l5
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
2002cb0: 10 80 00 13 b 2002cfc <vprintk+0xd8>
2002cb4: 83 38 e0 18 sra %g3, 0x18, %g1
2002cb8: 87 2a 20 18 sll %o0, 0x18, %g3
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
width += (*fmt - '0');
fmt++;
2002cbc: 88 01 20 01 inc %g4
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
2002cc0: d0 09 00 00 ldub [ %g4 ], %o0
width *= 10;
width += (*fmt - '0');
2002cc4: 85 2c 20 03 sll %l0, 3, %g2
2002cc8: 83 2c 20 01 sll %l0, 1, %g1
2002ccc: 87 38 e0 18 sra %g3, 0x18, %g3
2002cd0: 82 00 40 02 add %g1, %g2, %g1
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
2002cd4: 84 02 3f d0 add %o0, -48, %g2
width *= 10;
width += (*fmt - '0');
2002cd8: 82 00 40 03 add %g1, %g3, %g1
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
2002cdc: 84 08 a0 ff and %g2, 0xff, %g2
2002ce0: 80 a0 a0 09 cmp %g2, 9
2002ce4: 08 bf ff f5 bleu 2002cb8 <vprintk+0x94>
2002ce8: a0 00 7f d0 add %g1, -48, %l0
2002cec: b0 10 00 04 mov %g4, %i0
2002cf0: aa 10 00 10 mov %l0, %l5
2002cf4: 87 2a 20 18 sll %o0, 0x18, %g3
width *= 10;
width += (*fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
2002cf8: 83 38 e0 18 sra %g3, 0x18, %g1
2002cfc: 80 a0 60 6c cmp %g1, 0x6c
2002d00: 22 80 00 9b be,a 2002f6c <vprintk+0x348>
2002d04: d0 09 20 01 ldub [ %g4 + 1 ], %o0
lflag = 1;
c = *++fmt;
}
switch (c) {
2002d08: 82 02 3f bc add %o0, -68, %g1
2002d0c: 82 08 60 ff and %g1, 0xff, %g1
2002d10: 80 a0 60 34 cmp %g1, 0x34
2002d14: 08 80 00 12 bleu 2002d5c <vprintk+0x138>
2002d18: 83 28 60 02 sll %g1, 2, %g1
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
2002d1c: c2 05 00 00 ld [ %l4 ], %g1
2002d20: 91 2a 20 18 sll %o0, 0x18, %o0
2002d24: 9f c0 40 00 call %g1
2002d28: 91 3a 20 18 sra %o0, 0x18, %o0
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002d2c: b0 06 20 01 inc %i0
2002d30: d0 0e 00 00 ldub [ %i0 ], %o0
2002d34: 91 2a 20 18 sll %o0, 0x18, %o0
2002d38: 80 a2 20 00 cmp %o0, 0
2002d3c: 12 bf ff c8 bne 2002c5c <vprintk+0x38>
2002d40: 91 3a 20 18 sra %o0, 0x18, %o0
2002d44: 81 c7 e0 08 ret
2002d48: 81 e8 00 00 restore
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
base, sign, width, lead);
} else {
BSP_output_char(*fmt);
2002d4c: 9f c0 40 00 call %g1
2002d50: b0 06 20 01 inc %i0
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002d54: 10 bf ff f8 b 2002d34 <vprintk+0x110>
2002d58: d0 0e 00 00 ldub [ %i0 ], %o0
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
2002d5c: c4 06 80 01 ld [ %i2 + %g1 ], %g2
2002d60: 81 c0 80 00 jmp %g2
2002d64: 01 00 00 00 nop
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
2002d68: 82 10 20 00 clr %g1 ! 0 <PROM_START> <== NOT EXECUTED
2002d6c: a6 10 20 08 mov 8, %l3 <== NOT EXECUTED
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
2002d70: e2 06 40 00 ld [ %i1 ], %l1
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
2002d74: 80 a4 60 00 cmp %l1, 0
2002d78: 06 80 00 3d bl 2002e6c <vprintk+0x248> <== NEVER TAKEN
2002d7c: b2 06 60 04 add %i1, 4, %i1
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
2002d80: 90 10 00 11 mov %l1, %o0
2002d84: 92 10 00 13 mov %l3, %o1
2002d88: 40 00 42 fa call 2013970 <.udiv>
2002d8c: a0 10 20 00 clr %l0
2002d90: 80 a2 20 00 cmp %o0, 0
2002d94: 02 80 00 14 be 2002de4 <vprintk+0x1c0>
2002d98: a4 10 20 01 mov 1, %l2
2002d9c: a4 10 00 11 mov %l1, %l2
2002da0: a0 10 20 00 clr %l0
2002da4: 10 80 00 03 b 2002db0 <vprintk+0x18c>
2002da8: a2 10 00 08 mov %o0, %l1
2002dac: a2 10 00 08 mov %o0, %l1
toPrint[count++] = (num - (n*base));
2002db0: 92 10 00 13 mov %l3, %o1
2002db4: 40 00 42 b5 call 2013888 <.umul>
2002db8: 90 10 00 11 mov %l1, %o0
2002dbc: 90 24 80 08 sub %l2, %o0, %o0
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
2002dc0: 92 10 00 13 mov %l3, %o1
toPrint[count++] = (num - (n*base));
2002dc4: d0 2d c0 10 stb %o0, [ %l7 + %l0 ]
num = -num;
if (maxwidth) maxwidth--;
}
count = 0;
while ((n = num / base) > 0) {
2002dc8: 90 10 00 11 mov %l1, %o0
2002dcc: 40 00 42 e9 call 2013970 <.udiv>
2002dd0: a0 04 20 01 inc %l0
2002dd4: 80 a2 20 00 cmp %o0, 0
2002dd8: 12 bf ff f5 bne 2002dac <vprintk+0x188>
2002ddc: a4 10 00 11 mov %l1, %l2
2002de0: a4 04 20 01 add %l0, 1, %l2
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
2002de4: 82 06 c0 10 add %i3, %l0, %g1
2002de8: e2 28 7f e8 stb %l1, [ %g1 + -24 ]
for (n=maxwidth ; n > count; n-- )
2002dec: 80 a4 80 15 cmp %l2, %l5
2002df0: 1a 80 00 0a bcc 2002e18 <vprintk+0x1f4>
2002df4: a0 10 00 15 mov %l5, %l0
2002df8: a2 10 00 1d mov %i5, %l1
BSP_output_char(lead);
2002dfc: c2 05 00 00 ld [ %l4 ], %g1
2002e00: 9f c0 40 00 call %g1
2002e04: 90 10 00 11 mov %l1, %o0
toPrint[count++] = (num - (n*base));
num = n;
}
toPrint[count++] = num;
for (n=maxwidth ; n > count; n-- )
2002e08: a0 04 3f ff add %l0, -1, %l0
2002e0c: 80 a4 80 10 cmp %l2, %l0
2002e10: 2a bf ff fc bcs,a 2002e00 <vprintk+0x1dc>
2002e14: c2 05 00 00 ld [ %l4 ], %g1
BSP_output_char(lead);
for (n = 0; n < count; n++) {
2002e18: 80 a4 a0 00 cmp %l2, 0
2002e1c: 02 bf ff c4 be 2002d2c <vprintk+0x108> <== NEVER TAKEN
2002e20: a2 06 c0 12 add %i3, %l2, %l1
2002e24: a0 10 20 00 clr %l0
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
2002e28: 82 24 40 10 sub %l1, %l0, %g1
2002e2c: c4 48 7f e7 ldsb [ %g1 + -25 ], %g2
2002e30: c6 05 00 00 ld [ %l4 ], %g3
2002e34: d0 4f 00 02 ldsb [ %i4 + %g2 ], %o0
2002e38: 9f c0 c0 00 call %g3
2002e3c: 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++) {
2002e40: 80 a4 80 10 cmp %l2, %l0
2002e44: 18 bf ff fa bgu 2002e2c <vprintk+0x208>
2002e48: 82 24 40 10 sub %l1, %l0, %g1
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002e4c: 10 bf ff b9 b 2002d30 <vprintk+0x10c>
2002e50: b0 06 20 01 inc %i0
BSP_output_char(c);
break;
} /* switch*/
if (base)
printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int),
2002e54: e2 06 40 00 ld [ %i1 ], %l1
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
2002e58: 82 10 20 01 mov 1, %g1
2002e5c: a6 10 20 0a mov 0xa, %l3
{
long unsigned int n;
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
2002e60: 80 a4 60 00 cmp %l1, 0
2002e64: 16 bf ff c7 bge 2002d80 <vprintk+0x15c> <== ALWAYS TAKEN
2002e68: b2 06 60 04 add %i1, 4, %i1
2002e6c: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
2002e70: 02 bf ff c5 be 2002d84 <vprintk+0x160> <== NOT EXECUTED
2002e74: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
BSP_output_char('-');
2002e78: c2 05 00 00 ld [ %l4 ], %g1 <== NOT EXECUTED
2002e7c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002e80: 90 10 20 2d mov 0x2d, %o0 <== NOT EXECUTED
num = -num;
if (maxwidth) maxwidth--;
2002e84: 80 a0 00 15 cmp %g0, %l5 <== NOT EXECUTED
int count;
char toPrint[20];
if ( (sign == 1) && ((long)num < 0) ) {
BSP_output_char('-');
num = -num;
2002e88: a2 20 00 11 neg %l1 <== NOT EXECUTED
if (maxwidth) maxwidth--;
2002e8c: 10 bf ff bd b 2002d80 <vprintk+0x15c> <== NOT EXECUTED
2002e90: aa 65 60 00 subx %l5, 0, %l5 <== NOT EXECUTED
case 'p': base = 16; sign = 0; break;
case 's':
{ int i, len;
char *s;
str = va_arg(ap, char *);
2002e94: e6 06 40 00 ld [ %i1 ], %l3
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
2002e98: a4 10 20 00 clr %l2
2002e9c: c2 4c c0 00 ldsb [ %l3 ], %g1
2002ea0: 80 a0 60 00 cmp %g1, 0
2002ea4: 02 80 00 07 be 2002ec0 <vprintk+0x29c> <== NEVER TAKEN
2002ea8: b2 06 60 04 add %i1, 4, %i1
2002eac: a4 04 a0 01 inc %l2
2002eb0: c2 4c c0 12 ldsb [ %l3 + %l2 ], %g1
2002eb4: 80 a0 60 00 cmp %g1, 0
2002eb8: 32 bf ff fe bne,a 2002eb0 <vprintk+0x28c>
2002ebc: a4 04 a0 01 inc %l2
;
/* leading spaces */
if ( !minus )
2002ec0: 80 a5 a0 00 cmp %l6, 0
2002ec4: 02 80 00 36 be 2002f9c <vprintk+0x378>
2002ec8: 80 a4 00 12 cmp %l0, %l2
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
/* no width option */
if (width == 0) {
2002ecc: 80 a4 20 00 cmp %l0, 0
2002ed0: 22 80 00 02 be,a 2002ed8 <vprintk+0x2b4>
2002ed4: aa 10 00 12 mov %l2, %l5
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
2002ed8: 80 a5 60 00 cmp %l5, 0
2002edc: 14 80 00 29 bg 2002f80 <vprintk+0x35c> <== ALWAYS TAKEN
2002ee0: 80 a5 a0 00 cmp %l6, 0
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
2002ee4: 22 bf ff 93 be,a 2002d30 <vprintk+0x10c>
2002ee8: b0 06 20 01 inc %i0
for ( i=len ; i<width ; i++ )
2002eec: 80 a5 40 12 cmp %l5, %l2
2002ef0: 24 bf ff 90 ble,a 2002d30 <vprintk+0x10c> <== NEVER TAKEN
2002ef4: b0 06 20 01 inc %i0 <== NOT EXECUTED
2002ef8: a0 10 00 12 mov %l2, %l0
BSP_output_char(' ');
2002efc: c2 05 00 00 ld [ %l4 ], %g1
2002f00: 9f c0 40 00 call %g1
2002f04: 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++ )
2002f08: a0 04 20 01 inc %l0
2002f0c: 80 a5 40 10 cmp %l5, %l0
2002f10: 34 bf ff fc bg,a 2002f00 <vprintk+0x2dc>
2002f14: c2 05 00 00 ld [ %l4 ], %g1
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002f18: 10 bf ff 86 b 2002d30 <vprintk+0x10c>
2002f1c: 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));
2002f20: d0 4e 60 03 ldsb [ %i1 + 3 ], %o0 <== NOT EXECUTED
2002f24: c2 05 00 00 ld [ %l4 ], %g1 <== NOT EXECUTED
2002f28: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002f2c: b2 06 60 04 add %i1, 4, %i1 <== NOT EXECUTED
)
{
char c, *str;
int lflag, base, sign, width, lead, minus;
for (; *fmt != '\0'; fmt++) {
2002f30: 10 bf ff 80 b 2002d30 <vprintk+0x10c> <== NOT EXECUTED
2002f34: b0 06 20 01 inc %i0 <== NOT EXECUTED
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
}
switch (c) {
2002f38: 82 10 20 00 clr %g1
2002f3c: 10 bf ff 8d b 2002d70 <vprintk+0x14c>
2002f40: a6 10 20 0a mov 0xa, %l3
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = 1;
fmt++;
2002f44: 88 01 20 01 inc %g4
2002f48: d0 09 00 00 ldub [ %g4 ], %o0
2002f4c: ac 10 20 01 mov 1, %l6
2002f50: 10 bf ff 51 b 2002c94 <vprintk+0x70>
2002f54: 87 2a 20 18 sll %o0, 0x18, %g3
lead = ' ';
if (*fmt == '%') {
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
2002f58: d0 0e 20 02 ldub [ %i0 + 2 ], %o0
2002f5c: 88 06 20 02 add %i0, 2, %g4
2002f60: ba 10 20 30 mov 0x30, %i5
2002f64: 10 bf ff 48 b 2002c84 <vprintk+0x60>
2002f68: 87 2a 20 18 sll %o0, 0x18, %g3
fmt++;
}
if ((c = *fmt) == 'l') {
lflag = 1;
c = *++fmt;
2002f6c: 10 bf ff 67 b 2002d08 <vprintk+0xe4>
2002f70: b0 01 20 01 add %g4, 1, %i0
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
BSP_output_char(*str);
2002f74: 91 3a 20 18 sra %o0, 0x18, %o0
2002f78: 9f c0 40 00 call %g1
2002f7c: a6 04 e0 01 inc %l3
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
2002f80: d0 0c c0 00 ldub [ %l3 ], %o0
2002f84: 91 2a 20 18 sll %o0, 0x18, %o0
2002f88: 80 a2 20 00 cmp %o0, 0
2002f8c: 32 bf ff fa bne,a 2002f74 <vprintk+0x350>
2002f90: c2 05 00 00 ld [ %l4 ], %g1
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
2002f94: 10 bf ff d4 b 2002ee4 <vprintk+0x2c0>
2002f98: 80 a5 a0 00 cmp %l6, 0
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
2002f9c: 04 bf ff cc ble 2002ecc <vprintk+0x2a8> <== ALWAYS TAKEN
2002fa0: a2 10 00 12 mov %l2, %l1
BSP_output_char(' ');
2002fa4: c2 05 00 00 ld [ %l4 ], %g1 <== NOT EXECUTED
2002fa8: 9f c0 40 00 call %g1 <== NOT EXECUTED
2002fac: 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++ )
2002fb0: a2 04 60 01 inc %l1 <== NOT EXECUTED
2002fb4: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
2002fb8: 26 bf ff fc bl,a 2002fa8 <vprintk+0x384> <== NOT EXECUTED
2002fbc: c2 05 00 00 ld [ %l4 ], %g1 <== NOT EXECUTED
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
2002fc0: 10 bf ff c7 b 2002edc <vprintk+0x2b8> <== NOT EXECUTED
2002fc4: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
break;
case 'c':
BSP_output_char(va_arg(ap, int));
break;
default:
BSP_output_char(c);
2002fc8: 82 10 20 00 clr %g1
2002fcc: 10 bf ff 69 b 2002d70 <vprintk+0x14c>
2002fd0: a6 10 20 10 mov 0x10, %l3
02014c6c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
2014c6c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2014c70: 03 00 80 59 sethi %hi(0x2016400), %g1
2014c74: c4 00 61 88 ld [ %g1 + 0x188 ], %g2 ! 2016588 <rtems_libio_number_iops>
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
2014c78: 92 10 00 19 mov %i1, %o1
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2014c7c: 80 a6 00 02 cmp %i0, %g2
2014c80: 1a 80 00 24 bcc 2014d10 <write+0xa4> <== NEVER TAKEN
2014c84: 94 10 00 1a mov %i2, %o2
iop = rtems_libio_iop( fd );
2014c88: 03 00 80 5c sethi %hi(0x2017000), %g1
2014c8c: c6 00 62 0c ld [ %g1 + 0x20c ], %g3 ! 201720c <rtems_libio_iops>
2014c90: 85 2e 20 02 sll %i0, 2, %g2
2014c94: 83 2e 20 04 sll %i0, 4, %g1
2014c98: 82 20 40 02 sub %g1, %g2, %g1
2014c9c: 82 00 40 18 add %g1, %i0, %g1
2014ca0: 83 28 60 02 sll %g1, 2, %g1
2014ca4: b0 00 c0 01 add %g3, %g1, %i0
rtems_libio_check_is_open( iop );
2014ca8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2014cac: 80 88 61 00 btst 0x100, %g1
2014cb0: 02 80 00 18 be 2014d10 <write+0xa4> <== NEVER TAKEN
2014cb4: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
2014cb8: 02 80 00 22 be 2014d40 <write+0xd4> <== NEVER TAKEN
2014cbc: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
2014cc0: 02 80 00 12 be 2014d08 <write+0x9c> <== NEVER TAKEN
2014cc4: 90 10 20 00 clr %o0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2014cc8: 80 88 60 04 btst 4, %g1
2014ccc: 02 80 00 11 be 2014d10 <write+0xa4> <== NEVER TAKEN
2014cd0: 01 00 00 00 nop
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
2014cd4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
2014cd8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2014cdc: 80 a0 60 00 cmp %g1, 0
2014ce0: 02 80 00 12 be 2014d28 <write+0xbc> <== NEVER TAKEN
2014ce4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->write_h)( iop, buffer, count );
2014ce8: 9f c0 40 00 call %g1
2014cec: 90 10 00 18 mov %i0, %o0
if ( rc > 0 )
2014cf0: 80 a2 20 00 cmp %o0, 0
2014cf4: 04 80 00 05 ble 2014d08 <write+0x9c> <== NEVER TAKEN
2014cf8: 01 00 00 00 nop
iop->offset += rc;
2014cfc: c2 06 20 08 ld [ %i0 + 8 ], %g1
2014d00: 82 00 40 08 add %g1, %o0, %g1
2014d04: c2 26 20 08 st %g1, [ %i0 + 8 ]
return rc;
}
2014d08: 81 c7 e0 08 ret
2014d0c: 91 e8 00 08 restore %g0, %o0, %o0
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
rtems_libio_check_count( count );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2014d10: 7f ff e0 4d call 200ce44 <__errno> <== NOT EXECUTED
2014d14: 01 00 00 00 nop <== NOT EXECUTED
2014d18: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9> <== NOT EXECUTED
2014d1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014d20: 10 bf ff fa b 2014d08 <write+0x9c> <== NOT EXECUTED
2014d24: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2014d28: 7f ff e0 47 call 200ce44 <__errno> <== NOT EXECUTED
2014d2c: 01 00 00 00 nop <== NOT EXECUTED
2014d30: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86> <== NOT EXECUTED
2014d34: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014d38: 10 bf ff f4 b 2014d08 <write+0x9c> <== NOT EXECUTED
2014d3c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
2014d40: 7f ff e0 41 call 200ce44 <__errno> <== NOT EXECUTED
2014d44: 01 00 00 00 nop <== NOT EXECUTED
2014d48: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2014d4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2014d50: 10 bf ff ee b 2014d08 <write+0x9c> <== NOT EXECUTED
2014d54: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED