020140fc : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 20140fc: 9d e3 bf 90 save %sp, -112, %sp /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 2014100: 40 00 06 78 call 2015ae0 2014104: f0 06 00 00 ld [ %i0 ], %i0 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 2014108: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1 201410c: 91 2a 20 10 sll %o0, 0x10, %o0 2014110: 91 32 20 10 srl %o0, 0x10, %o0 2014114: 80 a2 00 01 cmp %o0, %g1 2014118: 02 80 00 0a be 2014140 201411c: 80 a2 20 00 cmp %o0, 0 2014120: 22 80 00 09 be,a 2014144 <== NOT EXECUTED 2014124: f2 36 20 38 sth %i1, [ %i0 + 0x38 ] <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 2014128: 40 00 37 15 call 2021d7c <__errno> <== NOT EXECUTED 201412c: 01 00 00 00 nop <== NOT EXECUTED 2014130: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 2014134: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 2014138: 10 80 00 0a b 2014160 <== NOT EXECUTED 201413c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED #endif jnode->st_uid = owner; 2014140: f2 36 20 38 sth %i1, [ %i0 + 0x38 ] jnode->st_gid = group; 2014144: f4 36 20 3a sth %i2, [ %i0 + 0x3a ] IMFS_update_ctime( jnode ); 2014148: 90 07 bf f0 add %fp, -16, %o0 201414c: 7f ff bf 23 call 2003dd8 2014150: 92 10 20 00 clr %o1 2014154: c2 07 bf f0 ld [ %fp + -16 ], %g1 2014158: 84 10 20 00 clr %g2 201415c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] return 0; } 2014160: 81 c7 e0 08 ret 2014164: 91 e8 00 02 restore %g0, %g2, %o0 0200d768 : IMFS_jnode_types_t type, char *name, mode_t mode, IMFS_types_union *info ) { 200d768: 9d e3 bf 90 save %sp, -112, %sp struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; char *sym_name; if ( parent_loc != NULL ) 200d76c: a6 96 20 00 orcc %i0, 0, %l3 200d770: 02 80 00 03 be 200d77c 200d774: a4 10 20 00 clr %l2 parent = parent_loc->node_access; 200d778: e4 04 c0 00 ld [ %l3 ], %l2 /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 200d77c: 90 10 20 01 mov 1, %o0 200d780: 92 10 20 5c mov 0x5c, %o1 200d784: 7f ff d3 5c call 20024f4 200d788: b0 10 20 00 clr %i0 if ( !node ) 200d78c: a2 92 20 00 orcc %o0, 0, %l1 200d790: 02 80 00 53 be 200d8dc 200d794: 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 ); 200d798: 92 10 00 1a mov %i2, %o1 200d79c: 94 10 20 20 mov 0x20, %o2 /* * Fill in the basic information */ node->st_nlink = 1; node->type = type; 200d7a0: f2 24 60 48 st %i1, [ %l1 + 0x48 ] /* * Fill in the basic information */ node->st_nlink = 1; 200d7a4: c2 34 60 30 sth %g1, [ %l1 + 0x30 ] node->type = type; strncpy( node->name, name, IMFS_NAME_MAX ); 200d7a8: 40 00 08 56 call 200f900 200d7ac: 90 04 60 0c add %l1, 0xc, %o0 /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 200d7b0: 03 00 80 5f sethi %hi(0x2017c00), %g1 200d7b4: c2 00 61 b8 ld [ %g1 + 0x1b8 ], %g1 ! 2017db8 /* * Set the type specific information */ switch (type) { 200d7b8: b2 06 7f ff add %i1, -1, %i1 /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 200d7bc: c2 10 60 24 lduh [ %g1 + 0x24 ], %g1 /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 200d7c0: b0 10 00 11 mov %l1, %i0 /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 200d7c4: 82 2e c0 01 andn %i3, %g1, %g1 #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); 200d7c8: 7f ff f8 7a call 200b9b0 200d7cc: c2 34 60 2e sth %g1, [ %l1 + 0x2e ] node->st_gid = getegid(); 200d7d0: 7f ff f8 74 call 200b9a0 200d7d4: d0 34 60 38 sth %o0, [ %l1 + 0x38 ] /* * Now set all the times. */ gettimeofday( &tv, 0 ); 200d7d8: 92 10 20 00 clr %o1 node->st_mode = mode & ~rtems_filesystem_umask; #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); node->st_gid = getegid(); 200d7dc: d0 34 60 3a sth %o0, [ %l1 + 0x3a ] /* * Now set all the times. */ gettimeofday( &tv, 0 ); 200d7e0: 7f ff f8 78 call 200b9c0 200d7e4: 90 07 bf f0 add %fp, -16, %o0 node->stat_atime = (time_t) tv.tv_sec; 200d7e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * Set the type specific information */ switch (type) { 200d7ec: 80 a6 60 05 cmp %i1, 5 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; 200d7f0: c2 24 60 44 st %g1, [ %l1 + 0x44 ] * Now set all the times. */ gettimeofday( &tv, 0 ); node->stat_atime = (time_t) tv.tv_sec; 200d7f4: c2 24 60 3c st %g1, [ %l1 + 0x3c ] /* * Set the type specific information */ switch (type) { 200d7f8: 18 80 00 27 bgu 200d894 200d7fc: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 200d800: 83 2e 60 02 sll %i1, 2, %g1 200d804: 05 00 80 35 sethi %hi(0x200d400), %g2 200d808: 84 10 a3 50 or %g2, 0x350, %g2 ! 200d750 200d80c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200d810: 81 c0 40 00 jmp %g1 200d814: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200d818: 82 04 60 50 add %l1, 0x50, %g1 the_chain->permanent_null = NULL; 200d81c: c0 24 60 50 clr [ %l1 + 0x50 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200d820: c2 24 60 4c st %g1, [ %l1 + 0x4c ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200d824: 82 04 60 4c add %l1, 0x4c, %g1 200d828: 10 80 00 21 b 200d8ac 200d82c: c2 24 60 54 st %g1, [ %l1 + 0x54 ] case IMFS_DIRECTORY: Chain_Initialize_empty(&node->info.directory.Entries); break; case IMFS_HARD_LINK: node->info.hard_link.link_node = info->hard_link.link_node; 200d830: c2 07 00 00 ld [ %i4 ], %g1 200d834: 10 80 00 1e b 200d8ac 200d838: c2 24 60 4c st %g1, [ %l1 + 0x4c ] break; case IMFS_SYM_LINK: sym_name = calloc( 1, strlen( info->sym_link.name ) + 1 ); 200d83c: 40 00 07 c7 call 200f758 200d840: d0 07 00 00 ld [ %i4 ], %o0 200d844: 92 02 20 01 add %o0, 1, %o1 200d848: 7f ff d3 2b call 20024f4 200d84c: 90 10 20 01 mov 1, %o0 strcpy( sym_name, info->sym_link.name ); 200d850: d2 07 00 00 ld [ %i4 ], %o1 200d854: 40 00 07 a1 call 200f6d8 200d858: a0 10 00 08 mov %o0, %l0 node->info.sym_link.name = sym_name; 200d85c: 10 80 00 14 b 200d8ac 200d860: e0 24 60 4c st %l0, [ %l1 + 0x4c ] break; case IMFS_DEVICE: node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; 200d864: c2 07 20 04 ld [ %i4 + 4 ], %g1 strcpy( sym_name, info->sym_link.name ); node->info.sym_link.name = sym_name; break; case IMFS_DEVICE: node->info.device.major = info->device.major; 200d868: c4 07 00 00 ld [ %i4 ], %g2 node->info.device.minor = info->device.minor; 200d86c: c2 24 60 50 st %g1, [ %l1 + 0x50 ] strcpy( sym_name, info->sym_link.name ); node->info.sym_link.name = sym_name; break; case IMFS_DEVICE: node->info.device.major = info->device.major; 200d870: 10 80 00 0f b 200d8ac 200d874: c4 24 60 4c st %g2, [ %l1 + 0x4c ] node->info.device.minor = info->device.minor; break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 200d878: c0 24 60 4c clr [ %l1 + 0x4c ] <== NOT EXECUTED node->info.linearfile.direct = 0; 200d87c: c0 24 60 50 clr [ %l1 + 0x50 ] <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 200d880: c0 24 60 4c clr [ %l1 + 0x4c ] node->info.file.indirect = 0; 200d884: c0 24 60 50 clr [ %l1 + 0x50 ] node->info.file.doubly_indirect = 0; 200d888: c0 24 60 54 clr [ %l1 + 0x54 ] node->info.file.triply_indirect = 0; 200d88c: 10 80 00 08 b 200d8ac 200d890: c0 24 60 58 clr [ %l1 + 0x58 ] break; default: assert(0); 200d894: 11 00 80 5b sethi %hi(0x2016c00), %o0 <== NOT EXECUTED 200d898: 15 00 80 5b sethi %hi(0x2016c00), %o2 <== NOT EXECUTED 200d89c: 90 12 23 48 or %o0, 0x348, %o0 <== NOT EXECUTED 200d8a0: 94 12 a3 98 or %o2, 0x398, %o2 <== NOT EXECUTED 200d8a4: 7f ff d1 98 call 2001f04 <__assert> <== NOT EXECUTED 200d8a8: 92 10 20 77 mov 0x77, %o1 <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 200d8ac: 80 a4 a0 00 cmp %l2, 0 200d8b0: 02 80 00 0b be 200d8dc 200d8b4: 90 04 a0 4c add %l2, 0x4c, %o0 Chain_Append( &parent->info.directory.Entries, &node->Node ); 200d8b8: 7f ff e3 eb call 2006864 <_Chain_Append> 200d8bc: 92 10 00 11 mov %l1, %o1 node->Parent = parent; fs_info = parent_loc->mt_entry->fs_info; 200d8c0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 * If this node has a parent, then put it in that directory list. */ if ( parent ) { Chain_Append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 200d8c4: e4 24 60 08 st %l2, [ %l1 + 8 ] fs_info = parent_loc->mt_entry->fs_info; 200d8c8: c4 00 60 2c ld [ %g1 + 0x2c ], %g2 node->st_ino = ++fs_info->ino_count; 200d8cc: c2 00 80 00 ld [ %g2 ], %g1 200d8d0: 82 00 60 01 inc %g1 200d8d4: c2 20 80 00 st %g1, [ %g2 ] 200d8d8: c2 24 60 34 st %g1, [ %l1 + 0x34 ] } return node; } 200d8dc: 81 c7 e0 08 ret 200d8e0: 81 e8 00 00 restore 02003920 : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 2003920: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; Chain_Control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 2003924: 80 a6 20 00 cmp %i0, 0 2003928: 12 80 00 09 bne 200394c 200392c: 80 a6 60 00 cmp %i1, 0 2003930: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 2003934: 15 00 80 76 sethi %hi(0x201d800), %o2 <== NOT EXECUTED 2003938: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED 200393c: 94 12 a1 10 or %o2, 0x110, %o2 <== NOT EXECUTED 2003940: 40 00 01 c1 call 2004044 <__assert> <== NOT EXECUTED 2003944: 92 10 20 7f mov 0x7f, %o1 <== NOT EXECUTED assert( level >= 0 ); 2003948: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 200394c: 36 80 00 09 bge,a 2003970 2003950: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2003954: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 2003958: 15 00 80 76 sethi %hi(0x201d800), %o2 <== NOT EXECUTED 200395c: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED 2003960: 94 12 a1 20 or %o2, 0x120, %o2 <== NOT EXECUTED 2003964: 40 00 01 b8 call 2004044 <__assert> <== NOT EXECUTED 2003968: 92 10 20 81 mov 0x81, %o1 <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 200396c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 2003970: 80 a0 60 01 cmp %g1, 1 2003974: 02 80 00 07 be 2003990 2003978: 11 00 80 76 sethi %hi(0x201d800), %o0 200397c: 15 00 80 76 sethi %hi(0x201d800), %o2 <== NOT EXECUTED 2003980: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED 2003984: 94 12 a1 30 or %o2, 0x130, %o2 <== NOT EXECUTED 2003988: 40 00 01 af call 2004044 <__assert> <== NOT EXECUTED 200398c: 92 10 20 83 mov 0x83, %o1 <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 2003990: e0 06 20 4c ld [ %i0 + 0x4c ], %l0 the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 2003994: 03 00 80 76 sethi %hi(0x201d800), %g1 assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); 2003998: b0 06 20 50 add %i0, 0x50, %i0 the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 200399c: a8 10 61 58 or %g1, 0x158, %l4 20039a0: 27 00 80 7e sethi %hi(0x201f800), %l3 IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 20039a4: 10 80 00 13 b 20039f0 20039a8: a4 06 60 01 add %i1, 1, %l2 !_Chain_Is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 20039ac: a2 04 60 01 inc %l1 fprintf(stdout, "...." ); 20039b0: d2 00 60 08 ld [ %g1 + 8 ], %o1 20039b4: 40 00 3c 62 call 2012b3c 20039b8: 90 10 00 14 mov %l4, %o0 !_Chain_Is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 20039bc: 80 a4 40 19 cmp %l1, %i1 20039c0: 04 bf ff fb ble 20039ac 20039c4: c2 04 e2 30 ld [ %l3 + 0x230 ], %g1 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 20039c8: 7f ff ff 82 call 20037d0 20039cc: 90 10 00 10 mov %l0, %o0 if ( the_jnode->type == IMFS_DIRECTORY ) 20039d0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 20039d4: 80 a0 60 01 cmp %g1, 1 20039d8: 32 80 00 06 bne,a 20039f0 20039dc: e0 04 00 00 ld [ %l0 ], %l0 IMFS_dump_directory( the_jnode, level + 1 ); 20039e0: 90 10 00 10 mov %l0, %o0 20039e4: 7f ff ff cf call 2003920 20039e8: 92 10 00 12 mov %l2, %o1 the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); the_node = the_node->next ) { 20039ec: e0 04 00 00 ld [ %l0 ], %l0 assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); 20039f0: 80 a4 00 18 cmp %l0, %i0 20039f4: 12 bf ff f2 bne 20039bc 20039f8: a2 10 20 00 clr %l1 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 20039fc: 81 c7 e0 08 ret 2003a00: 81 e8 00 00 restore 0200ab5c : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200ab5c: 9d e3 bf 60 save %sp, -160, %sp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 200ab60: e0 06 80 00 ld [ %i2 ], %l0 int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200ab64: 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; 200ab68: a4 10 20 00 clr %l2 200ab6c: a2 10 20 01 mov 1, %l1 * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); 200ab70: a8 07 bf c3 add %fp, -61, %l4 200ab74: ac 07 bf f4 add %fp, -12, %l6 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200ab78: 10 80 00 69 b 200ad1c 200ab7c: 2b 00 80 5f sethi %hi(0x2017c00), %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 ); 200ab80: 92 10 00 14 mov %l4, %o1 200ab84: 40 00 01 d5 call 200b2d8 200ab88: 94 10 00 16 mov %l6, %o2 i += len; if ( !pathloc->node_access ) 200ab8c: c2 06 80 00 ld [ %i2 ], %g1 * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); 200ab90: a2 10 00 08 mov %o0, %l1 i += len; if ( !pathloc->node_access ) 200ab94: 80 a0 60 00 cmp %g1, 0 200ab98: 02 80 00 59 be 200acfc 200ab9c: c4 07 bf f4 ld [ %fp + -12 ], %g2 rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 200aba0: 80 a2 20 00 cmp %o0, 0 200aba4: 02 80 00 12 be 200abec 200aba8: a4 04 80 02 add %l2, %g2, %l2 if ( node->type == IMFS_DIRECTORY ) 200abac: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200abb0: 80 a0 60 01 cmp %g1, 1 200abb4: 12 80 00 0f bne 200abf0 200abb8: 80 a4 60 03 cmp %l1, 3 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 200abbc: 90 10 00 1a mov %i2, %o0 200abc0: 7f ff ff b6 call 200aa98 200abc4: 92 10 20 01 mov 1, %o1 200abc8: 80 a2 20 00 cmp %o0, 0 200abcc: 12 80 00 09 bne 200abf0 200abd0: 80 a4 60 03 cmp %l1, 3 rtems_set_errno_and_return_minus_one( EACCES ); 200abd4: 40 00 0e 03 call 200e3e0 <__errno> 200abd8: b0 10 3f ff mov -1, %i0 200abdc: 82 10 20 0d mov 0xd, %g1 200abe0: c2 22 00 00 st %g1, [ %o0 ] 200abe4: 81 c7 e0 08 ret 200abe8: 81 e8 00 00 restore node = pathloc->node_access; switch( type ) { 200abec: 80 a4 60 03 cmp %l1, 3 200abf0: 02 80 00 1b be 200ac5c 200abf4: e0 06 80 00 ld [ %i2 ], %l0 200abf8: 80 a4 60 04 cmp %l1, 4 200abfc: 02 80 00 44 be 200ad0c 200ac00: 80 a4 60 02 cmp %l1, 2 200ac04: 12 80 00 47 bne 200ad20 200ac08: 80 a4 60 00 cmp %l1, 0 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200ac0c: c2 05 61 b8 ld [ %l5 + 0x1b8 ], %g1 200ac10: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 200ac14: 80 a4 00 01 cmp %l0, %g1 200ac18: 02 bf ff da be 200ab80 200ac1c: 90 04 c0 12 add %l3, %l2, %o0 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 200ac20: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 200ac24: c2 02 60 18 ld [ %o1 + 0x18 ], %g1 200ac28: 80 a4 00 01 cmp %l0, %g1 200ac2c: 32 80 00 04 bne,a 200ac3c 200ac30: e0 04 20 08 ld [ %l0 + 8 ], %l0 */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 200ac34: 10 80 00 48 b 200ad54 200ac38: 92 02 60 08 add %o1, 8, %o1 *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 200ac3c: 80 a4 20 00 cmp %l0, 0 200ac40: 32 80 00 3a bne,a 200ad28 200ac44: e0 26 80 00 st %l0, [ %i2 ] rtems_set_errno_and_return_minus_one( ENOENT ); 200ac48: 40 00 0d e6 call 200e3e0 <__errno> 200ac4c: b0 10 3f ff mov -1, %i0 200ac50: e2 22 00 00 st %l1, [ %o0 ] 200ac54: 81 c7 e0 08 ret 200ac58: 81 e8 00 00 restore case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 200ac5c: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200ac60: 80 a0 60 03 cmp %g1, 3 200ac64: 12 80 00 0a bne 200ac8c 200ac68: 80 a0 60 04 cmp %g1, 4 IMFS_evaluate_hard_link( pathloc, 0 ); 200ac6c: 90 10 00 1a mov %i2, %o0 200ac70: 7f ff ff a2 call 200aaf8 200ac74: 92 10 20 00 clr %o1 node = pathloc->node_access; 200ac78: d0 06 80 00 ld [ %i2 ], %o0 if ( !node ) 200ac7c: 80 a2 20 00 cmp %o0, 0 200ac80: 32 80 00 0d bne,a 200acb4 200ac84: a0 10 00 08 mov %o0, %l0 200ac88: 30 80 00 0f b,a 200acc4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 200ac8c: 32 80 00 0b bne,a 200acb8 200ac90: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 result = IMFS_evaluate_sym_link( pathloc, 0 ); 200ac94: 90 10 00 1a mov %i2, %o0 200ac98: 40 00 00 50 call 200add8 200ac9c: 92 10 20 00 clr %o1 200aca0: b0 10 00 08 mov %o0, %i0 node = pathloc->node_access; if ( result == -1 ) 200aca4: 80 a2 3f ff cmp %o0, -1 200aca8: 02 bf ff cf be 200abe4 200acac: d0 06 80 00 ld [ %i2 ], %o0 } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 200acb0: a0 10 00 08 mov %o0, %l0 /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 200acb4: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200acb8: 80 a0 60 01 cmp %g1, 1 200acbc: 22 80 00 06 be,a 200acd4 200acc0: d2 04 20 58 ld [ %l0 + 0x58 ], %o1 rtems_set_errno_and_return_minus_one( ENOTDIR ); 200acc4: 40 00 0d c7 call 200e3e0 <__errno> 200acc8: b0 10 3f ff mov -1, %i0 200accc: 10 bf ff c5 b 200abe0 200acd0: 82 10 20 14 mov 0x14, %g1 /* * 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 ) { 200acd4: 80 a2 60 00 cmp %o1, 0 200acd8: 02 80 00 04 be 200ace8 200acdc: 90 10 00 10 mov %l0, %o0 newloc = node->info.directory.mt_fs->mt_fs_root; 200ace0: 10 80 00 1d b 200ad54 200ace4: 92 02 60 18 add %o1, 0x18, %o1 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 200ace8: 40 00 01 4e call 200b220 200acec: 92 10 00 14 mov %l4, %o1 if ( !node ) 200acf0: a0 92 20 00 orcc %o0, 0, %l0 200acf4: 32 80 00 0d bne,a 200ad28 200acf8: e0 26 80 00 st %l0, [ %i2 ] rtems_set_errno_and_return_minus_one( ENOENT ); 200acfc: 40 00 0d b9 call 200e3e0 <__errno> 200ad00: b0 10 3f ff mov -1, %i0 200ad04: 10 bf ff b7 b 200abe0 200ad08: 82 10 20 02 mov 2, %g1 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200ad0c: 40 00 0d b5 call 200e3e0 <__errno> 200ad10: b0 10 3f ff mov -1, %i0 200ad14: 10 bf ff b3 b 200abe0 200ad18: 82 10 20 5b mov 0x5b, %g1 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 200ad1c: 80 a4 60 00 cmp %l1, 0 200ad20: 22 80 00 06 be,a 200ad38 200ad24: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200ad28: 80 a4 60 04 cmp %l1, 4 200ad2c: 12 bf ff 95 bne 200ab80 200ad30: 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 ) { 200ad34: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 <== NOT EXECUTED 200ad38: 80 a0 60 01 cmp %g1, 1 200ad3c: 12 80 00 18 bne 200ad9c 200ad40: 01 00 00 00 nop if ( node->info.directory.mt_fs != NULL ) { 200ad44: d0 04 20 58 ld [ %l0 + 0x58 ], %o0 200ad48: 80 a2 20 00 cmp %o0, 0 200ad4c: 02 80 00 14 be 200ad9c 200ad50: 92 02 20 18 add %o0, 0x18, %o1 newloc = node->info.directory.mt_fs->mt_fs_root; 200ad54: a0 07 bf e4 add %fp, -28, %l0 200ad58: 94 10 20 10 mov 0x10, %o2 200ad5c: 40 00 0f 76 call 200eb34 200ad60: 90 10 00 10 mov %l0, %o0 *pathloc = newloc; 200ad64: 92 10 00 10 mov %l0, %o1 200ad68: 94 10 20 10 mov 0x10, %o2 200ad6c: 40 00 0f 72 call 200eb34 200ad70: 90 10 00 1a mov %i2, %o0 return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200ad74: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200ad78: d0 07 bf f4 ld [ %fp + -12 ], %o0 200ad7c: c2 00 40 00 ld [ %g1 ], %g1 200ad80: 90 24 80 08 sub %l2, %o0, %o0 200ad84: 92 10 00 19 mov %i1, %o1 200ad88: 90 04 c0 08 add %l3, %o0, %o0 200ad8c: 9f c0 40 00 call %g1 200ad90: 94 10 00 1a mov %i2, %o2 200ad94: 81 c7 e0 08 ret 200ad98: 91 e8 00 08 restore %g0, %o0, %o0 } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 200ad9c: 7f ff ff 26 call 200aa34 200ada0: 90 10 00 1a mov %i2, %o0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 200ada4: 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 ); 200ada8: b0 10 00 08 mov %o0, %i0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 200adac: 7f ff ff 3b call 200aa98 200adb0: 90 10 00 1a mov %i2, %o0 200adb4: 80 a2 20 00 cmp %o0, 0 200adb8: 12 80 00 06 bne 200add0 200adbc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); 200adc0: 40 00 0d 88 call 200e3e0 <__errno> 200adc4: b0 10 3f ff mov -1, %i0 ! ffffffff 200adc8: 82 10 20 0d mov 0xd, %g1 200adcc: c2 22 00 00 st %g1, [ %o0 ] return result; } 200add0: 81 c7 e0 08 ret 200add4: 81 e8 00 00 restore 0200af5c : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 200af5c: 9d e3 bf 60 save %sp, -160, %sp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 200af60: e0 06 40 00 ld [ %i1 ], %l0 int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 200af64: a8 10 00 18 mov %i0, %l4 /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 200af68: a6 10 20 00 clr %l3 * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 200af6c: aa 07 bf c3 add %fp, -61, %l5 200af70: ae 07 bf f4 add %fp, -12, %l7 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200af74: 2d 00 80 5f sethi %hi(0x2017c00), %l6 * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 200af78: 90 05 00 13 add %l4, %l3, %o0 200af7c: 92 10 00 15 mov %l5, %o1 200af80: 40 00 00 d6 call 200b2d8 200af84: 94 10 00 17 mov %l7, %o2 i += len; if ( !pathloc->node_access ) 200af88: c2 06 40 00 ld [ %i1 ], %g1 * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 200af8c: a2 10 00 08 mov %o0, %l1 i += len; if ( !pathloc->node_access ) 200af90: 80 a0 60 00 cmp %g1, 0 200af94: 02 80 00 82 be 200b19c 200af98: e4 07 bf f4 ld [ %fp + -12 ], %l2 /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 200af9c: 80 a2 20 00 cmp %o0, 0 200afa0: 22 80 00 10 be,a 200afe0 200afa4: a6 04 c0 12 add %l3, %l2, %l3 if ( node->type == IMFS_DIRECTORY ) 200afa8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200afac: 80 a0 60 01 cmp %g1, 1 200afb0: 32 80 00 0c bne,a 200afe0 200afb4: a6 04 c0 12 add %l3, %l2, %l3 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 200afb8: 90 10 00 19 mov %i1, %o0 200afbc: 7f ff fe b7 call 200aa98 200afc0: 92 10 20 01 mov 1, %o1 200afc4: 80 a2 20 00 cmp %o0, 0 200afc8: 32 80 00 06 bne,a 200afe0 200afcc: a6 04 c0 12 add %l3, %l2, %l3 rtems_set_errno_and_return_minus_one( EACCES ); 200afd0: 40 00 0d 04 call 200e3e0 <__errno> 200afd4: b0 10 3f ff mov -1, %i0 200afd8: 10 80 00 83 b 200b1e4 200afdc: 82 10 20 0d mov 0xd, %g1 node = pathloc->node_access; switch( type ) { 200afe0: 80 a4 60 02 cmp %l1, 2 200afe4: 02 80 00 0f be 200b020 200afe8: e0 06 40 00 ld [ %i1 ], %l0 200afec: 80 a4 60 02 cmp %l1, 2 200aff0: 18 80 00 07 bgu 200b00c 200aff4: 80 a4 60 03 cmp %l1, 3 200aff8: 80 a4 60 00 cmp %l1, 0 200affc: 02 80 00 56 be 200b154 200b000: 01 00 00 00 nop * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 200b004: 10 bf ff de b 200af7c 200b008: 90 05 00 13 add %l4, %l3, %o0 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; switch( type ) { 200b00c: 02 80 00 19 be 200b070 200b010: 80 a4 60 04 cmp %l1, 4 200b014: 32 bf ff da bne,a 200af7c 200b018: 90 05 00 13 add %l4, %l3, %o0 <== NOT EXECUTED 200b01c: 30 80 00 52 b,a 200b164 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200b020: c2 05 a1 b8 ld [ %l6 + 0x1b8 ], %g1 200b024: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 200b028: 80 a4 00 01 cmp %l0, %g1 200b02c: 02 bf ff d4 be 200af7c 200b030: 90 05 00 13 add %l4, %l3, %o0 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 200b034: d2 06 60 0c ld [ %i1 + 0xc ], %o1 200b038: c2 02 60 18 ld [ %o1 + 0x18 ], %g1 200b03c: 80 a4 00 01 cmp %l0, %g1 200b040: 32 80 00 04 bne,a 200b050 200b044: e0 04 20 08 ld [ %l0 + 8 ], %l0 if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 200b048: 10 80 00 2a b 200b0f0 200b04c: 92 02 60 08 add %o1, 8, %o1 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 200b050: 80 a4 20 00 cmp %l0, 0 200b054: 32 bf ff c9 bne,a 200af78 200b058: e0 26 40 00 st %l0, [ %i1 ] rtems_set_errno_and_return_minus_one( ENOENT ); 200b05c: 40 00 0c e1 call 200e3e0 <__errno> 200b060: b0 10 3f ff mov -1, %i0 200b064: e2 22 00 00 st %l1, [ %o0 ] 200b068: 81 c7 e0 08 ret 200b06c: 81 e8 00 00 restore pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 200b070: d0 04 20 48 ld [ %l0 + 0x48 ], %o0 200b074: 80 a2 20 03 cmp %o0, 3 200b078: 12 80 00 0a bne 200b0a0 200b07c: 80 a2 20 04 cmp %o0, 4 result = IMFS_evaluate_link( pathloc, 0 ); 200b080: 90 10 00 19 mov %i1, %o0 200b084: 7f ff ff 89 call 200aea8 200b088: 92 10 20 00 clr %o1 if ( result == -1 ) 200b08c: 80 a2 3f ff cmp %o0, -1 200b090: 12 80 00 0c bne 200b0c0 200b094: b0 10 00 08 mov %o0, %i0 200b098: 81 c7 e0 08 ret <== NOT EXECUTED 200b09c: 81 e8 00 00 restore <== NOT EXECUTED return -1; } else if ( node->type == IMFS_SYM_LINK ) { 200b0a0: 32 80 00 09 bne,a 200b0c4 200b0a4: d0 06 40 00 ld [ %i1 ], %o0 result = IMFS_evaluate_link( pathloc, 0 ); 200b0a8: 90 10 00 19 mov %i1, %o0 200b0ac: 7f ff ff 7f call 200aea8 200b0b0: 92 10 20 00 clr %o1 if ( result == -1 ) 200b0b4: 80 a2 3f ff cmp %o0, -1 200b0b8: 02 bf ff ec be 200b068 200b0bc: b0 10 00 08 mov %o0, %i0 return -1; } node = pathloc->node_access; 200b0c0: d0 06 40 00 ld [ %i1 ], %o0 if ( !node ) 200b0c4: 80 a2 20 00 cmp %o0, 0 200b0c8: 02 80 00 44 be 200b1d8 200b0cc: 01 00 00 00 nop /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 200b0d0: c2 02 20 48 ld [ %o0 + 0x48 ], %g1 200b0d4: 80 a0 60 01 cmp %g1, 1 200b0d8: 12 80 00 40 bne 200b1d8 200b0dc: 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 ) { 200b0e0: d2 02 20 58 ld [ %o0 + 0x58 ], %o1 200b0e4: 80 a2 60 00 cmp %o1, 0 200b0e8: 02 80 00 14 be 200b138 200b0ec: 92 02 60 18 add %o1, 0x18, %o1 newloc = node->info.directory.mt_fs->mt_fs_root; 200b0f0: a0 07 bf e4 add %fp, -28, %l0 200b0f4: 94 10 20 10 mov 0x10, %o2 200b0f8: 40 00 0e 8f call 200eb34 200b0fc: 90 10 00 10 mov %l0, %o0 *pathloc = newloc; 200b100: 92 10 00 10 mov %l0, %o1 200b104: 94 10 20 10 mov 0x10, %o2 200b108: 40 00 0e 8b call 200eb34 200b10c: 90 10 00 19 mov %i1, %o0 return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 200b110: c2 06 60 08 ld [ %i1 + 8 ], %g1 200b114: d0 07 bf f4 ld [ %fp + -12 ], %o0 200b118: c2 00 60 04 ld [ %g1 + 4 ], %g1 200b11c: 90 24 c0 08 sub %l3, %o0, %o0 200b120: 92 10 00 19 mov %i1, %o1 200b124: 90 05 00 08 add %l4, %o0, %o0 200b128: 9f c0 40 00 call %g1 200b12c: 94 10 00 1a mov %i2, %o2 200b130: 81 c7 e0 08 ret 200b134: 91 e8 00 08 restore %g0, %o0, %o0 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 200b138: 40 00 00 3a call 200b220 200b13c: 92 10 00 15 mov %l5, %o1 /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 200b140: a0 92 20 00 orcc %o0, 0, %l0 200b144: 02 80 00 0c be 200b174 200b148: c2 07 bf f4 ld [ %fp + -12 ], %g1 done = TRUE; else pathloc->node_access = node; 200b14c: 10 bf ff 8b b 200af78 200b150: e0 26 40 00 st %l0, [ %i1 ] break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 200b154: 40 00 0c a3 call 200e3e0 <__errno> 200b158: b0 10 3f ff mov -1, %i0 200b15c: 10 80 00 22 b 200b1e4 200b160: 82 10 20 11 mov 0x11, %g1 break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200b164: 40 00 0c 9f call 200e3e0 <__errno> 200b168: b0 10 3f ff mov -1, %i0 200b16c: 10 80 00 1e b 200b1e4 200b170: 82 10 20 5b mov 0x5b, %g1 case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 200b174: 84 05 00 13 add %l4, %l3, %g2 200b178: 82 24 c0 01 sub %l3, %g1, %g1 200b17c: 82 05 00 01 add %l4, %g1, %g1 200b180: 10 80 00 0b b 200b1ac 200b184: c2 26 80 00 st %g1, [ %i2 ] * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { if ( !IMFS_is_separator( path[ i ] ) ) 200b188: 80 a0 60 2f cmp %g1, 0x2f 200b18c: 02 80 00 08 be 200b1ac 200b190: 80 a0 60 5c cmp %g1, 0x5c 200b194: 22 80 00 07 be,a 200b1b0 200b198: c2 48 80 00 ldsb [ %g2 ], %g1 rtems_set_errno_and_return_minus_one( ENOENT ); 200b19c: 40 00 0c 91 call 200e3e0 <__errno> 200b1a0: b0 10 3f ff mov -1, %i0 200b1a4: 10 80 00 10 b 200b1e4 200b1a8: 82 10 20 02 mov 2, %g1 /* * 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++) { 200b1ac: c2 48 80 00 ldsb [ %g2 ], %g1 200b1b0: 80 a0 60 00 cmp %g1, 0 200b1b4: 12 bf ff f5 bne 200b188 200b1b8: 84 00 a0 01 inc %g2 /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 200b1bc: 7f ff fe 1e call 200aa34 200b1c0: 90 10 00 19 mov %i1, %o0 /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 200b1c4: c2 06 40 00 ld [ %i1 ], %g1 200b1c8: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 200b1cc: 80 a0 60 01 cmp %g1, 1 200b1d0: 02 80 00 08 be 200b1f0 200b1d4: b0 10 00 08 mov %o0, %i0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 200b1d8: 40 00 0c 82 call 200e3e0 <__errno> 200b1dc: b0 10 3f ff mov -1, %i0 200b1e0: 82 10 20 14 mov 0x14, %g1 200b1e4: c2 22 00 00 st %g1, [ %o0 ] 200b1e8: 81 c7 e0 08 ret 200b1ec: 81 e8 00 00 restore /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 200b1f0: 90 10 00 19 mov %i1, %o0 200b1f4: 7f ff fe 29 call 200aa98 200b1f8: 92 10 20 03 mov 3, %o1 200b1fc: 80 a2 20 00 cmp %o0, 0 200b200: 12 80 00 06 bne 200b218 200b204: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); 200b208: 40 00 0c 76 call 200e3e0 <__errno> 200b20c: b0 10 3f ff mov -1, %i0 ! ffffffff 200b210: 82 10 20 0d mov 0xd, %g1 200b214: c2 22 00 00 st %g1, [ %o0 ] return result; } 200b218: 81 c7 e0 08 ret 200b21c: 81 e8 00 00 restore 0200aaf8 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 200aaf8: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *jnode = node->node_access; 200aafc: e0 06 00 00 ld [ %i0 ], %l0 /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 200ab00: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200ab04: 80 a0 60 03 cmp %g1, 3 200ab08: 22 80 00 05 be,a 200ab1c 200ab0c: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 rtems_fatal_error_occurred (0xABCD0000); 200ab10: 7f ff ee 96 call 2006568 <== NOT EXECUTED 200ab14: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 200ab18: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 <== NOT EXECUTED IMFS_Set_handlers( node ); 200ab1c: 90 10 00 18 mov %i0, %o0 200ab20: 7f ff ff c5 call 200aa34 200ab24: c2 26 00 00 st %g1, [ %i0 ] /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 200ab28: 90 10 00 18 mov %i0, %o0 200ab2c: 92 10 00 19 mov %i1, %o1 200ab30: 7f ff ff da call 200aa98 200ab34: b0 10 20 00 clr %i0 200ab38: 80 a2 20 00 cmp %o0, 0 200ab3c: 12 80 00 06 bne 200ab54 200ab40: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); 200ab44: 40 00 0e 27 call 200e3e0 <__errno> <== NOT EXECUTED 200ab48: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200ab4c: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED 200ab50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return result; } 200ab54: 81 c7 e0 08 ret 200ab58: 81 e8 00 00 restore 0200add8 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 200add8: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *jnode = node->node_access; 200addc: e0 06 00 00 ld [ %i0 ], %l0 /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 200ade0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200ade4: 80 a0 60 04 cmp %g1, 4 200ade8: 02 80 00 04 be 200adf8 200adec: a2 10 00 18 mov %i0, %l1 rtems_fatal_error_occurred (0xABCD0000); 200adf0: 7f ff ed de call 2006568 <== NOT EXECUTED 200adf4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED if ( !jnode->Parent ) 200adf8: c2 04 20 08 ld [ %l0 + 8 ], %g1 200adfc: 80 a0 60 00 cmp %g1, 0 200ae00: 32 80 00 06 bne,a 200ae18 200ae04: c2 24 40 00 st %g1, [ %l1 ] rtems_fatal_error_occurred( 0xBAD00000 ); 200ae08: 7f ff ed d8 call 2006568 <== NOT EXECUTED 200ae0c: 11 2e b4 00 sethi %hi(0xbad00000), %o0 <== 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; 200ae10: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200ae14: c2 24 40 00 st %g1, [ %l1 ] <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 200ae18: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 200ae1c: c2 48 40 00 ldsb [ %g1 ], %g1 200ae20: 80 a0 60 2f cmp %g1, 0x2f 200ae24: 02 80 00 06 be 200ae3c 200ae28: 80 a0 60 5c cmp %g1, 0x5c 200ae2c: 02 80 00 04 be 200ae3c 200ae30: 80 a0 60 00 cmp %g1, 0 200ae34: 12 80 00 09 bne 200ae58 200ae38: 82 10 20 00 clr %g1 200ae3c: 03 00 80 5f sethi %hi(0x2017c00), %g1 200ae40: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 ! 2017db8 200ae44: 90 10 00 11 mov %l1, %o0 200ae48: 92 02 60 14 add %o1, 0x14, %o1 200ae4c: 40 00 0f 3a call 200eb34 200ae50: 94 10 20 10 mov 0x10, %o2 200ae54: 82 10 20 01 mov 1, %g1 /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 200ae58: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 200ae5c: 94 10 00 11 mov %l1, %o2 200ae60: 90 00 40 08 add %g1, %o0, %o0 200ae64: 7f ff ff 3e call 200ab5c 200ae68: 92 10 00 19 mov %i1, %o1 200ae6c: b0 10 00 08 mov %o0, %i0 &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 200ae70: 7f ff fe f1 call 200aa34 200ae74: 90 10 00 11 mov %l1, %o0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 200ae78: 90 10 00 11 mov %l1, %o0 200ae7c: 7f ff ff 07 call 200aa98 200ae80: 92 10 00 19 mov %i1, %o1 200ae84: 80 a2 20 00 cmp %o0, 0 200ae88: 12 80 00 06 bne 200aea0 200ae8c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); 200ae90: 40 00 0d 54 call 200e3e0 <__errno> <== NOT EXECUTED 200ae94: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200ae98: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED 200ae9c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return result; } 200aea0: 81 c7 e0 08 ret 200aea4: 81 e8 00 00 restore 0200d8e4 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 200d8e4: 9d e3 bf 90 save %sp, -112, %sp /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 200d8e8: 7f ff f8 32 call 200b9b0 200d8ec: f0 06 00 00 ld [ %i0 ], %i0 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 200d8f0: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1 200d8f4: 91 2a 20 10 sll %o0, 0x10, %o0 200d8f8: 91 32 20 10 srl %o0, 0x10, %o0 200d8fc: 80 a2 00 01 cmp %o0, %g1 200d900: 02 80 00 04 be 200d910 200d904: 80 a2 20 00 cmp %o0, 0 200d908: 12 80 00 08 bne 200d928 <== NOT EXECUTED 200d90c: 01 00 00 00 nop <== NOT EXECUTED #endif /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) 200d910: 83 2e 60 10 sll %i1, 0x10, %g1 200d914: 83 30 60 10 srl %g1, 0x10, %g1 200d918: 82 08 7e 00 and %g1, -512, %g1 200d91c: 80 a0 60 00 cmp %g1, 0 200d920: 22 80 00 08 be,a 200d940 200d924: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1 rtems_set_errno_and_return_minus_one( EPERM ); 200d928: 40 00 02 ae call 200e3e0 <__errno> 200d92c: 01 00 00 00 nop 200d930: 82 10 20 01 mov 1, %g1 ! 1 200d934: 84 10 3f ff mov -1, %g2 200d938: 10 80 00 0b b 200d964 200d93c: c2 22 00 00 st %g1, [ %o0 ] jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; IMFS_update_ctime( jnode ); 200d940: 90 07 bf f0 add %fp, -16, %o0 */ 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; 200d944: 82 08 7e 00 and %g1, -512, %g1 200d948: 82 10 40 19 or %g1, %i1, %g1 IMFS_update_ctime( jnode ); 200d94c: 92 10 20 00 clr %o1 200d950: 7f ff f8 1c call 200b9c0 200d954: c2 36 20 2e sth %g1, [ %i0 + 0x2e ] 200d958: c2 07 bf f0 ld [ %fp + -16 ], %g1 200d95c: 84 10 20 00 clr %g2 200d960: c2 26 20 44 st %g1, [ %i0 + 0x44 ] return 0; } 200d964: 81 c7 e0 08 ret 200d968: 91 e8 00 02 restore %g0, %g2, %o0 0200b220 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 200b220: 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 ); 200b224: 80 a6 20 00 cmp %i0, 0 200b228: 12 80 00 09 bne 200b24c 200b22c: 80 a6 60 00 cmp %i1, 0 200b230: 11 00 80 5b sethi %hi(0x2016c00), %o0 <== NOT EXECUTED 200b234: 15 00 80 5b sethi %hi(0x2016c00), %o2 <== NOT EXECUTED 200b238: 90 12 21 c8 or %o0, 0x1c8, %o0 <== NOT EXECUTED 200b23c: 94 12 a2 18 or %o2, 0x218, %o2 <== NOT EXECUTED 200b240: 7f ff db 31 call 2001f04 <__assert> <== NOT EXECUTED 200b244: 92 10 20 2a mov 0x2a, %o1 <== NOT EXECUTED if ( !name ) 200b248: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 200b24c: 22 80 00 12 be,a 200b294 200b250: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; assert( name ); if ( !directory ) 200b254: 80 a6 20 00 cmp %i0, 0 200b258: 02 80 00 0f be 200b294 200b25c: 90 10 00 19 mov %i1, %o0 /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 200b260: 13 00 80 5f sethi %hi(0x2017c00), %o1 200b264: 40 00 10 ed call 200f618 200b268: 92 12 61 38 or %o1, 0x138, %o1 ! 2017d38 200b26c: 80 a2 20 00 cmp %o0, 0 200b270: 02 80 00 09 be 200b294 200b274: 90 10 00 19 mov %i1, %o0 return directory; if ( !strcmp( name, dotdotname ) ) 200b278: 13 00 80 5f sethi %hi(0x2017c00), %o1 200b27c: 40 00 10 e7 call 200f618 200b280: 92 12 61 40 or %o1, 0x140, %o1 ! 2017d40 200b284: 80 a2 20 00 cmp %o0, 0 200b288: 32 80 00 05 bne,a 200b29c 200b28c: e0 06 20 4c ld [ %i0 + 0x4c ], %l0 return directory->Parent; 200b290: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 200b294: 81 c7 e0 08 ret <== NOT EXECUTED 200b298: 81 e8 00 00 restore <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); 200b29c: 10 80 00 09 b 200b2c0 200b2a0: b0 06 20 50 add %i0, 0x50, %i0 the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 200b2a4: 40 00 10 dd call 200f618 200b2a8: 90 10 00 19 mov %i1, %o0 200b2ac: 80 a2 20 00 cmp %o0, 0 200b2b0: 32 80 00 04 bne,a 200b2c0 200b2b4: e0 04 00 00 ld [ %l0 ], %l0 200b2b8: 81 c7 e0 08 ret 200b2bc: 91 e8 00 10 restore %g0, %l0, %o0 return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); 200b2c0: 80 a4 00 18 cmp %l0, %i0 200b2c4: 12 bf ff f8 bne 200b2a4 200b2c8: 92 04 20 0c add %l0, 0xc, %o1 200b2cc: b0 10 20 00 clr %i0 if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 200b2d0: 81 c7 e0 08 ret 200b2d4: 81 e8 00 00 restore 02014b08 : ((IMFS_jnode_t *)( Chain_Head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 2014b08: 9d e3 bf 88 save %sp, -120, %sp * Traverse tree that starts at the mt_fs_root and deallocate memory * associated memory space */ jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access; loc = temp_mt_entry->mt_fs_root; 2014b0c: 94 10 20 10 mov 0x10, %o2 2014b10: 90 07 bf e8 add %fp, -24, %o0 /* * Traverse tree that starts at the mt_fs_root and deallocate memory * associated memory space */ jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access; 2014b14: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 2014b18: a2 10 00 08 mov %o0, %l1 * Traverse tree that starts at the mt_fs_root and deallocate memory * associated memory space */ jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access; loc = temp_mt_entry->mt_fs_root; 2014b1c: 40 00 3b 4c call 202384c 2014b20: 92 06 20 18 add %i0, 0x18, %o1 /* * Set this to null to indicate that it is being unmounted. */ temp_mt_entry->mt_fs_root.node_access = NULL; 2014b24: c0 26 20 18 clr [ %i0 + 0x18 ] do { next = jnode->Parent; loc.node_access = (void *)jnode; 2014b28: e0 27 bf e8 st %l0, [ %fp + -24 ] */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 2014b2c: f0 04 20 08 ld [ %l0 + 8 ], %i0 loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 2014b30: 7f ff fd f9 call 2014314 2014b34: 90 10 00 11 mov %l1, %o0 if ( jnode->type != IMFS_DIRECTORY ) { 2014b38: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2014b3c: 80 a0 60 01 cmp %g1, 1 2014b40: 12 80 00 06 bne 2014b58 2014b44: 84 04 20 50 add %l0, 0x50, %g2 result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 2014b48: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 2014b4c: 80 a0 40 02 cmp %g1, %g2 2014b50: 12 80 00 08 bne 2014b70 2014b54: 80 a4 20 00 cmp %l0, 0 result = IMFS_unlink( &loc ); 2014b58: 7f ff bb 49 call 200387c 2014b5c: 90 10 00 11 mov %l1, %o0 if (result != 0) 2014b60: 80 a2 20 00 cmp %o0, 0 2014b64: 12 80 00 13 bne 2014bb0 2014b68: a0 10 00 18 mov %i0, %l0 return -1; jnode = next; } if ( jnode != NULL ) { 2014b6c: 80 a4 20 00 cmp %l0, 0 2014b70: 02 80 00 12 be 2014bb8 2014b74: 01 00 00 00 nop if ( jnode->type == IMFS_DIRECTORY ) { 2014b78: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2014b7c: 80 a0 60 01 cmp %g1, 1 2014b80: 32 bf ff eb bne,a 2014b2c 2014b84: e0 27 bf e8 st %l0, [ %fp + -24 ] <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 2014b88: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2014b8c: 82 04 20 50 add %l0, 0x50, %g1 2014b90: 80 a0 80 01 cmp %g2, %g1 2014b94: 22 bf ff e6 be,a 2014b2c 2014b98: e0 27 bf e8 st %l0, [ %fp + -24 ] jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); 2014b9c: 80 a0 a0 00 cmp %g2, 0 2014ba0: 02 80 00 06 be 2014bb8 2014ba4: a0 10 00 02 mov %g2, %l0 temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; loc.node_access = (void *)jnode; 2014ba8: 10 bf ff e1 b 2014b2c 2014bac: e0 27 bf e8 st %l0, [ %fp + -24 ] jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); 2014bb0: 81 c7 e0 08 ret <== NOT EXECUTED 2014bb4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED } } } while (jnode != NULL); return 0; } 2014bb8: 81 c7 e0 08 ret 2014bbc: 91 e8 20 00 restore %g0, 0, %o0 0200b3bc : rtems_filesystem_mount_table_entry_t *temp_mt_entry, rtems_filesystem_operations_table *op_table, rtems_filesystem_file_handlers_r *memfile_handlers, rtems_filesystem_file_handlers_r *directory_handlers ) { 200b3bc: 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, 200b3c0: 03 00 80 5d sethi %hi(0x2017400), %g1 200b3c4: c4 00 63 a0 ld [ %g1 + 0x3a0 ], %g2 ! 20177a0 200b3c8: 86 10 20 00 clr %g3 200b3cc: 10 80 00 05 b 200b3e0 200b3d0: 82 10 20 10 mov 0x10, %g1 * 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) { 200b3d4: 22 80 00 02 be,a 200b3dc 200b3d8: 86 10 20 01 mov 1, %g3 /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 200b3dc: 83 28 60 01 sll %g1, 1, %g1 int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 200b3e0: 80 a0 e0 00 cmp %g3, 0 200b3e4: 32 80 00 07 bne,a 200b400 200b3e8: 03 00 80 61 sethi %hi(0x2018400), %g1 200b3ec: 80 a0 62 00 cmp %g1, 0x200 200b3f0: 04 bf ff f9 ble 200b3d4 200b3f4: 80 a0 40 02 cmp %g1, %g2 bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { is_valid = TRUE; } } *dest_bytes_per_block = ((is_valid) 200b3f8: 84 10 20 80 mov 0x80, %g2 <== NOT EXECUTED 200b3fc: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED * 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( 200b400: 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) 200b404: c4 20 63 18 st %g2, [ %g1 + 0x318 ] * 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( 200b408: 92 10 20 01 mov 1, %o1 200b40c: 90 10 20 00 clr %o0 200b410: 15 00 80 5a sethi %hi(0x2016800), %o2 200b414: 17 00 00 10 sethi %hi(0x4000), %o3 200b418: 94 12 a3 38 or %o2, 0x338, %o2 200b41c: 40 00 08 d3 call 200d768 200b420: 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; 200b424: 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( 200b428: 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; 200b42c: f2 26 20 20 st %i1, [ %i0 + 0x20 ] "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 200b430: 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; 200b434: 13 00 80 60 sethi %hi(0x2018000), %o1 200b438: 90 06 20 30 add %i0, 0x30, %o0 200b43c: 40 00 0d be call 200eb34 200b440: 92 12 60 b0 or %o1, 0xb0, %o1 /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 200b444: 90 10 20 01 mov 1, %o0 200b448: 7f ff dc 2b call 20024f4 200b44c: 92 10 20 0c mov 0xc, %o1 if ( !fs_info ){ 200b450: 80 a2 20 00 cmp %o0, 0 200b454: 12 80 00 0a bne 200b47c 200b458: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 free(temp_mt_entry->mt_fs_root.node_access); 200b45c: 7f ff db 68 call 20021fc <== NOT EXECUTED 200b460: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 200b464: 40 00 0b df call 200e3e0 <__errno> <== NOT EXECUTED 200b468: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200b46c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 200b470: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b474: 81 c7 e0 08 ret <== NOT EXECUTED 200b478: 81 e8 00 00 restore <== NOT EXECUTED /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 200b47c: 82 10 20 01 mov 1, %g1 200b480: 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; 200b484: 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; 200b488: f6 22 20 08 st %i3, [ %o0 + 8 ] jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 200b48c: 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; 200b490: 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; } 200b494: 81 c7 e0 08 ret 200b498: 91 e8 20 00 restore %g0, 0, %o0 02003610 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 2003610: 9d e3 bf 58 save %sp, -168, %sp /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 2003614: c2 06 00 00 ld [ %i0 ], %g1 2003618: c2 27 bf dc st %g1, [ %fp + -36 ] if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 200361c: c2 10 60 30 lduh [ %g1 + 0x30 ], %g1 2003620: 80 a0 60 07 cmp %g1, 7 2003624: 08 80 00 06 bleu 200363c 2003628: 90 10 00 1a mov %i2, %o0 rtems_set_errno_and_return_minus_one( EMLINK ); 200362c: 40 00 79 d4 call 2021d7c <__errno> 2003630: 01 00 00 00 nop 2003634: 10 80 00 13 b 2003680 2003638: 82 10 20 1f mov 0x1f, %g1 ! 1f /* * Remove any separators at the end of the string. */ IMFS_get_token( token, new_name, &i ); 200363c: a0 07 bf bb add %fp, -69, %l0 2003640: 94 07 bf f4 add %fp, -12, %o2 2003644: 7f ff ff 78 call 2003424 2003648: 92 10 00 10 mov %l0, %o1 /* * Create a new link node. */ new_node = IMFS_create_node( 200364c: 90 10 00 19 mov %i1, %o0 2003650: 94 10 00 10 mov %l0, %o2 2003654: 92 10 20 03 mov 3, %o1 2003658: 17 00 00 28 sethi %hi(0xa000), %o3 200365c: 98 07 bf dc add %fp, -36, %o4 2003660: 40 00 42 c8 call 2014180 2003664: 96 12 e1 ff or %o3, 0x1ff, %o3 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 2003668: 80 a2 20 00 cmp %o0, 0 200366c: 12 80 00 08 bne 200368c 2003670: c4 07 bf dc ld [ %fp + -36 ], %g2 rtems_set_errno_and_return_minus_one( ENOMEM ); 2003674: 40 00 79 c2 call 2021d7c <__errno> <== NOT EXECUTED 2003678: 01 00 00 00 nop <== NOT EXECUTED 200367c: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 2003680: c2 22 00 00 st %g1, [ %o0 ] 2003684: 81 c7 e0 08 ret 2003688: 91 e8 3f ff restore %g0, -1, %o0 /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; IMFS_update_ctime( info.hard_link.link_node ); 200368c: 90 07 bf ec add %fp, -20, %o0 /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 2003690: c2 10 a0 30 lduh [ %g2 + 0x30 ], %g1 IMFS_update_ctime( info.hard_link.link_node ); 2003694: 92 10 20 00 clr %o1 /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 2003698: 82 00 60 01 inc %g1 IMFS_update_ctime( info.hard_link.link_node ); 200369c: 40 00 01 cf call 2003dd8 20036a0: c2 30 a0 30 sth %g1, [ %g2 + 0x30 ] 20036a4: c4 07 bf ec ld [ %fp + -20 ], %g2 20036a8: c2 07 bf dc ld [ %fp + -36 ], %g1 20036ac: c4 20 60 44 st %g2, [ %g1 + 0x44 ] return 0; } 20036b0: 81 c7 e0 08 ret 20036b4: 91 e8 20 00 restore %g0, 0, %o0 020191cc : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 20191cc: 9d e3 bf 98 save %sp, -104, %sp block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 20191d0: 80 a6 20 00 cmp %i0, 0 20191d4: 32 80 00 09 bne,a 20191f8 20191d8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20191dc: 92 10 21 69 mov 0x169, %o1 <== NOT EXECUTED 20191e0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20191e4: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20191e8: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20191ec: 7f ff aa 40 call 2003aec <__assert> <== NOT EXECUTED 20191f0: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED 20191f4: 30 80 00 0d b,a 2019228 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 20191f8: 80 a0 60 05 cmp %g1, 5 20191fc: 02 80 00 07 be 2019218 2019200: 11 00 80 d1 sethi %hi(0x2034400), %o0 2019204: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019208: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 201920c: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 2019210: 7f ff aa 37 call 2003aec <__assert> <== NOT EXECUTED 2019214: 92 10 21 6d mov 0x16d, %o1 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 2019218: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201921c: 80 a0 60 05 cmp %g1, 5 2019220: 02 80 00 08 be 2019240 2019224: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EIO ); 2019228: 40 00 22 d5 call 2021d7c <__errno> <== NOT EXECUTED 201922c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2019230: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 2019234: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019238: 81 c7 e0 08 ret 201923c: 81 e8 00 00 restore block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 2019240: 92 10 00 19 mov %i1, %o1 2019244: 7f ff fe 68 call 2018be4 2019248: 94 10 20 01 mov 1, %o2 if ( *block_entry_ptr ) 201924c: c2 02 00 00 ld [ %o0 ], %g1 assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 2019250: b2 10 00 08 mov %o0, %i1 if ( *block_entry_ptr ) 2019254: 80 a0 60 00 cmp %g1, 0 2019258: 12 bf ff f8 bne 2019238 201925c: b0 10 20 00 clr %i0 #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 2019260: 7f ff fe 54 call 2018bb0 2019264: b0 10 20 01 mov 1, %i0 if ( !memory ) 2019268: 80 a2 20 00 cmp %o0, 0 201926c: 02 80 00 04 be 201927c 2019270: 01 00 00 00 nop return 1; *block_entry_ptr = memory; 2019274: d0 26 40 00 st %o0, [ %i1 ] 2019278: b0 10 20 00 clr %i0 return 0; } 201927c: 81 c7 e0 08 ret 2019280: 81 e8 00 00 restore 02019284 : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 2019284: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 2019288: 80 a6 20 00 cmp %i0, 0 201928c: 32 80 00 09 bne,a 20192b0 2019290: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2019294: 92 10 21 31 mov 0x131, %o1 <== NOT EXECUTED 2019298: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 201929c: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20192a0: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20192a4: 7f ff aa 12 call 2003aec <__assert> <== NOT EXECUTED 20192a8: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED 20192ac: 30 80 00 0d b,a 20192e0 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 20192b0: 80 a0 60 05 cmp %g1, 5 20192b4: 02 80 00 07 be 20192d0 20192b8: 11 00 80 d1 sethi %hi(0x2034400), %o0 20192bc: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20192c0: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20192c4: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 20192c8: 7f ff aa 09 call 2003aec <__assert> <== NOT EXECUTED 20192cc: 92 10 21 35 mov 0x135, %o1 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 20192d0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20192d4: 80 a0 60 05 cmp %g1, 5 20192d8: 22 80 00 06 be,a 20192f0 20192dc: 03 00 80 e3 sethi %hi(0x2038c00), %g1 rtems_set_errno_and_return_minus_one( EIO ); 20192e0: 40 00 22 a7 call 2021d7c <__errno> <== NOT EXECUTED 20192e4: 01 00 00 00 nop <== NOT EXECUTED 20192e8: 10 80 00 31 b 20193ac <== NOT EXECUTED 20192ec: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 20192f0: e2 00 60 dc ld [ %g1 + 0xdc ], %l1 20192f4: a1 34 60 02 srl %l1, 2, %l0 20192f8: 92 10 00 10 mov %l0, %o1 20192fc: 40 00 5e e2 call 2030e84 <.umul> 2019300: 90 04 20 01 add %l0, 1, %o0 2019304: 92 10 00 10 mov %l0, %o1 2019308: 40 00 5e df call 2030e84 <.umul> 201930c: 90 02 20 01 inc %o0 2019310: 92 10 00 11 mov %l1, %o1 2019314: 40 00 5e dc call 2030e84 <.umul> 2019318: 90 02 3f ff add %o0, -1, %o0 201931c: 80 a6 40 08 cmp %i1, %o0 2019320: 2a 80 00 06 bcs,a 2019338 2019324: e0 06 20 4c ld [ %i0 + 0x4c ], %l0 rtems_set_errno_and_return_minus_one( EINVAL ); 2019328: 40 00 22 95 call 2021d7c <__errno> <== NOT EXECUTED 201932c: 01 00 00 00 nop <== NOT EXECUTED 2019330: 10 80 00 1f b 20193ac <== NOT EXECUTED 2019334: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 2019338: 80 a6 40 10 cmp %i1, %l0 201933c: 04 80 00 24 ble 20193cc 2019340: 82 10 20 00 clr %g1 /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019344: 92 10 00 11 mov %l1, %o1 2019348: 40 00 5f 0b call 2030f74 <.div> 201934c: 90 10 00 19 mov %i1, %o0 old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019350: 92 10 00 11 mov %l1, %o1 /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019354: a4 10 00 08 mov %o0, %l2 old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019358: 40 00 5f 07 call 2030f74 <.div> 201935c: 90 10 00 10 mov %l0, %o0 2019360: a0 10 00 08 mov %o0, %l0 2019364: 10 80 00 15 b 20193b8 2019368: a2 10 00 08 mov %o0, %l1 /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { 201936c: 7f ff ff 98 call 20191cc 2019370: 90 10 00 18 mov %i0, %o0 2019374: 80 a2 20 00 cmp %o0, 0 2019378: 22 80 00 10 be,a 20193b8 201937c: a0 04 20 01 inc %l0 for ( ; block>=old_blocks ; block-- ) { 2019380: 10 80 00 06 b 2019398 <== NOT EXECUTED 2019384: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); 2019388: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 201938c: 7f ff fe c6 call 2018ea4 <== NOT EXECUTED 2019390: a0 04 3f ff add %l0, -1, %l0 <== NOT EXECUTED * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { for ( ; block>=old_blocks ; block-- ) { 2019394: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED 2019398: 1a bf ff fc bcc 2019388 <== NOT EXECUTED 201939c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 20193a0: 40 00 22 77 call 2021d7c <__errno> <== NOT EXECUTED 20193a4: 01 00 00 00 nop <== NOT EXECUTED 20193a8: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 20193ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20193b0: 10 80 00 07 b 20193cc <== NOT EXECUTED 20193b4: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 20193b8: 80 a4 00 12 cmp %l0, %l2 20193bc: 08 bf ff ec bleu 201936c 20193c0: 92 10 00 10 mov %l0, %o1 /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 20193c4: f2 26 20 4c st %i1, [ %i0 + 0x4c ] 20193c8: 82 10 20 00 clr %g1 return 0; } 20193cc: 81 c7 e0 08 ret 20193d0: 91 e8 00 01 restore %g0, %g1, %o0 02018be4 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 2018be4: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 2018be8: 80 a6 20 00 cmp %i0, 0 2018bec: 32 80 00 0a bne,a 2018c14 2018bf0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2018bf4: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2018bf8: 92 10 23 86 mov 0x386, %o1 <== NOT EXECUTED 2018bfc: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2018c00: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2018c04: 7f ff ab ba call 2003aec <__assert> <== NOT EXECUTED 2018c08: 94 12 a1 b8 or %o2, 0x1b8, %o2 ! 20345b8 <_POSIX_Threads_Default_attributes+0x88> <== NOT EXECUTED 2018c0c: 81 c7 e0 08 ret <== NOT EXECUTED 2018c10: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 2018c14: 80 a0 60 05 cmp %g1, 5 2018c18: 02 80 00 07 be 2018c34 2018c1c: 11 00 80 d1 sethi %hi(0x2034400), %o0 2018c20: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2018c24: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2018c28: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 2018c2c: 7f ff ab b0 call 2003aec <__assert> <== NOT EXECUTED 2018c30: 92 10 23 8a mov 0x38a, %o1 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 2018c34: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2018c38: 80 a0 60 05 cmp %g1, 5 2018c3c: 32 bf ff f4 bne,a 2018c0c 2018c40: b0 10 20 00 clr %i0 <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 2018c44: 03 00 80 e3 sethi %hi(0x2038c00), %g1 2018c48: c2 00 60 dc ld [ %g1 + 0xdc ], %g1 ! 2038cdc 2018c4c: a3 30 60 02 srl %g1, 2, %l1 2018c50: 82 04 7f ff add %l1, -1, %g1 2018c54: 80 a6 40 01 cmp %i1, %g1 2018c58: 18 80 00 15 bgu 2018cac 2018c5c: 90 04 60 01 add %l1, 1, %o0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; if ( malloc_it ) { 2018c60: 80 a6 a0 00 cmp %i2, 0 2018c64: 02 80 00 0e be 2018c9c 2018c68: e0 06 20 50 ld [ %i0 + 0x50 ], %l0 if ( !p ) { 2018c6c: 80 a4 20 00 cmp %l0, 0 2018c70: 32 80 00 09 bne,a 2018c94 2018c74: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 p = memfile_alloc_block(); 2018c78: 7f ff ff ce call 2018bb0 2018c7c: 01 00 00 00 nop if ( !p ) 2018c80: 80 a2 20 00 cmp %o0, 0 2018c84: 22 bf ff e2 be,a 2018c0c 2018c88: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; info->indirect = p; 2018c8c: d0 26 20 50 st %o0, [ %i0 + 0x50 ] } return &info->indirect[ my_block ]; 2018c90: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 2018c94: 10 80 00 7f b 2018e90 2018c98: 83 2e 60 02 sll %i1, 2, %g1 } if ( !p ) return 0; return &info->indirect[ my_block ]; 2018c9c: 83 2e 60 02 sll %i1, 2, %g1 info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 2018ca0: 80 a4 20 00 cmp %l0, 0 return 0; return &info->indirect[ my_block ]; 2018ca4: 10 80 00 32 b 2018d6c 2018ca8: b0 04 00 01 add %l0, %g1, %i0 /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 2018cac: 40 00 60 76 call 2030e84 <.umul> <== NOT EXECUTED 2018cb0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018cb4: 82 02 3f ff add %o0, -1, %g1 <== NOT EXECUTED 2018cb8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 2018cbc: 18 80 00 30 bgu 2018d7c <== NOT EXECUTED 2018cc0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 2018cc4: a0 26 40 11 sub %i1, %l1, %l0 <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 2018cc8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018ccc: 40 00 61 54 call 203121c <.urem> <== NOT EXECUTED 2018cd0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 2018cd4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 2018cd8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 2018cdc: 40 00 60 a4 call 2030f6c <.udiv> <== NOT EXECUTED 2018ce0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { 2018ce4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED #endif my_block -= FIRST_DOUBLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 2018ce8: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { 2018cec: 02 80 00 18 be 2018d4c <== NOT EXECUTED 2018cf0: e0 06 20 54 ld [ %i0 + 0x54 ], %l0 <== NOT EXECUTED if ( !p ) { 2018cf4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2018cf8: 32 80 00 09 bne,a 2018d1c <== NOT EXECUTED 2018cfc: a3 2c 60 02 sll %l1, 2, %l1 <== NOT EXECUTED p = memfile_alloc_block(); 2018d00: 7f ff ff ac call 2018bb0 <== NOT EXECUTED 2018d04: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) 2018d08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018d0c: 02 80 00 63 be 2018e98 <== NOT EXECUTED 2018d10: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED return 0; info->doubly_indirect = p; 2018d14: d0 26 20 54 st %o0, [ %i0 + 0x54 ] <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 2018d18: a3 2c 60 02 sll %l1, 2, %l1 <== NOT EXECUTED 2018d1c: c2 04 00 11 ld [ %l0 + %l1 ], %g1 <== NOT EXECUTED if ( !p1 ) { 2018d20: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 2018d24: 12 80 00 4f bne 2018e60 <== NOT EXECUTED 2018d28: 83 2c a0 02 sll %l2, 2, %g1 <== NOT EXECUTED p1 = memfile_alloc_block(); 2018d2c: 7f ff ff a1 call 2018bb0 <== NOT EXECUTED 2018d30: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) 2018d34: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 2018d38: 02 80 00 58 be 2018e98 <== NOT EXECUTED 2018d3c: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 2018d40: c2 24 00 11 st %g1, [ %l0 + %l1 ] <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 2018d44: 10 80 00 47 b 2018e60 <== NOT EXECUTED 2018d48: 83 2c a0 02 sll %l2, 2, %g1 <== NOT EXECUTED } if ( !p ) 2018d4c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2018d50: 02 bf ff af be 2018c0c <== NOT EXECUTED 2018d54: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 2018d58: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED 2018d5c: c2 04 00 01 ld [ %l0 + %g1 ], %g1 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly, singly, p, &p[singly] ); fflush(stdout); #endif return (block_p *)&p[ singly ]; 2018d60: 85 2c a0 02 sll %l2, 2, %g2 <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 2018d64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly, singly, p, &p[singly] ); fflush(stdout); #endif return (block_p *)&p[ singly ]; 2018d68: b0 00 40 02 add %g1, %g2, %i0 <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 2018d6c: 12 80 00 4c bne 2018e9c 2018d70: 01 00 00 00 nop p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 2018d74: 81 c7 e0 08 ret <== NOT EXECUTED 2018d78: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 2018d7c: 90 02 20 01 inc %o0 <== NOT EXECUTED 2018d80: 40 00 60 41 call 2030e84 <.umul> <== NOT EXECUTED 2018d84: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018d88: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED 2018d8c: 80 a6 40 08 cmp %i1, %o0 <== NOT EXECUTED 2018d90: 18 80 00 42 bgu 2018e98 <== NOT EXECUTED 2018d94: a0 26 40 10 sub %i1, %l0, %l0 <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 2018d98: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018d9c: 40 00 61 20 call 203121c <.urem> <== NOT EXECUTED 2018da0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 2018da4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 2018da8: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 2018dac: 40 00 60 70 call 2030f6c <.udiv> <== NOT EXECUTED 2018db0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 2018db4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018db8: 40 00 60 6d call 2030f6c <.udiv> <== NOT EXECUTED 2018dbc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; 2018dc0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED if ( my_block <= LAST_TRIPLY_INDIRECT ) { my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 2018dc4: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; 2018dc8: 40 00 61 15 call 203121c <.urem> <== NOT EXECUTED 2018dcc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { 2018dd0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; doubly %= IMFS_MEMFILE_BLOCK_SLOTS; 2018dd4: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { 2018dd8: 02 80 00 24 be 2018e68 <== NOT EXECUTED 2018ddc: e0 06 20 58 ld [ %i0 + 0x58 ], %l0 <== NOT EXECUTED if ( !p ) { 2018de0: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2018de4: 12 80 00 09 bne 2018e08 <== NOT EXECUTED 2018de8: b5 2e 60 02 sll %i1, 2, %i2 <== NOT EXECUTED p = memfile_alloc_block(); 2018dec: 7f ff ff 71 call 2018bb0 <== NOT EXECUTED 2018df0: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) 2018df4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018df8: 02 80 00 28 be 2018e98 <== NOT EXECUTED 2018dfc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED return 0; info->triply_indirect = p; 2018e00: d0 26 20 58 st %o0, [ %i0 + 0x58 ] <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 2018e04: b5 2e 60 02 sll %i1, 2, %i2 <== NOT EXECUTED 2018e08: c2 04 00 1a ld [ %l0 + %i2 ], %g1 <== NOT EXECUTED if ( !p1 ) { 2018e0c: a2 90 60 00 orcc %g1, 0, %l1 <== NOT EXECUTED 2018e10: 32 80 00 09 bne,a 2018e34 <== NOT EXECUTED 2018e14: a1 2c a0 02 sll %l2, 2, %l0 <== NOT EXECUTED p1 = memfile_alloc_block(); 2018e18: 7f ff ff 66 call 2018bb0 <== NOT EXECUTED 2018e1c: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) 2018e20: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 2018e24: 02 80 00 1d be 2018e98 <== NOT EXECUTED 2018e28: a2 10 00 01 mov %g1, %l1 <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 2018e2c: c2 24 00 1a st %g1, [ %l0 + %i2 ] <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 2018e30: a1 2c a0 02 sll %l2, 2, %l0 <== NOT EXECUTED 2018e34: c2 04 40 10 ld [ %l1 + %l0 ], %g1 <== NOT EXECUTED if ( !p2 ) { 2018e38: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 2018e3c: 12 80 00 09 bne 2018e60 <== NOT EXECUTED 2018e40: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED p2 = memfile_alloc_block(); 2018e44: 7f ff ff 5b call 2018bb0 <== NOT EXECUTED 2018e48: 01 00 00 00 nop <== NOT EXECUTED if ( !p2 ) 2018e4c: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 2018e50: 02 80 00 12 be 2018e98 <== NOT EXECUTED 2018e54: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 2018e58: c2 24 40 10 st %g1, [ %l1 + %l0 ] <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 2018e5c: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED 2018e60: 81 c7 e0 08 ret <== NOT EXECUTED 2018e64: 91 ea 00 01 restore %o0, %g1, %o0 <== NOT EXECUTED } if ( !p ) 2018e68: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2018e6c: 02 bf ff 68 be 2018c0c <== NOT EXECUTED 2018e70: b0 10 20 00 clr %i0 <== NOT EXECUTED #if 0 fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly ); fflush(stdout); #endif p1 = (block_p *) p[ triply ]; 2018e74: 83 2e 60 02 sll %i1, 2, %g1 <== NOT EXECUTED 2018e78: d0 04 00 01 ld [ %l0 + %g1 ], %o0 <== NOT EXECUTED if ( !p1 ) 2018e7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018e80: 02 bf ff 63 be 2018c0c <== NOT EXECUTED 2018e84: 83 2c a0 02 sll %l2, 2, %g1 <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 2018e88: c4 02 00 01 ld [ %o0 + %g1 ], %g2 <== NOT EXECUTED 2018e8c: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED 2018e90: 81 c7 e0 08 ret 2018e94: 91 e8 40 02 restore %g1, %g2, %o0 2018e98: b0 10 20 00 clr %i0 <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 2018e9c: 81 c7 e0 08 ret 2018ea0: 81 e8 00 00 restore 020197c4 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 20197c4: 9d e3 bf 90 save %sp, -112, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 20197c8: a8 96 20 00 orcc %i0, 0, %l4 20197cc: 32 80 00 09 bne,a 20197f0 20197d0: c2 05 20 48 ld [ %l4 + 0x48 ], %g1 20197d4: 92 10 22 4a mov 0x24a, %o1 <== NOT EXECUTED 20197d8: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20197dc: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20197e0: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20197e4: 7f ff a8 c2 call 2003aec <__assert> <== NOT EXECUTED 20197e8: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED 20197ec: 30 80 00 0f b,a 2019828 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 20197f0: 82 00 7f fb add %g1, -5, %g1 20197f4: 80 a0 60 01 cmp %g1, 1 20197f8: 08 80 00 07 bleu 2019814 20197fc: 11 00 80 d1 sethi %hi(0x2034400), %o0 2019800: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019804: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2019808: 94 12 a2 18 or %o2, 0x218, %o2 <== NOT EXECUTED 201980c: 7f ff a8 b8 call 2003aec <__assert> <== NOT EXECUTED 2019810: 92 10 22 4f mov 0x24f, %o1 <== NOT EXECUTED the_jnode->type == IMFS_LINEAR_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE && 2019814: c4 05 20 48 ld [ %l4 + 0x48 ], %g2 2019818: 82 00 bf fb add %g2, -5, %g1 201981c: 80 a0 60 01 cmp %g1, 1 2019820: 08 80 00 06 bleu 2019838 2019824: 80 a6 a0 00 cmp %i2, 0 the_jnode->type != IMFS_LINEAR_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 2019828: 40 00 21 55 call 2021d7c <__errno> <== NOT EXECUTED 201982c: 01 00 00 00 nop <== NOT EXECUTED 2019830: 10 80 00 0d b 2019864 <== NOT EXECUTED 2019834: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 2019838: 12 80 00 0e bne 2019870 201983c: 80 a6 e0 00 cmp %i3, 0 2019840: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2019844: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019848: 92 10 22 58 mov 0x258, %o1 <== NOT EXECUTED 201984c: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2019850: 7f ff a8 a7 call 2003aec <__assert> <== NOT EXECUTED 2019854: 94 12 a2 68 or %o2, 0x268, %o2 <== NOT EXECUTED if ( !dest ) rtems_set_errno_and_return_minus_one( EINVAL ); 2019858: 40 00 21 49 call 2021d7c <__errno> <== NOT EXECUTED 201985c: 01 00 00 00 nop <== NOT EXECUTED 2019860: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2019864: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019868: 10 80 00 74 b 2019a38 <== NOT EXECUTED 201986c: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 2019870: 02 bf ff fa be 2019858 2019874: 80 a0 a0 06 cmp %g2, 6 /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 2019878: 32 80 00 0d bne,a 20198ac 201987c: c4 05 20 4c ld [ %l4 + 0x4c ], %g2 unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 2019880: c2 05 20 4c ld [ %l4 + 0x4c ], %g1 <== NOT EXECUTED 2019884: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED 2019888: 82 20 40 19 sub %g1, %i1, %g1 <== NOT EXECUTED 201988c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED 2019890: 08 80 00 03 bleu 201989c <== NOT EXECUTED 2019894: d2 05 20 50 ld [ %l4 + 0x50 ], %o1 <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; 2019898: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED memcpy(dest, &file_ptr[start], my_length); 201989c: 92 02 40 19 add %o1, %i1, %o1 <== NOT EXECUTED 20198a0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 20198a4: 10 80 00 5d b 2019a18 <== NOT EXECUTED 20198a8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 20198ac: 82 06 c0 19 add %i3, %i1, %g1 20198b0: 80 a0 40 02 cmp %g1, %g2 20198b4: 08 80 00 03 bleu 20198c0 20198b8: a0 10 00 1b mov %i3, %l0 my_length = the_jnode->info.file.size - start; 20198bc: a0 20 80 19 sub %g2, %i1, %l0 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 20198c0: 03 00 80 e3 sethi %hi(0x2038c00), %g1 20198c4: e2 00 60 dc ld [ %g1 + 0xdc ], %l1 ! 2038cdc 20198c8: 90 10 00 19 mov %i1, %o0 20198cc: 40 00 5e 56 call 2031224 <.rem> 20198d0: 92 10 00 11 mov %l1, %o1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 20198d4: 92 10 00 11 mov %l1, %o1 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 20198d8: a4 10 00 08 mov %o0, %l2 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 20198dc: 40 00 5d a6 call 2030f74 <.div> 20198e0: 90 10 00 19 mov %i1, %o0 if ( start_offset ) { 20198e4: 80 a4 a0 00 cmp %l2, 0 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 20198e8: b2 10 00 08 mov %o0, %i1 if ( start_offset ) { 20198ec: a6 10 00 1a mov %i2, %l3 20198f0: 02 80 00 1d be 2019964 20198f4: b0 10 20 00 clr %i0 to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 20198f8: 90 10 00 14 mov %l4, %o0 20198fc: 92 10 00 19 mov %i1, %o1 2019900: 7f ff fc b9 call 2018be4 2019904: 94 10 20 00 clr %o2 assert( block_ptr ); 2019908: 80 a2 20 00 cmp %o0, 0 201990c: 12 80 00 0a bne 2019934 2019910: 92 24 40 12 sub %l1, %l2, %o1 2019914: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2019918: 92 10 22 94 mov 0x294, %o1 <== NOT EXECUTED 201991c: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2019920: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019924: 7f ff a8 72 call 2003aec <__assert> <== NOT EXECUTED 2019928: 94 12 a2 08 or %o2, 0x208, %o2 ! 2034608 <_POSIX_Threads_Default_attributes+0xd8> <== NOT EXECUTED 201992c: 10 80 00 43 b 2019a38 <== NOT EXECUTED 2019930: 94 10 20 00 clr %o2 <== NOT EXECUTED */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 2019934: 80 a4 00 09 cmp %l0, %o1 2019938: 08 80 00 03 bleu 2019944 201993c: 94 10 00 10 mov %l0, %o2 2019940: 94 10 00 09 mov %o1, %o2 to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 2019944: d2 02 00 00 ld [ %o0 ], %o1 dest += to_copy; 2019948: a6 06 80 0a add %i2, %o2, %l3 to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 201994c: 92 04 80 09 add %l2, %o1, %o1 dest += to_copy; block++; 2019950: b2 06 60 01 inc %i1 my_length -= to_copy; 2019954: a0 24 00 0a sub %l0, %o2, %l0 2019958: b0 10 00 0a mov %o2, %i0 to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 201995c: 40 00 27 bc call 202384c 2019960: 90 10 00 1a mov %i2, %o0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 2019964: 03 00 80 e3 sethi %hi(0x2038c00), %g1 2019968: f4 00 60 dc ld [ %g1 + 0xdc ], %i2 ! 2038cdc while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201996c: 10 80 00 12 b 20199b4 2019970: a2 10 00 01 mov %g1, %l1 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 2019974: 7f ff fc 9c call 2018be4 2019978: 01 00 00 00 nop assert( block_ptr ); 201997c: 80 a2 20 00 cmp %o0, 0 2019980: 32 80 00 06 bne,a 2019998 2019984: d2 02 00 00 ld [ %o0 ], %o1 2019988: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 201998c: 92 10 22 a5 mov 0x2a5, %o1 <== NOT EXECUTED 2019990: 10 80 00 1a b 20199f8 <== NOT EXECUTED 2019994: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); dest += to_copy; block++; 2019998: b2 06 60 01 inc %i1 while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 201999c: 90 10 00 13 mov %l3, %o0 dest += to_copy; block++; my_length -= to_copy; 20199a0: a0 24 00 1a sub %l0, %i2, %l0 copied += to_copy; 20199a4: b0 06 00 1a add %i0, %i2, %i0 while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 20199a8: a6 04 c0 1a add %l3, %i2, %l3 20199ac: 40 00 27 a8 call 202384c 20199b0: 94 10 00 1a mov %i2, %o2 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 20199b4: c2 04 60 dc ld [ %l1 + 0xdc ], %g1 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 20199b8: 92 10 00 19 mov %i1, %o1 20199bc: 94 10 20 00 clr %o2 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 20199c0: 80 a4 00 01 cmp %l0, %g1 20199c4: 1a bf ff ec bcc 2019974 20199c8: 90 10 00 14 mov %l4, %o0 * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 20199cc: 80 a4 20 00 cmp %l0, 0 20199d0: 22 80 00 15 be,a 2019a24 20199d4: 90 07 bf f0 add %fp, -16, %o0 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 20199d8: 7f ff fc 83 call 2018be4 20199dc: 01 00 00 00 nop assert( block_ptr ); 20199e0: 80 a2 20 00 cmp %o0, 0 20199e4: 32 80 00 0a bne,a 2019a0c 20199e8: d2 02 00 00 ld [ %o0 ], %o1 20199ec: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20199f0: 92 10 22 b7 mov 0x2b7, %o1 <== NOT EXECUTED 20199f4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20199f8: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20199fc: 7f ff a8 3c call 2003aec <__assert> <== NOT EXECUTED 2019a00: 94 12 a2 08 or %o2, 0x208, %o2 ! 2034608 <_POSIX_Threads_Default_attributes+0xd8> <== NOT EXECUTED if ( !block_ptr ) return copied; 2019a04: 10 80 00 0d b 2019a38 <== NOT EXECUTED 2019a08: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; 2019a0c: b0 06 00 10 add %i0, %l0, %i0 if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 2019a10: 90 10 00 13 mov %l3, %o0 2019a14: 94 10 00 10 mov %l0, %o2 2019a18: 40 00 27 8d call 202384c 2019a1c: 01 00 00 00 nop copied += my_length; } IMFS_update_atime( the_jnode ); 2019a20: 90 07 bf f0 add %fp, -16, %o0 2019a24: 7f ff a8 ed call 2003dd8 2019a28: 92 10 20 00 clr %o1 2019a2c: c2 07 bf f0 ld [ %fp + -16 ], %g1 return copied; 2019a30: 94 10 00 18 mov %i0, %o2 return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( the_jnode ); 2019a34: c2 25 20 3c st %g1, [ %l4 + 0x3c ] return copied; } 2019a38: 81 c7 e0 08 ret 2019a3c: 91 e8 00 0a restore %g0, %o2, %o0 02018f44 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 2018f44: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 2018f48: 80 a6 20 00 cmp %i0, 0 2018f4c: 32 80 00 09 bne,a 2018f70 2018f50: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2018f54: 92 10 21 ec mov 0x1ec, %o1 <== NOT EXECUTED 2018f58: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2018f5c: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2018f60: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2018f64: 7f ff aa e2 call 2003aec <__assert> <== NOT EXECUTED 2018f68: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED 2018f6c: 30 80 00 0d b,a 2018fa0 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 2018f70: 80 a0 60 05 cmp %g1, 5 2018f74: 02 80 00 07 be 2018f90 2018f78: 11 00 80 d1 sethi %hi(0x2034400), %o0 2018f7c: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2018f80: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 2018f84: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 2018f88: 7f ff aa d9 call 2003aec <__assert> <== NOT EXECUTED 2018f8c: 92 10 21 f0 mov 0x1f0, %o1 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 2018f90: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2018f94: 80 a0 60 05 cmp %g1, 5 2018f98: 22 80 00 08 be,a 2018fb8 2018f9c: 21 00 80 e3 sethi %hi(0x2038c00), %l0 rtems_set_errno_and_return_minus_one( EIO ); 2018fa0: 40 00 23 77 call 2021d7c <__errno> <== NOT EXECUTED 2018fa4: 01 00 00 00 nop <== NOT EXECUTED 2018fa8: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 2018fac: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 2018fb0: 10 80 00 4b b 20190dc <== NOT EXECUTED 2018fb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 2018fb8: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 /* * Eventually this could be set smarter at each call to * memfile_free_blocks_in_table to greatly speed this up. */ to_free = IMFS_MEMFILE_BLOCK_SLOTS; 2018fbc: c4 04 20 dc ld [ %l0 + 0xdc ], %g2 * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 2018fc0: 80 a0 60 00 cmp %g1, 0 2018fc4: 02 80 00 05 be 2018fd8 2018fc8: a5 30 a0 02 srl %g2, 2, %l2 memfile_free_blocks_in_table( &info->indirect, to_free ); 2018fcc: 90 06 20 50 add %i0, 0x50, %o0 2018fd0: 7f ff ff c1 call 2018ed4 2018fd4: 92 10 00 12 mov %l2, %o1 } if ( info->doubly_indirect ) { 2018fd8: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 for ( i=0 ; iindirect ) { memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { 2018fe0: 80 a0 60 00 cmp %g1, 0 2018fe4: 12 80 00 0c bne 2019014 2018fe8: a0 10 20 00 clr %l0 } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { 2018fec: 10 80 00 13 b 2019038 2018ff0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 } if ( info->doubly_indirect ) { for ( i=0 ; idoubly_indirect[i] ) { 2018ff4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; idoubly_indirect[i] ) { 2018ffc: c4 02 00 01 ld [ %o0 + %g1 ], %g2 <== NOT EXECUTED 2019000: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2019004: 02 80 00 04 be 2019014 <== NOT EXECUTED 2019008: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED memfile_free_blocks_in_table( 201900c: 7f ff ff b2 call 2018ed4 <== NOT EXECUTED 2019010: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i <== NOT EXECUTED 2019024: 91 2c 20 02 sll %l0, 2, %o0 <== NOT EXECUTED if ( info->doubly_indirect[i] ) { memfile_free_blocks_in_table( (block_p **)&info->doubly_indirect[i], to_free ); } } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); 2019028: 90 06 20 54 add %i0, 0x54, %o0 <== NOT EXECUTED 201902c: 7f ff ff aa call 2018ed4 <== NOT EXECUTED 2019030: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED } if ( info->triply_indirect ) { 2019034: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED 2019038: 84 10 20 00 clr %g2 201903c: 80 a0 60 00 cmp %g1, 0 2019040: a6 10 20 00 clr %l3 2019044: 12 80 00 1d bne 20190b8 2019048: 2b 00 80 e3 sethi %hi(0x2038c00), %l5 memfile_free_blocks_in_table( (block_p **)&info->triply_indirect, to_free ); } return 0; } 201904c: 81 c7 e0 08 ret 2019050: 91 e8 00 02 restore %g0, %g2, %o0 } memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { 2019054: a9 2c e0 02 sll %l3, 2, %l4 <== NOT EXECUTED for ( i=0 ; itriply_indirect[i]; 2019058: d0 00 40 14 ld [ %g1 + %l4 ], %o0 <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 201905c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2019060: 22 80 00 1c be,a 20190d0 <== NOT EXECUTED 2019064: 90 06 20 58 add %i0, 0x58, %o0 <== NOT EXECUTED break; 2019068: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 201906c: 10 80 00 09 b 2019090 <== NOT EXECUTED 2019070: a2 10 20 00 clr %l1 <== NOT EXECUTED for ( j=0 ; j <== NOT EXECUTED 2019080: a2 04 60 01 inc %l1 <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 2019084: 7f ff ff 94 call 2018ed4 <== NOT EXECUTED 2019088: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j <== NOT EXECUTED 20190a0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 20190a4: d0 06 20 58 ld [ %i0 + 0x58 ], %o0 <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i <== NOT EXECUTED 20190b4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i <== NOT EXECUTED 20190c8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 20190cc: 90 06 20 58 add %i0, 0x58, %o0 <== NOT EXECUTED 20190d0: 7f ff ff 81 call 2018ed4 <== NOT EXECUTED 20190d4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 20190d8: 84 10 20 00 clr %g2 <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 20190dc: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED 20190e0: 81 c7 e0 08 ret <== NOT EXECUTED 20190e4: 81 e8 00 00 restore <== NOT EXECUTED 02018ea4 : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 2018ea4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED block_p *block_entry_ptr; block_p ptr; block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 2018ea8: 94 10 20 00 clr %o2 <== NOT EXECUTED 2018eac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2018eb0: 7f ff ff 4d call 2018be4 <== NOT EXECUTED 2018eb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ptr = *block_entry_ptr; 2018eb8: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *block_entry_ptr = 0; memfile_free_block( ptr ); return 1; } 2018ebc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED block_p *block_entry_ptr; block_p ptr; block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); ptr = *block_entry_ptr; *block_entry_ptr = 0; 2018ec0: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED memfile_free_block( ptr ); 2018ec4: 7f ff ff 32 call 2018b8c <== NOT EXECUTED 2018ec8: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 1; } 2018ecc: 81 c7 e0 08 ret <== NOT EXECUTED 2018ed0: 81 e8 00 00 restore <== NOT EXECUTED 02019498 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 2019498: 9d e3 bf 90 save %sp, -112, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201949c: 80 a6 20 00 cmp %i0, 0 20194a0: 32 80 00 09 bne,a 20194c4 20194a4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20194a8: 92 10 22 e1 mov 0x2e1, %o1 <== NOT EXECUTED 20194ac: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20194b0: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20194b4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20194b8: 7f ff a9 8d call 2003aec <__assert> <== NOT EXECUTED 20194bc: 94 12 a1 b8 or %o2, 0x1b8, %o2 <== NOT EXECUTED 20194c0: 30 80 00 0d b,a 20194f4 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 20194c4: 80 a0 60 05 cmp %g1, 5 20194c8: 02 80 00 07 be 20194e4 20194cc: 11 00 80 d1 sethi %hi(0x2034400), %o0 20194d0: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20194d4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20194d8: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 20194dc: 7f ff a9 84 call 2003aec <__assert> <== NOT EXECUTED 20194e0: 92 10 22 e5 mov 0x2e5, %o1 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 20194e4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20194e8: 80 a0 60 05 cmp %g1, 5 20194ec: 02 80 00 06 be 2019504 20194f0: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EIO ); 20194f4: 40 00 22 22 call 2021d7c <__errno> <== NOT EXECUTED 20194f8: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED 20194fc: 10 80 00 0d b 2019530 <== NOT EXECUTED 2019500: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED /* * Error check arguments */ assert( source ); 2019504: 12 80 00 0d bne 2019538 2019508: 80 a6 e0 00 cmp %i3, 0 201950c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2019510: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019514: 92 10 22 ed mov 0x2ed, %o1 <== NOT EXECUTED 2019518: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 201951c: 7f ff a9 74 call 2003aec <__assert> <== NOT EXECUTED 2019520: 94 12 a2 00 or %o2, 0x200, %o2 <== NOT EXECUTED if ( !source ) rtems_set_errno_and_return_minus_one( EINVAL ); 2019524: 40 00 22 16 call 2021d7c <__errno> <== NOT EXECUTED 2019528: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED 201952c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2019530: 10 80 00 71 b 20196f4 <== NOT EXECUTED 2019534: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 2019538: 02 bf ff fb be 2019524 201953c: 01 00 00 00 nop * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) { 2019540: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 /* * If the last byte we are supposed to write is past the end of this * in memory file, then extend the length. */ last_byte = start + length; 2019544: 92 06 c0 19 add %i3, %i1, %o1 if ( last_byte > the_jnode->info.file.size ) { 2019548: 80 a2 40 01 cmp %o1, %g1 201954c: 08 80 00 0b bleu 2019578 2019550: 03 00 80 e3 sethi %hi(0x2038c00), %g1 status = IMFS_memfile_extend( the_jnode, last_byte ); 2019554: 7f ff ff 4c call 2019284 2019558: 90 10 00 18 mov %i0, %o0 if ( status ) 201955c: 80 a2 20 00 cmp %o0, 0 2019560: 22 80 00 06 be,a 2019578 2019564: 03 00 80 e3 sethi %hi(0x2038c00), %g1 rtems_set_errno_and_return_minus_one( ENOSPC ); 2019568: 40 00 22 05 call 2021d7c <__errno> <== NOT EXECUTED 201956c: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED 2019570: 10 bf ff f0 b 2019530 <== NOT EXECUTED 2019574: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 2019578: e0 00 60 dc ld [ %g1 + 0xdc ], %l0 201957c: 90 10 00 19 mov %i1, %o0 2019580: 40 00 5f 29 call 2031224 <.rem> 2019584: 92 10 00 10 mov %l0, %o1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019588: 92 10 00 10 mov %l0, %o1 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 201958c: a2 10 00 08 mov %o0, %l1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 2019590: 40 00 5e 79 call 2030f74 <.div> 2019594: 90 10 00 19 mov %i1, %o0 if ( start_offset ) { 2019598: 80 a4 60 00 cmp %l1, 0 201959c: 12 80 00 05 bne 20195b0 20195a0: b2 10 00 08 mov %o0, %i1 20195a4: a0 10 00 1a mov %i2, %l0 20195a8: 10 80 00 1d b 201961c 20195ac: a4 10 20 00 clr %l2 to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 20195b0: 90 10 00 18 mov %i0, %o0 20195b4: 92 10 00 19 mov %i1, %o1 20195b8: 7f ff fd 8b call 2018be4 20195bc: 94 10 20 00 clr %o2 assert( block_ptr ); 20195c0: 80 a2 20 00 cmp %o0, 0 20195c4: 32 80 00 0b bne,a 20195f0 20195c8: 94 24 00 11 sub %l0, %l1, %o2 20195cc: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20195d0: 92 10 23 1a mov 0x31a, %o1 <== NOT EXECUTED 20195d4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20195d8: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20195dc: a4 10 20 00 clr %l2 <== NOT EXECUTED 20195e0: 7f ff a9 43 call 2003aec <__assert> <== NOT EXECUTED 20195e4: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); return copied; } 20195e8: 81 c7 e0 08 ret <== NOT EXECUTED 20195ec: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; 20195f0: 80 a2 80 1b cmp %o2, %i3 20195f4: 38 80 00 02 bgu,a 20195fc 20195f8: 94 10 00 1b mov %i3, %o2 if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 20195fc: d0 02 00 00 ld [ %o0 ], %o0 src += to_copy; 2019600: a0 06 80 0a add %i2, %o2, %l0 if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 2019604: 90 04 40 08 add %l1, %o0, %o0 src += to_copy; block++; 2019608: b2 06 60 01 inc %i1 my_length -= to_copy; 201960c: b6 26 c0 0a sub %i3, %o2, %i3 copied += to_copy; 2019610: a4 10 00 0a mov %o2, %l2 if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 2019614: 40 00 28 8e call 202384c 2019618: 92 10 00 1a mov %i2, %o1 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201961c: 03 00 80 e3 sethi %hi(0x2038c00), %g1 2019620: f4 00 60 dc ld [ %g1 + 0xdc ], %i2 ! 2038cdc while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 2019624: 10 80 00 14 b 2019674 2019628: a2 10 00 01 mov %g1, %l1 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201962c: 7f ff fd 6e call 2018be4 2019630: 01 00 00 00 nop assert( block_ptr ); 2019634: 80 a2 20 00 cmp %o0, 0 2019638: 32 80 00 08 bne,a 2019658 201963c: d0 02 00 00 ld [ %o0 ], %o0 2019640: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2019644: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 2019648: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 201964c: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED 2019650: 10 80 00 1c b 20196c0 <== NOT EXECUTED 2019654: 92 10 23 2e mov 0x32e, %o1 <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 2019658: 92 10 00 10 mov %l0, %o1 src += to_copy; block++; 201965c: b2 06 60 01 inc %i1 my_length -= to_copy; 2019660: b6 26 c0 1a sub %i3, %i2, %i3 2019664: a4 04 80 1a add %l2, %i2, %l2 if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 2019668: a0 04 00 1a add %l0, %i2, %l0 201966c: 40 00 28 78 call 202384c 2019670: 94 10 00 1a mov %i2, %o2 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 2019674: c2 04 60 dc ld [ %l1 + 0xdc ], %g1 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 2019678: 92 10 00 19 mov %i1, %o1 201967c: 94 10 20 00 clr %o2 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 2019680: 80 a6 c0 01 cmp %i3, %g1 2019684: 1a bf ff ea bcc 201962c 2019688: 90 10 00 18 mov %i0, %o0 */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 201968c: 80 a6 e0 00 cmp %i3, 0 2019690: 22 80 00 14 be,a 20196e0 2019694: 90 07 bf f0 add %fp, -16, %o0 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 2019698: 7f ff fd 53 call 2018be4 201969c: 01 00 00 00 nop assert( block_ptr ); 20196a0: 80 a2 20 00 cmp %o0, 0 20196a4: 32 80 00 0a bne,a 20196cc 20196a8: d0 02 00 00 ld [ %o0 ], %o0 20196ac: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 20196b0: 15 00 80 d1 sethi %hi(0x2034400), %o2 <== NOT EXECUTED 20196b4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED 20196b8: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED 20196bc: 92 10 23 44 mov 0x344, %o1 <== NOT EXECUTED 20196c0: 7f ff a9 0b call 2003aec <__assert> <== NOT EXECUTED 20196c4: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED 20196c8: 30 80 00 0c b,a 20196f8 <== NOT EXECUTED #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); my_length = 0; copied += to_copy; 20196cc: a4 04 80 1b add %l2, %i3, %l2 if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); 20196d0: 92 10 00 10 mov %l0, %o1 20196d4: 40 00 28 5e call 202384c 20196d8: 94 10 00 1b mov %i3, %o2 my_length = 0; copied += to_copy; } IMFS_atime_mtime_update( the_jnode ); 20196dc: 90 07 bf f0 add %fp, -16, %o0 20196e0: 7f ff a9 be call 2003dd8 20196e4: 92 10 20 00 clr %o1 20196e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20196ec: c2 26 20 3c st %g1, [ %i0 + 0x3c ] 20196f0: c2 26 20 40 st %g1, [ %i0 + 0x40 ] return copied; } 20196f4: b0 10 00 12 mov %l2, %i0 20196f8: 81 c7 e0 08 ret 20196fc: 81 e8 00 00 restore 0200b49c : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200b49c: 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 ); 200b4a0: 90 10 00 18 mov %i0, %o0 200b4a4: 92 07 bf c3 add %fp, -61, %o1 200b4a8: 7f ff ff 8c call 200b2d8 200b4ac: 94 07 bf f4 add %fp, -12, %o2 /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 200b4b0: 03 00 00 3c sethi %hi(0xf000), %g1 200b4b4: b3 2e 60 10 sll %i1, 0x10, %i1 200b4b8: 97 36 60 10 srl %i1, 0x10, %o3 200b4bc: 84 0a c0 01 and %o3, %g1, %g2 200b4c0: 03 00 00 10 sethi %hi(0x4000), %g1 200b4c4: 80 a0 80 01 cmp %g2, %g1 200b4c8: 02 80 00 17 be 200b524 200b4cc: 90 10 00 1c mov %i4, %o0 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 200b4d0: 03 00 00 20 sethi %hi(0x8000), %g1 200b4d4: 80 a0 80 01 cmp %g2, %g1 200b4d8: 02 80 00 14 be 200b528 200b4dc: 92 10 20 05 mov 5, %o1 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 200b4e0: 03 00 00 18 sethi %hi(0x6000), %g1 200b4e4: 80 a0 80 01 cmp %g2, %g1 200b4e8: 02 80 00 05 be 200b4fc 200b4ec: 03 00 00 08 sethi %hi(0x2000), %g1 200b4f0: 80 a0 80 01 cmp %g2, %g1 200b4f4: 12 80 00 06 bne 200b50c 200b4f8: 01 00 00 00 nop type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 200b4fc: f6 27 bf e8 st %i3, [ %fp + -24 ] 200b500: f4 27 bf e4 st %i2, [ %fp + -28 ] 200b504: 10 80 00 09 b 200b528 200b508: 92 10 20 02 mov 2, %o1 } else { rtems_set_errno_and_return_minus_one( EINVAL ); 200b50c: 40 00 0b b5 call 200e3e0 <__errno> <== NOT EXECUTED 200b510: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200b514: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200b518: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b51c: 81 c7 e0 08 ret <== NOT EXECUTED 200b520: 81 e8 00 00 restore <== NOT EXECUTED 200b524: 92 10 20 01 mov 1, %o1 /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 200b528: 94 07 bf c3 add %fp, -61, %o2 200b52c: 98 07 bf e4 add %fp, -28, %o4 200b530: 40 00 08 8e call 200d768 200b534: b0 10 20 00 clr %i0 new_name, mode, &info ); if ( !new_node ) 200b538: 80 a2 20 00 cmp %o0, 0 200b53c: 12 80 00 06 bne 200b554 200b540: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOMEM ); 200b544: 40 00 0b a7 call 200e3e0 <__errno> <== NOT EXECUTED 200b548: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200b54c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 200b550: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return 0; } 200b554: 81 c7 e0 08 ret 200b558: 81 e8 00 00 restore 02003778 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 2003778: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 200377c: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 2003780: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 2003784: 80 a0 60 01 cmp %g1, 1 2003788: 22 80 00 08 be,a 20037a8 200378c: f0 20 a0 58 st %i0, [ %g2 + 0x58 ] rtems_set_errno_and_return_minus_one( ENOTDIR ); 2003790: 40 00 79 7b call 2021d7c <__errno> <== NOT EXECUTED 2003794: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003798: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED 200379c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20037a0: 81 c7 e0 08 ret <== NOT EXECUTED 20037a4: 81 e8 00 00 restore <== NOT EXECUTED * the mounted file system. */ node->info.directory.mt_fs = mt_entry; return 0; } 20037a8: 81 c7 e0 08 ret 20037ac: 91 e8 20 00 restore %g0, 0, %o0 020037d0 : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 20037d0: 9d e3 bf 98 save %sp, -104, %sp assert( the_jnode ); 20037d4: 80 a6 20 00 cmp %i0, 0 20037d8: 12 80 00 09 bne 20037fc 20037dc: 21 00 80 7e sethi %hi(0x201f800), %l0 20037e0: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 20037e4: 15 00 80 76 sethi %hi(0x201d800), %o2 <== NOT EXECUTED 20037e8: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED 20037ec: 94 12 a0 98 or %o2, 0x98, %o2 <== NOT EXECUTED 20037f0: 40 00 02 15 call 2004044 <__assert> <== NOT EXECUTED 20037f4: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 20037f8: 21 00 80 7e sethi %hi(0x201f800), %l0 <== NOT EXECUTED 20037fc: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 ! 201fa30 <_impure_ptr> 2003800: 90 06 20 0c add %i0, 0xc, %o0 2003804: 40 00 3c ce call 2012b3c 2003808: d2 00 60 08 ld [ %g1 + 8 ], %o1 switch( the_jnode->type ) { 200380c: d4 06 20 48 ld [ %i0 + 0x48 ], %o2 2003810: 82 02 bf ff add %o2, -1, %g1 2003814: 80 a0 60 05 cmp %g1, 5 2003818: 38 80 00 34 bgu,a 20038e8 200381c: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 <== NOT EXECUTED 2003820: 83 28 60 02 sll %g1, 2, %g1 2003824: 05 00 80 0d sethi %hi(0x2003400), %g2 2003828: 84 10 a3 7c or %g2, 0x37c, %g2 ! 200377c 200382c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2003830: 81 c0 40 00 jmp %g1 2003834: 01 00 00 00 nop case IMFS_DIRECTORY: fprintf(stdout, "/" ); 2003838: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 200383c: 90 10 20 2f mov 0x2f, %o0 2003840: 40 00 3c 7e call 2012a38 2003844: d2 00 60 08 ld [ %g1 + 8 ], %o1 default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 2003848: 10 80 00 33 b 2003914 200384c: 31 00 80 75 sethi %hi(0x201d400), %i0 case IMFS_DIRECTORY: fprintf(stdout, "/" ); break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 2003850: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 2003854: d6 06 20 50 ld [ %i0 + 0x50 ], %o3 2003858: d0 00 60 08 ld [ %g1 + 8 ], %o0 200385c: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 2003860: 13 00 80 76 sethi %hi(0x201d800), %o1 2003864: 10 80 00 08 b 2003884 2003868: 92 12 60 a8 or %o1, 0xa8, %o1 ! 201d8a8 the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 200386c: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 <== NOT EXECUTED 2003870: d6 06 20 50 ld [ %i0 + 0x50 ], %o3 <== NOT EXECUTED 2003874: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED 2003878: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 <== NOT EXECUTED 200387c: 13 00 80 76 sethi %hi(0x201d800), %o1 <== NOT EXECUTED 2003880: 92 12 60 c0 or %o1, 0xc0, %o1 ! 201d8c0 <== NOT EXECUTED 2003884: 40 00 3c 61 call 2012a08 2003888: 31 00 80 75 sethi %hi(0x201d400), %i0 200388c: 30 80 00 22 b,a 2003914 the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 2003890: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 2003894: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 2003898: d0 00 60 08 ld [ %g1 + 8 ], %o0 200389c: 13 00 80 76 sethi %hi(0x201d800), %o1 20038a0: 40 00 3c 5a call 2012a08 20038a4: 92 12 60 d0 or %o1, 0xd0, %o1 ! 201d8d0 default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 20038a8: 10 80 00 1b b 2003914 20038ac: 31 00 80 75 sethi %hi(0x201d400), %i0 (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 20038b0: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 <== NOT EXECUTED 20038b4: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 20038b8: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED 20038bc: 40 00 3c a0 call 2012b3c <== NOT EXECUTED 20038c0: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED assert(0); 20038c4: 10 80 00 0e b 20038fc <== NOT EXECUTED 20038c8: 92 10 20 5d mov 0x5d, %o1 <== NOT EXECUTED break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 20038cc: c2 04 22 30 ld [ %l0 + 0x230 ], %g1 <== NOT EXECUTED 20038d0: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 20038d4: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED 20038d8: 40 00 3c 99 call 2012b3c <== NOT EXECUTED 20038dc: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED assert(0); 20038e0: 10 80 00 07 b 20038fc <== NOT EXECUTED 20038e4: 92 10 20 62 mov 0x62, %o1 <== NOT EXECUTED break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 20038e8: 13 00 80 76 sethi %hi(0x201d800), %o1 <== NOT EXECUTED 20038ec: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED 20038f0: 40 00 3c 46 call 2012a08 <== NOT EXECUTED 20038f4: 92 12 61 00 or %o1, 0x100, %o1 <== NOT EXECUTED assert(0); 20038f8: 92 10 20 67 mov 0x67, %o1 <== NOT EXECUTED 20038fc: 11 00 80 76 sethi %hi(0x201d800), %o0 <== NOT EXECUTED 2003900: 15 00 80 76 sethi %hi(0x201d800), %o2 <== NOT EXECUTED 2003904: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED 2003908: 40 00 01 cf call 2004044 <__assert> <== NOT EXECUTED 200390c: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED break; } puts(""); 2003910: 31 00 80 75 sethi %hi(0x201d400), %i0 <== NOT EXECUTED 2003914: 40 00 42 db call 2014480 2003918: 91 ee 23 f8 restore %i0, 0x3f8, %o0 200391c: 01 00 00 00 nop 020037bc : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 20037bc: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; int i; node = loc->node_access; 20037c0: c6 06 00 00 ld [ %i0 ], %g3 if ( node->type != IMFS_SYM_LINK ) 20037c4: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 20037c8: 80 a0 60 04 cmp %g1, 4 20037cc: 02 80 00 0a be 20037f4 20037d0: b0 10 20 00 clr %i0 rtems_set_errno_and_return_minus_one( EINVAL ); 20037d4: 40 00 79 6a call 2021d7c <__errno> <== NOT EXECUTED 20037d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20037dc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20037e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20037e4: 81 c7 e0 08 ret <== NOT EXECUTED 20037e8: 81 e8 00 00 restore <== NOT EXECUTED for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) buf[i] = node->info.sym_link.name[i]; 20037ec: c2 2e 00 19 stb %g1, [ %i0 + %i1 ] node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 20037f0: b0 06 20 01 inc %i0 20037f4: 80 a6 00 1a cmp %i0, %i2 20037f8: 02 80 00 07 be 2003814 20037fc: 01 00 00 00 nop 2003800: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1 2003804: c4 48 40 18 ldsb [ %g1 + %i0 ], %g2 2003808: 80 a0 a0 00 cmp %g2, 0 200380c: 12 bf ff f8 bne 20037ec 2003810: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 buf[i] = node->info.sym_link.name[i]; return i; } 2003814: 81 c7 e0 08 ret 2003818: 81 e8 00 00 restore 0200b568 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 200b568: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 200b56c: e0 06 00 00 ld [ %i0 ], %l0 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 200b570: c2 04 20 08 ld [ %l0 + 8 ], %g1 200b574: 80 a0 60 00 cmp %g1, 0 200b578: 22 80 00 06 be,a 200b590 200b57c: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED Chain_Extract( (Chain_Node *) the_jnode ); 200b580: 40 00 05 65 call 200cb14 <_Chain_Extract> 200b584: 90 10 00 10 mov %l0, %o0 the_jnode->Parent = NULL; 200b588: c0 24 20 08 clr [ %l0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 200b58c: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 200b590: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 200b594: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 200b598: 90 07 bf f0 add %fp, -16, %o0 200b59c: 40 00 01 09 call 200b9c0 200b5a0: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] 200b5a4: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * 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) ) { 200b5a8: 90 10 00 10 mov %l0, %o0 200b5ac: 40 00 01 3e call 200baa4 200b5b0: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 200b5b4: 80 a2 20 00 cmp %o0, 0 200b5b8: 12 80 00 18 bne 200b618 200b5bc: 01 00 00 00 nop 200b5c0: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 200b5c4: 80 a0 60 00 cmp %g1, 0 200b5c8: 12 80 00 14 bne 200b618 200b5cc: 03 00 80 5f sethi %hi(0x2017c00), %g1 /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 200b5d0: c6 00 61 b8 ld [ %g1 + 0x1b8 ], %g3 ! 2017db8 200b5d4: c4 06 00 00 ld [ %i0 ], %g2 200b5d8: c2 00 e0 04 ld [ %g3 + 4 ], %g1 200b5dc: 80 a0 40 02 cmp %g1, %g2 200b5e0: 22 80 00 02 be,a 200b5e8 200b5e4: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 200b5e8: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200b5ec: 80 a0 60 04 cmp %g1, 4 200b5f0: 12 80 00 08 bne 200b610 200b5f4: 01 00 00 00 nop if ( the_jnode->info.sym_link.name ) 200b5f8: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 200b5fc: 80 a2 20 00 cmp %o0, 0 200b600: 02 80 00 04 be 200b610 200b604: 01 00 00 00 nop free( the_jnode->info.sym_link.name ); 200b608: 7f ff da fd call 20021fc 200b60c: 01 00 00 00 nop } free( the_jnode ); 200b610: 7f ff da fb call 20021fc 200b614: 90 10 00 10 mov %l0, %o0 } return 0; } 200b618: 81 c7 e0 08 ret 200b61c: 91 e8 20 00 restore %g0, 0, %o0 0200b620 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 200b620: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 200b624: f0 06 00 00 ld [ %i0 ], %i0 switch ( the_jnode->type ) { 200b628: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 200b62c: 80 a0 60 04 cmp %g1, 4 200b630: 22 80 00 18 be,a 200b690 200b634: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED 200b638: 14 80 00 07 bg 200b654 200b63c: 80 a0 60 06 cmp %g1, 6 200b640: 80 a0 60 02 cmp %g1, 2 200b644: 12 80 00 0d bne 200b678 200b648: 01 00 00 00 nop rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 200b64c: 10 80 00 06 b 200b664 200b650: c4 06 20 4c ld [ %i0 + 0x4c ], %g2 200b654: 14 80 00 09 bg 200b678 200b658: 01 00 00 00 nop 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; 200b65c: 10 80 00 05 b 200b670 200b660: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 temp.__overlay.minor = _minor; 200b664: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 switch ( the_jnode->type ) { case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); 200b668: 10 80 00 0a b 200b690 200b66c: c4 3e 40 00 std %g2, [ %i1 ] break; case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 200b670: 10 80 00 08 b 200b690 200b674: c2 26 60 20 st %g1, [ %i1 + 0x20 ] case IMFS_SYM_LINK: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 200b678: 40 00 0b 5a call 200e3e0 <__errno> <== NOT EXECUTED 200b67c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200b680: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 200b684: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b688: 81 c7 e0 08 ret <== NOT EXECUTED 200b68c: 81 e8 00 00 restore <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 200b690: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1 buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; 200b694: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); break; } buf->st_mode = the_jnode->st_mode; 200b698: c2 36 60 0c sth %g1, [ %i1 + 0xc ] buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; 200b69c: c4 26 60 08 st %g2, [ %i1 + 8 ] rtems_set_errno_and_return_minus_one( ENOTSUP ); break; } buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; 200b6a0: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; buf->st_gid = the_jnode->st_gid; buf->st_atime = the_jnode->stat_atime; 200b6a4: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 rtems_set_errno_and_return_minus_one( ENOTSUP ); break; } buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; 200b6a8: c2 36 60 0e sth %g1, [ %i1 + 0xe ] buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; buf->st_gid = the_jnode->st_gid; buf->st_atime = the_jnode->stat_atime; 200b6ac: c4 26 60 24 st %g2, [ %i1 + 0x24 ] } buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; 200b6b0: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1 buf->st_gid = the_jnode->st_gid; buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; 200b6b4: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 } buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; 200b6b8: c2 36 60 10 sth %g1, [ %i1 + 0x10 ] buf->st_gid = the_jnode->st_gid; buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; 200b6bc: c4 26 60 2c st %g2, [ %i1 + 0x2c ] buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; buf->st_gid = the_jnode->st_gid; 200b6c0: c4 16 20 3a lduh [ %i0 + 0x3a ], %g2 buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime; 200b6c4: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 buf->st_mode = the_jnode->st_mode; buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; buf->st_uid = the_jnode->st_uid; buf->st_gid = the_jnode->st_gid; 200b6c8: c4 36 60 12 sth %g2, [ %i1 + 0x12 ] buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime; 200b6cc: c2 26 60 34 st %g1, [ %i1 + 0x34 ] return 0; } 200b6d0: 81 c7 e0 08 ret 200b6d4: 91 e8 20 00 restore %g0, 0, %o0 0200381c : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 200381c: 9d e3 bf 60 save %sp, -160, %sp /* * Remove any separators at the end of the string. */ IMFS_get_token( node_name, new_name, &i ); 2003820: a0 07 bf c3 add %fp, -61, %l0 2003824: 94 07 bf f4 add %fp, -12, %o2 2003828: 92 10 00 10 mov %l0, %o1 200382c: 7f ff fe fe call 2003424 2003830: 90 10 00 1a mov %i2, %o0 int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 2003834: 90 10 00 18 mov %i0, %o0 * Remove any separators at the end of the string. */ IMFS_get_token( node_name, new_name, &i ); info.sym_link.name = link_name; 2003838: f2 27 bf e4 st %i1, [ %fp + -28 ] /* * Create a new link node. */ new_node = IMFS_create_node( 200383c: 94 10 00 10 mov %l0, %o2 2003840: 92 10 20 04 mov 4, %o1 2003844: 17 00 00 28 sethi %hi(0xa000), %o3 2003848: 98 07 bf e4 add %fp, -28, %o4 200384c: 96 12 e1 ff or %o3, 0x1ff, %o3 2003850: 40 00 42 4c call 2014180 2003854: b0 10 20 00 clr %i0 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 2003858: 80 a2 20 00 cmp %o0, 0 200385c: 12 80 00 06 bne 2003874 2003860: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOMEM ); 2003864: 40 00 79 46 call 2021d7c <__errno> <== NOT EXECUTED 2003868: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200386c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 2003870: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return 0; } 2003874: 81 c7 e0 08 ret 2003878: 81 e8 00 00 restore 0200387c : #include int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) { 200387c: 9d e3 bf 80 save %sp, -128, %sp IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 2003880: e0 06 00 00 ld [ %i0 ], %l0 /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 2003884: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2003888: 80 a0 60 03 cmp %g1, 3 200388c: 32 80 00 2a bne,a 2003934 2003890: c2 06 20 04 ld [ %i0 + 4 ], %g1 if ( !node->info.hard_link.link_node ) 2003894: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 2003898: 80 a0 60 00 cmp %g1, 0 200389c: 12 80 00 08 bne 20038bc 20038a0: a2 07 bf e0 add %fp, -32, %l1 rtems_set_errno_and_return_minus_one( EINVAL ); 20038a4: 40 00 79 36 call 2021d7c <__errno> <== NOT EXECUTED 20038a8: 01 00 00 00 nop <== NOT EXECUTED 20038ac: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 20038b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20038b4: 10 80 00 23 b 2003940 <== NOT EXECUTED 20038b8: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED the_link = *loc; 20038bc: 92 10 00 18 mov %i0, %o1 20038c0: 94 10 20 10 mov 0x10, %o2 20038c4: 40 00 7f e2 call 202384c 20038c8: 90 10 00 11 mov %l1, %o0 the_link.node_access = node->info.hard_link.link_node; 20038cc: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 IMFS_Set_handlers( &the_link ); 20038d0: 90 10 00 11 mov %l1, %o0 20038d4: 40 00 42 90 call 2014314 20038d8: c2 27 bf e0 st %g1, [ %fp + -32 ] /* * If removing the last hard link to a node, then we need * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) 20038dc: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 20038e0: c2 10 a0 30 lduh [ %g2 + 0x30 ], %g1 20038e4: 80 a0 60 01 cmp %g1, 1 20038e8: 12 80 00 0b bne 2003914 20038ec: 82 00 7f ff add %g1, -1, %g1 { result = (*the_link.handlers->rmnod_h)( &the_link ); 20038f0: c2 07 bf e4 ld [ %fp + -28 ], %g1 20038f4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 20038f8: 9f c0 40 00 call %g1 20038fc: 90 10 00 11 mov %l1, %o0 if ( result != 0 ) 2003900: 80 a2 20 00 cmp %o0, 0 2003904: 12 80 00 0f bne 2003940 2003908: 90 10 3f ff mov -1, %o0 /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 200390c: 10 80 00 0a b 2003934 2003910: c2 06 20 04 ld [ %i0 + 4 ], %g1 return -1; } else { node->info.hard_link.link_node->st_nlink --; IMFS_update_ctime( node->info.hard_link.link_node ); 2003914: 90 07 bf f0 add %fp, -16, %o0 if ( result != 0 ) return -1; } else { node->info.hard_link.link_node->st_nlink --; 2003918: c2 30 a0 30 sth %g1, [ %g2 + 0x30 ] IMFS_update_ctime( node->info.hard_link.link_node ); 200391c: 40 00 01 2f call 2003dd8 2003920: 92 10 20 00 clr %o1 2003924: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2003928: c2 07 bf f0 ld [ %fp + -16 ], %g1 200392c: c2 20 a0 44 st %g1, [ %g2 + 0x44 ] /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 2003930: c2 06 20 04 ld [ %i0 + 4 ], %g1 2003934: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 2003938: 9f c0 40 00 call %g1 200393c: 90 10 00 18 mov %i0, %o0 return result; } 2003940: 81 c7 e0 08 ret 2003944: 91 e8 00 08 restore %g0, %o0, %o0 02003948 : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 2003948: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 200394c: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 2003950: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 2003954: 80 a0 60 01 cmp %g1, 1 2003958: 22 80 00 06 be,a 2003970 200395c: c2 00 a0 58 ld [ %g2 + 0x58 ], %g1 rtems_set_errno_and_return_minus_one( ENOTDIR ); 2003960: 40 00 79 07 call 2021d7c <__errno> <== NOT EXECUTED 2003964: 01 00 00 00 nop <== NOT EXECUTED 2003968: 10 80 00 08 b 2003988 <== NOT EXECUTED 200396c: 82 10 20 14 mov 0x14, %g1 ! 14 <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 2003970: 80 a0 60 00 cmp %g1, 0 2003974: 32 80 00 08 bne,a 2003994 2003978: c0 20 a0 58 clr [ %g2 + 0x58 ] rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 200397c: 40 00 79 00 call 2021d7c <__errno> <== NOT EXECUTED 2003980: 01 00 00 00 nop <== NOT EXECUTED 2003984: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2003988: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200398c: 81 c7 e0 08 ret <== NOT EXECUTED 2003990: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 2003994: 81 c7 e0 08 ret 2003998: 91 e8 20 00 restore %g0, 0, %o0 02021560 : assert( 0 ); return 0; } int POSIX_BOTTOM_REACHED() { 2021560: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 2021564: 92 10 20 22 mov 0x22, %o1 <== NOT EXECUTED 2021568: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 202156c: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021570: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 2021574: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 2021578: 7f ff 92 8f call 2005fb4 <__assert> <== NOT EXECUTED 202157c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2021580: 81 c7 e0 08 ret <== NOT EXECUTED 2021584: 81 e8 00 00 restore <== NOT EXECUTED 02021588 : */ #include int POSIX_MP_NOT_IMPLEMENTED() { 2021588: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 202158c: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED 2021590: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 2021594: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021598: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 202159c: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 20215a0: 7f ff 92 85 call 2005fb4 <__assert> <== NOT EXECUTED 20215a4: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 20215a8: 81 c7 e0 08 ret <== NOT EXECUTED 20215ac: 81 e8 00 00 restore <== NOT EXECUTED 02021538 : assert( 0 ); return 0; } int POSIX_NOT_IMPLEMENTED() { 2021538: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 202153c: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED 2021540: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 2021544: 15 00 80 8e sethi %hi(0x2023800), %o2 <== NOT EXECUTED 2021548: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 202154c: 94 12 a3 b0 or %o2, 0x3b0, %o2 <== NOT EXECUTED 2021550: 7f ff 92 99 call 2005fb4 <__assert> <== NOT EXECUTED 2021554: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2021558: 81 c7 e0 08 ret <== NOT EXECUTED 202155c: 81 e8 00 00 restore <== NOT EXECUTED 02002540 : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 2002540: 9d e3 bf 98 save %sp, -104, %sp */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2002544: 03 00 80 62 sethi %hi(0x2018800), %g1 2002548: 82 10 61 8c or %g1, 0x18c, %g1 ! 201898c */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200254c: c2 20 7f fc st %g1, [ %g1 + -4 ] 2002550: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2002554: 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; 2002558: c0 20 60 04 clr [ %g1 + 4 ] * get length worth of memory using sbrk. Make sure we * align the address that we get back. */ starting_address = start; RTEMS_Malloc_Sbrk_amount = sbrk_amount; 200255c: 03 00 80 62 sethi %hi(0x2018800), %g1 if (!starting_address) { 2002560: 80 a6 20 00 cmp %i0, 0 2002564: 12 80 00 11 bne 20025a8 2002568: f4 20 61 84 st %i2, [ %g1 + 0x184 ] uaddress = (uintptr_t)sbrk(length); 200256c: 40 00 4e 77 call 2015f48 <== NOT EXECUTED 2002570: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED if (uaddress == (uintptr_t) -1) { 2002574: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 2002578: 12 80 00 04 bne 2002588 <== NOT EXECUTED 200257c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 2002580: 40 00 0f fa call 2006568 <== NOT EXECUTED 2002584: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED /* DOES NOT RETURN!!! */ } if (uaddress & (CPU_HEAP_ALIGNMENT-1)) { 2002588: 80 8e 20 07 btst 7, %i0 <== NOT EXECUTED 200258c: 02 80 00 08 be 20025ac <== NOT EXECUTED 2002590: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED old_address = uaddress; uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1); 2002594: 82 06 20 08 add %i0, 8, %g1 <== NOT EXECUTED 2002598: 82 08 7f f8 and %g1, -8, %g1 <== NOT EXECUTED /* * adjust the length by whatever we aligned by */ length -= uaddress - old_address; 200259c: 84 20 40 18 sub %g1, %i0, %g2 <== NOT EXECUTED 20025a0: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED 20025a4: b2 26 40 02 sub %i1, %g2, %i1 <== 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_cpu_configuration_get_do_zero_of_workspace() ) 20025a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20025ac: c2 00 63 14 ld [ %g1 + 0x314 ], %g1 ! 2018b14 <_CPU_Table+0x10> 20025b0: 80 a0 60 00 cmp %g1, 0 20025b4: 02 80 00 07 be 20025d0 20025b8: 92 10 00 18 mov %i0, %o1 memset( starting_address, 0, length ); 20025bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20025c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20025c4: 40 00 31 89 call 200ebe8 <== NOT EXECUTED 20025c8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 20025cc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20025d0: 94 10 00 19 mov %i1, %o2 20025d4: 11 00 80 62 sethi %hi(0x2018800), %o0 20025d8: 96 10 20 08 mov 8, %o3 20025dc: 40 00 12 c0 call 20070dc <_Heap_Initialize> 20025e0: 90 12 21 2c or %o0, 0x12c, %o0 &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 20025e4: 80 a2 20 00 cmp %o0, 0 20025e8: 12 80 00 04 bne 20025f8 20025ec: 01 00 00 00 nop rtems_fatal_error_occurred( status ); 20025f0: 40 00 0f de call 2006568 <== NOT EXECUTED 20025f4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 20025f8: 81 c7 e0 08 ret 20025fc: 81 e8 00 00 restore 020026d0 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 20026d0: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED void *low; void *high_water_mark; Stack_Control *stack; char name[5]; if ( !the_thread ) 20026d4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 20026d8: 02 80 00 3e be 20027d0 <== NOT EXECUTED 20026dc: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED return; if ( !print_handler ) 20026e0: c2 00 63 84 ld [ %g1 + 0x384 ], %g1 ! 201cb84 <== NOT EXECUTED 20026e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20026e8: 02 80 00 3a be 20027d0 <== NOT EXECUTED 20026ec: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED /* * XXX HACK to get to interrupt stack */ if (the_thread == (Thread_Control *) -1) { 20026f0: 12 80 00 09 bne 2002714 <== NOT EXECUTED 20026f4: a2 06 20 d0 add %i0, 0xd0, %l1 <== NOT EXECUTED if (Stack_check_Interrupt_stack.area) { 20026f8: 03 00 80 73 sethi %hi(0x201cc00), %g1 <== NOT EXECUTED 20026fc: 82 10 62 fc or %g1, 0x2fc, %g1 ! 201cefc <== NOT EXECUTED 2002700: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; } else return; 2002704: a2 10 00 01 mov %g1, %l1 <== NOT EXECUTED /* * XXX HACK to get to interrupt stack */ if (the_thread == (Thread_Control *) -1) { if (Stack_check_Interrupt_stack.area) { 2002708: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200270c: 02 80 00 31 be 20027d0 <== NOT EXECUTED 2002710: b0 10 20 00 clr %i0 <== NOT EXECUTED else return; } else stack = &the_thread->Start.Initial_stack; low = Stack_check_usable_stack_start(stack); 2002714: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 2002718: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED else return; } else stack = &the_thread->Start.Initial_stack; low = Stack_check_usable_stack_start(stack); 200271c: a0 00 60 10 add %g1, 0x10, %l0 <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 2002720: a4 00 bf f0 add %g2, -16, %l2 <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 2002724: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2002728: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 200272c: 7f ff ff d9 call 2002690 <== NOT EXECUTED 2002730: a6 10 20 00 clr %l3 <== NOT EXECUTED if ( high_water_mark ) 2002734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002738: 02 80 00 03 be 2002744 <== NOT EXECUTED 200273c: 82 04 00 12 add %l0, %l2, %g1 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 2002740: a6 20 40 08 sub %g1, %o0, %l3 <== NOT EXECUTED else used = 0; if ( the_thread ) { 2002744: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 2002748: 02 80 00 07 be 2002764 <== NOT EXECUTED 200274c: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002750: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED 2002754: 40 00 10 21 call 20067d8 <== NOT EXECUTED 2002758: 94 07 bf f3 add %fp, -13, %o2 <== NOT EXECUTED name[ 2 ] = 'T'; name[ 3 ] = 'R'; name[ 4 ] = '\0'; } (*print_handler)( 200275c: 10 80 00 0c b 200278c <== NOT EXECUTED 2002760: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED used = 0; if ( the_thread ) { rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); } else { name[ 0 ] = 'I'; 2002764: 82 10 20 49 mov 0x49, %g1 <== NOT EXECUTED 2002768: c2 2f bf f3 stb %g1, [ %fp + -13 ] <== NOT EXECUTED name[ 1 ] = 'N'; 200276c: 82 10 20 4e mov 0x4e, %g1 <== NOT EXECUTED 2002770: c2 2f bf f4 stb %g1, [ %fp + -12 ] <== NOT EXECUTED name[ 2 ] = 'T'; 2002774: 82 10 20 54 mov 0x54, %g1 <== NOT EXECUTED name[ 3 ] = 'R'; name[ 4 ] = '\0'; 2002778: c0 2f bf f7 clrb [ %fp + -9 ] <== NOT EXECUTED if ( the_thread ) { rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); } else { name[ 0 ] = 'I'; name[ 1 ] = 'N'; name[ 2 ] = 'T'; 200277c: c2 2f bf f5 stb %g1, [ %fp + -11 ] <== NOT EXECUTED name[ 3 ] = 'R'; 2002780: 82 10 20 52 mov 0x52, %g1 <== NOT EXECUTED 2002784: c2 2f bf f6 stb %g1, [ %fp + -10 ] <== NOT EXECUTED name[ 4 ] = '\0'; } (*print_handler)( 2002788: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED 200278c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 2002790: c4 00 63 84 ld [ %g1 + 0x384 ], %g2 <== NOT EXECUTED 2002794: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 2002798: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED 200279c: 02 80 00 03 be 20027a8 <== NOT EXECUTED 20027a0: d0 00 63 80 ld [ %g1 + 0x380 ], %o0 ! 201cb80 <== NOT EXECUTED 20027a4: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED 20027a8: da 04 40 00 ld [ %l1 ], %o5 <== NOT EXECUTED 20027ac: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED 20027b0: 13 00 80 68 sethi %hi(0x201a000), %o1 <== NOT EXECUTED 20027b4: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED 20027b8: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED 20027bc: e6 23 a0 60 st %l3, [ %sp + 0x60 ] <== NOT EXECUTED 20027c0: 9a 03 7f ff add %o5, -1, %o5 <== NOT EXECUTED 20027c4: 92 12 61 48 or %o1, 0x148, %o1 <== NOT EXECUTED 20027c8: 9f c0 80 00 call %g2 <== NOT EXECUTED 20027cc: 96 07 bf f3 add %fp, -13, %o3 <== NOT EXECUTED 20027d0: 81 c7 e0 08 ret <== NOT EXECUTED 20027d4: 81 e8 00 00 restore <== NOT EXECUTED 02002690 : /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 2002690: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 2002694: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED if (*base != U32_PATTERN) 2002698: 03 29 69 69 sethi %hi(0xa5a5a400), %g1 <== NOT EXECUTED * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) 200269c: 84 02 00 09 add %o0, %o1, %g2 <== NOT EXECUTED if (*base != U32_PATTERN) 20026a0: 10 80 00 06 b 20026b8 <== NOT EXECUTED 20026a4: 86 10 61 a5 or %g1, 0x1a5, %g3 <== NOT EXECUTED 20026a8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20026ac: 12 80 00 07 bne 20026c8 <== NOT EXECUTED 20026b0: 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++) 20026b4: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 20026b8: 80 a2 00 02 cmp %o0, %g2 <== NOT EXECUTED 20026bc: 2a bf ff fb bcs,a 20026a8 <== NOT EXECUTED 20026c0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 20026c4: 90 10 20 00 clr %o0 <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 20026c8: 81 c3 e0 08 retl <== NOT EXECUTED 20026cc: 01 00 00 00 nop 0200288c : */ void Stack_check_report_blown_task( Thread_Control *running, boolean pattern_ok ) { 200288c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; printk( 2002890: d4 1e 20 08 ldd [ %i0 + 8 ], %o2 <== NOT EXECUTED 2002894: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002898: 11 00 80 68 sethi %hi(0x201a000), %o0 <== NOT EXECUTED 200289c: 40 00 05 b9 call 2003f80 <== NOT EXECUTED 20028a0: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 201a1d0 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 20028a4: d4 06 20 d4 ld [ %i0 + 0xd4 ], %o2 <== NOT EXECUTED 20028a8: c2 06 20 d0 ld [ %i0 + 0xd0 ], %g1 <== NOT EXECUTED 20028ac: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 20028b0: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 20028b4: 94 02 80 01 add %o2, %g1, %o2 <== NOT EXECUTED 20028b8: 11 00 80 68 sethi %hi(0x201a000), %o0 <== NOT EXECUTED 20028bc: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 20028c0: 40 00 05 b0 call 2003f80 <== NOT EXECUTED 20028c4: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 20028c8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 20028cc: 12 80 00 07 bne 20028e8 <== NOT EXECUTED 20028d0: 11 00 80 68 sethi %hi(0x201a000), %o0 <== NOT EXECUTED printk( 20028d4: d2 06 20 d4 ld [ %i0 + 0xd4 ], %o1 <== NOT EXECUTED 20028d8: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 20028dc: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 20028e0: 40 00 05 a8 call 2003f80 <== NOT EXECUTED 20028e4: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED " Damaged pattern begins at 0x%08lx and is %ld bytes long\n", (unsigned long) Stack_check_Get_pattern_area(stack), (long) PATTERN_SIZE_BYTES); } rtems_fatal_error_occurred( 0x81 ); 20028e8: 40 00 13 b7 call 20077c4 <== NOT EXECUTED 20028ec: 91 e8 20 81 restore %g0, 0x81, %o0 <== NOT EXECUTED 20028f0: 01 00 00 00 nop 02006778 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2006778: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 200677c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006780: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_API_extensions_List> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2006784: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006788: 10 80 00 08 b 20067a8 <_API_extensions_Run_postdriver+0x30> 200678c: a2 10 61 84 or %g1, 0x184, %l1 ! 2018d84 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 2006790: 80 a0 60 00 cmp %g1, 0 2006794: 22 80 00 05 be,a 20067a8 <_API_extensions_Run_postdriver+0x30> 2006798: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 200679c: 9f c0 40 00 call %g1 20067a0: 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 ) { 20067a4: 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 ) ; 20067a8: 80 a4 00 11 cmp %l0, %l1 20067ac: 32 bf ff f9 bne,a 2006790 <_API_extensions_Run_postdriver+0x18> 20067b0: c2 04 20 0c ld [ %l0 + 0xc ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 20067b4: 81 c7 e0 08 ret 20067b8: 81 e8 00 00 restore 0200681c <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 200681c: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006820: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006824: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_API_extensions_List> the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); 2006828: 23 00 80 62 sethi %hi(0x2018800), %l1 200682c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006830: 10 80 00 08 b 2006850 <_API_extensions_Run_postswitch+0x34> 2006834: a4 10 61 84 or %g1, 0x184, %l2 ! 2018d84 <_API_extensions_List+0x4> !_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 ) 2006838: 80 a0 60 00 cmp %g1, 0 200683c: 22 80 00 05 be,a 2006850 <_API_extensions_Run_postswitch+0x34> 2006840: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 2006844: 9f c0 40 00 call %g1 2006848: d0 04 63 d0 ld [ %l1 + 0x3d0 ], %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 ) { 200684c: 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 ) ; 2006850: 80 a4 00 12 cmp %l0, %l2 2006854: 32 bf ff f9 bne,a 2006838 <_API_extensions_Run_postswitch+0x1c> 2006858: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 200685c: 81 c7 e0 08 ret 2006860: 81 e8 00 00 restore 020067d8 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 20067d8: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 20067dc: 03 00 80 63 sethi %hi(0x2018c00), %g1 20067e0: e0 00 61 80 ld [ %g1 + 0x180 ], %l0 ! 2018d80 <_API_extensions_List> 20067e4: 03 00 80 63 sethi %hi(0x2018c00), %g1 20067e8: 10 80 00 08 b 2006808 <_API_extensions_Run_predriver+0x30> 20067ec: a2 10 61 84 or %g1, 0x184, %l1 ! 2018d84 <_API_extensions_List+0x4> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 20067f0: 80 a0 60 00 cmp %g1, 0 20067f4: 22 80 00 05 be,a 2006808 <_API_extensions_Run_predriver+0x30> 20067f8: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 20067fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006800: 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 ) { 2006804: 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 ) ; 2006808: 80 a4 00 11 cmp %l0, %l1 200680c: 32 bf ff f9 bne,a 20067f0 <_API_extensions_Run_predriver+0x18> 2006810: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 2006814: 81 c7 e0 08 ret 2006818: 81 e8 00 00 restore 02008af4 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 2008af4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 2008af8: 03 00 80 6d sethi %hi(0x201b400), %g1 * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 2008afc: 7f ff e8 43 call 2002c08 2008b00: e0 00 62 c0 ld [ %g1 + 0x2c0 ], %l0 ! 201b6c0 <_Thread_Executing> 2008b04: 84 10 00 08 mov %o0, %g2 switch ( the_rwlock->current_state ) { 2008b08: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2008b0c: 80 a0 60 01 cmp %g1, 1 2008b10: 22 80 00 0e be,a 2008b48 <_CORE_RWLock_Release+0x54> 2008b14: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2008b18: 0a 80 00 06 bcs 2008b30 <_CORE_RWLock_Release+0x3c> 2008b1c: 80 a0 60 02 cmp %g1, 2 2008b20: 32 80 00 13 bne,a 2008b6c <_CORE_RWLock_Release+0x78> 2008b24: c0 26 20 44 clr [ %i0 + 0x44 ] <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; break; case CORE_RWLOCK_LOCKED_FOR_WRITING: executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 2008b28: 10 80 00 10 b 2008b68 <_CORE_RWLock_Release+0x74> 2008b2c: c0 24 20 34 clr [ %l0 + 0x34 ] */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: _ISR_Enable( level ); 2008b30: 7f ff e8 3a call 2002c18 <== NOT EXECUTED 2008b34: b0 10 20 00 clr %i0 <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 2008b38: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2008b3c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED 2008b40: 81 c7 e0 08 ret <== NOT EXECUTED 2008b44: 81 e8 00 00 restore <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; 2008b48: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 2008b4c: 80 a0 60 00 cmp %g1, 0 2008b50: 02 80 00 05 be 2008b64 <_CORE_RWLock_Release+0x70> 2008b54: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* must be unlocked again */ _ISR_Enable( level ); 2008b58: 7f ff e8 30 call 2002c18 2008b5c: b0 10 20 00 clr %i0 2008b60: 30 80 00 25 b,a 2008bf4 <_CORE_RWLock_Release+0x100> return CORE_RWLOCK_SUCCESSFUL; } executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; break; case CORE_RWLOCK_LOCKED_FOR_WRITING: executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 2008b64: c0 24 20 34 clr [ %l0 + 0x34 ] /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 2008b68: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 2008b6c: 7f ff e8 2b call 2002c18 2008b70: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 2008b74: 40 00 09 76 call 200b14c <_Thread_queue_Dequeue> 2008b78: 90 10 00 18 mov %i0, %o0 if ( next ) { 2008b7c: 80 a2 20 00 cmp %o0, 0 2008b80: 22 80 00 1d be,a 2008bf4 <_CORE_RWLock_Release+0x100> 2008b84: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 2008b88: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2008b8c: 80 a0 60 01 cmp %g1, 1 2008b90: 32 80 00 05 bne,a 2008ba4 <_CORE_RWLock_Release+0xb0> 2008b94: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 2008b98: 82 10 20 02 mov 2, %g1 2008b9c: 10 80 00 15 b 2008bf0 <_CORE_RWLock_Release+0xfc> 2008ba0: c2 26 20 44 st %g1, [ %i0 + 0x44 ] /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 2008ba4: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 2008ba8: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 2008bac: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 2008bb0: c2 26 20 48 st %g1, [ %i0 + 0x48 ] /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 2008bb4: 40 00 0a fa call 200b79c <_Thread_queue_First> 2008bb8: 90 10 00 18 mov %i0, %o0 if ( !next || 2008bbc: 80 a2 20 00 cmp %o0, 0 2008bc0: 22 80 00 0d be,a 2008bf4 <_CORE_RWLock_Release+0x100> 2008bc4: b0 10 20 00 clr %i0 2008bc8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2008bcc: 80 a0 60 01 cmp %g1, 1 2008bd0: 02 80 00 08 be 2008bf0 <_CORE_RWLock_Release+0xfc> 2008bd4: 92 10 00 08 mov %o0, %o1 next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 2008bd8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 2008bdc: 90 10 00 18 mov %i0, %o0 while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 2008be0: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 2008be4: 40 00 0a 81 call 200b5e8 <_Thread_queue_Extract> 2008be8: c2 26 20 48 st %g1, [ %i0 + 0x48 ] 2008bec: 30 bf ff f2 b,a 2008bb4 <_CORE_RWLock_Release+0xc0> } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2008bf0: b0 10 20 00 clr %i0 2008bf4: 81 c7 e0 08 ret 2008bf8: 81 e8 00 00 restore 02008bfc <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 2008bfc: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2008c00: 92 96 20 00 orcc %i0, 0, %o1 2008c04: 12 80 00 0a bne 2008c2c <_CORE_RWLock_Timeout+0x30> 2008c08: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008c0c: 03 00 80 6d sethi %hi(0x201b400), %g1 <== NOT EXECUTED 2008c10: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008c14: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008c18: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] <== NOT EXECUTED 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; 2008c1c: 03 00 80 6d sethi %hi(0x201b400), %g1 <== NOT EXECUTED 2008c20: d2 00 62 c0 ld [ %g1 + 0x2c0 ], %o1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 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; 2008c24: 10 80 00 18 b 2008c84 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 2008c28: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2008c2c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2008c30: 80 a0 a0 04 cmp %g2, 4 2008c34: 18 80 00 0e bgu 2008c6c <_CORE_RWLock_Timeout+0x70> 2008c38: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2008c3c: 83 32 60 1b srl %o1, 0x1b, %g1 2008c40: 80 a0 60 01 cmp %g1, 1 2008c44: 12 80 00 0a bne 2008c6c <_CORE_RWLock_Timeout+0x70> 2008c48: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008c4c: 83 28 a0 02 sll %g2, 2, %g1 2008c50: 05 00 80 6d sethi %hi(0x201b400), %g2 2008c54: 84 10 a1 40 or %g2, 0x140, %g2 ! 201b540 <_Objects_Information_table> 2008c58: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2008c5c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2008c60: 80 a2 20 00 cmp %o0, 0 2008c64: 12 80 00 05 bne 2008c78 <_CORE_RWLock_Timeout+0x7c> 2008c68: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008c6c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008c70: 10 80 00 05 b 2008c84 <_CORE_RWLock_Timeout+0x88> <== NOT EXECUTED 2008c74: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008c78: 40 00 03 46 call 2009990 <_Objects_Get> 2008c7c: 94 07 bf f4 add %fp, -12, %o2 2008c80: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008c84: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008c88: 80 a0 60 00 cmp %g1, 0 2008c8c: 12 80 00 18 bne 2008cec <_CORE_RWLock_Timeout+0xf0> 2008c90: 01 00 00 00 nop */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 2008c94: c4 02 60 44 ld [ %o1 + 0x44 ], %g2 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 2008c98: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 2008c9c: 80 a0 e0 00 cmp %g3, 0 2008ca0: 02 80 00 0b be 2008ccc <_CORE_RWLock_Timeout+0xd0> 2008ca4: 03 00 80 6d sethi %hi(0x201b400), %g1 2008ca8: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 2008cac: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 2008cb0: 32 80 00 08 bne,a 2008cd0 <_CORE_RWLock_Timeout+0xd4> <== NOT EXECUTED 2008cb4: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 2008cb8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008cbc: 02 80 00 08 be 2008cdc <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 2008cc0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2008cc4: 10 80 00 06 b 2008cdc <_CORE_RWLock_Timeout+0xe0> <== NOT EXECUTED 2008cc8: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2008ccc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2008cd0: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 2008cd4: 40 00 0a 45 call 200b5e8 <_Thread_queue_Extract> 2008cd8: c2 22 60 34 st %g1, [ %o1 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2008cdc: 05 00 80 6d sethi %hi(0x201b400), %g2 2008ce0: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 201b5e0 <_Thread_Dispatch_disable_level> 2008ce4: 82 00 7f ff add %g1, -1, %g1 2008ce8: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] 2008cec: 81 c7 e0 08 ret 2008cf0: 81 e8 00 00 restore 02013524 <_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 ) { 2013524: 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 ) { 2013528: 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 ) { 201352c: 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 ) { 2013530: 80 a6 80 01 cmp %i2, %g1 2013534: 18 80 00 17 bgu 2013590 <_CORE_message_queue_Broadcast+0x6c> 2013538: 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 ) { 201353c: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 2013540: 80 a0 60 00 cmp %g1, 0 2013544: 02 80 00 0a be 201356c <_CORE_message_queue_Broadcast+0x48> 2013548: a2 10 20 00 clr %l1 *count = 0; 201354c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 2013550: 81 c7 e0 08 ret <== NOT EXECUTED 2013554: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2013558: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 201355c: 40 00 23 64 call 201c2ec 2013560: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 2013564: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2013568: 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))) { 201356c: 40 00 0b 7f call 2016368 <_Thread_queue_Dequeue> 2013570: 90 10 00 12 mov %l2, %o0 2013574: 92 10 00 19 mov %i1, %o1 2013578: a0 10 00 08 mov %o0, %l0 201357c: 80 a2 20 00 cmp %o0, 0 2013580: 12 bf ff f6 bne 2013558 <_CORE_message_queue_Broadcast+0x34> 2013584: 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; 2013588: e2 27 40 00 st %l1, [ %i5 ] 201358c: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 2013590: 81 c7 e0 08 ret 2013594: 81 e8 00 00 restore 02013a34 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, uint32_t maximum_message_size ) { 2013a34: 9d e3 bf 98 save %sp, -104, %sp uint32_t message_buffering_required; uint32_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; the_message_queue->number_of_pending_messages = 0; 2013a38: c0 26 20 48 clr [ %i0 + 0x48 ] ) { uint32_t message_buffering_required; uint32_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 2013a3c: 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; 2013a40: 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; 2013a44: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 2013a48: 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)) { 2013a4c: 80 8e e0 03 btst 3, %i3 2013a50: 02 80 00 07 be 2013a6c <_CORE_message_queue_Initialize+0x38> 2013a54: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 2013a58: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 2013a5c: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 2013a60: 80 a4 00 1b cmp %l0, %i3 2013a64: 0a 80 00 24 bcs 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a68: 01 00 00 00 nop /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = maximum_pending_messages * 2013a6c: b6 04 20 14 add %l0, 0x14, %i3 2013a70: 92 10 00 1a mov %i2, %o1 2013a74: 40 00 29 f0 call 201e234 <.umul> 2013a78: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 2013a7c: 80 a2 00 10 cmp %o0, %l0 2013a80: 0a 80 00 1d bcs 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a84: 92 10 00 08 mov %o0, %o1 2013a88: 11 00 80 8e sethi %hi(0x2023800), %o0 2013a8c: 7f ff e7 51 call 200d7d0 <_Heap_Allocate> 2013a90: 90 12 21 9c or %o0, 0x19c, %o0 ! 202399c <_Workspace_Area> * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 2013a94: 80 a2 20 00 cmp %o0, 0 2013a98: 02 80 00 17 be 2013af4 <_CORE_message_queue_Initialize+0xc0> 2013a9c: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 2013aa0: 92 10 00 08 mov %o0, %o1 2013aa4: 94 10 00 1a mov %i2, %o2 2013aa8: 90 06 20 68 add %i0, 0x68, %o0 2013aac: 7f ff ff 88 call 20138cc <_Chain_Initialize> 2013ab0: 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( 2013ab4: c2 06 40 00 ld [ %i1 ], %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2013ab8: c0 26 20 54 clr [ %i0 + 0x54 ] 2013abc: 82 18 60 01 xor %g1, 1, %g1 2013ac0: 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); 2013ac4: 82 06 20 54 add %i0, 0x54, %g1 2013ac8: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2013acc: 82 06 20 50 add %i0, 0x50, %g1 2013ad0: 90 10 00 18 mov %i0, %o0 2013ad4: c2 26 20 58 st %g1, [ %i0 + 0x58 ] 2013ad8: 92 60 3f ff subx %g0, -1, %o1 2013adc: 94 10 20 80 mov 0x80, %o2 2013ae0: 96 10 20 06 mov 6, %o3 2013ae4: 7f ff f1 1b call 200ff50 <_Thread_queue_Initialize> 2013ae8: b0 10 20 01 mov 1, %i0 2013aec: 81 c7 e0 08 ret 2013af0: 81 e8 00 00 restore STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 2013af4: 81 c7 e0 08 ret <== NOT EXECUTED 2013af8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020135c0 <_CORE_message_queue_Seize>: void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 20135c0: 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; 20135c4: 03 00 80 9e sethi %hi(0x2027800), %g1 20135c8: e2 00 63 30 ld [ %g1 + 0x330 ], %l1 ! 2027b30 <_Thread_Executing> void *buffer, size_t *size, boolean wait, Watchdog_Interval timeout ) { 20135cc: a0 10 00 18 mov %i0, %l0 Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); 20135d0: 7f ff bb cd call 2002504 20135d4: c0 24 60 34 clr [ %l1 + 0x34 ] 20135d8: 86 10 00 08 mov %o0, %g3 if ( the_message_queue->number_of_pending_messages != 0 ) { 20135dc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20135e0: 80 a0 60 00 cmp %g1, 0 20135e4: 02 80 00 2a be 201368c <_CORE_message_queue_Seize+0xcc> 20135e8: 80 a7 20 00 cmp %i4, 0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 20135ec: f2 06 20 50 ld [ %i0 + 0x50 ], %i1 the_message_queue->number_of_pending_messages -= 1; 20135f0: 82 00 7f ff add %g1, -1, %g1 20135f4: c2 26 20 48 st %g1, [ %i0 + 0x48 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 20135f8: 82 06 20 54 add %i0, 0x54, %g1 20135fc: 80 a6 40 01 cmp %i1, %g1 2013600: 32 80 00 04 bne,a 2013610 <_CORE_message_queue_Seize+0x50> 2013604: c2 06 40 00 ld [ %i1 ], %g1 2013608: 10 80 00 05 b 201361c <_CORE_message_queue_Seize+0x5c> <== NOT EXECUTED 201360c: b2 10 20 00 clr %i1 <== NOT EXECUTED Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; new_first->previous = _Chain_Head(the_chain); 2013610: 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; the_chain->first = new_first; 2013614: c2 26 20 50 st %g1, [ %i0 + 0x50 ] new_first->previous = _Chain_Head(the_chain); 2013618: c4 20 60 04 st %g2, [ %g1 + 4 ] the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); 201361c: 7f ff bb be call 2002514 2013620: 90 10 00 03 mov %g3, %o0 *size = the_message->Contents.size; 2013624: d4 06 60 0c ld [ %i1 + 0xc ], %o2 _Thread_Executing->Wait.count = the_message->priority; 2013628: 03 00 80 9e sethi %hi(0x2027800), %g1 the_message_queue->number_of_pending_messages -= 1; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; 201362c: d4 26 c0 00 st %o2, [ %i3 ] _Thread_Executing->Wait.count = the_message->priority; 2013630: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 2013634: c2 06 60 08 ld [ %i1 + 8 ], %g1 _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2013638: 92 10 00 1a mov %i2, %o1 the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); _ISR_Enable( level ); *size = the_message->Contents.size; _Thread_Executing->Wait.count = the_message->priority; 201363c: c2 20 a0 24 st %g1, [ %g2 + 0x24 ] _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size); 2013640: a2 06 60 10 add %i1, 0x10, %l1 2013644: 7f ff ff d8 call 20135a4 <_CORE_message_queue_Copy_buffer> 2013648: 90 10 00 11 mov %l1, %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 ); 201364c: 7f ff e8 ba call 200d934 <_Thread_queue_Dequeue> 2013650: 90 10 00 10 mov %l0, %o0 if ( !the_thread ) { 2013654: 82 92 20 00 orcc %o0, 0, %g1 2013658: 32 80 00 04 bne,a 2013668 <_CORE_message_queue_Seize+0xa8> 201365c: d4 00 60 30 ld [ %g1 + 0x30 ], %o2 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 ); 2013660: 7f ff de 98 call 200b0c0 <_Chain_Append> 2013664: 91 ec 20 68 restore %l0, 0x68, %o0 * waiting task. */ the_message->priority = the_thread->Wait.count; the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 2013668: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 201366c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 the_message->Contents.size = (uint32_t)the_thread->Wait.option; 2013670: d4 26 60 0c st %o2, [ %i1 + 0xc ] * 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; 2013674: c2 26 60 08 st %g1, [ %i1 + 8 ] the_message->Contents.size = (uint32_t)the_thread->Wait.option; _CORE_message_queue_Copy_buffer( 2013678: 7f ff ff cb call 20135a4 <_CORE_message_queue_Copy_buffer> 201367c: 92 10 00 11 mov %l1, %o1 the_thread->Wait.return_argument, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 2013680: f4 06 60 08 ld [ %i1 + 8 ], %i2 2013684: 40 00 0c 20 call 2016704 <_CORE_message_queue_Insert_message> 2013688: 91 e8 00 10 restore %g0, %l0, %o0 the_message->priority ); return; } if ( !wait ) { 201368c: 12 80 00 08 bne 20136ac <_CORE_message_queue_Seize+0xec> 2013690: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 2013694: 7f ff bb a0 call 2002514 2013698: 01 00 00 00 nop executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 201369c: 82 10 20 04 mov 4, %g1 ! 4 20136a0: c2 24 60 34 st %g1, [ %l1 + 0x34 ] executing->Wait.return_argument_1 = (void *)size; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 20136a4: 81 c7 e0 08 ret 20136a8: 81 e8 00 00 restore _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 = buffer; executing->Wait.return_argument_1 = (void *)size; 20136ac: f6 24 60 2c st %i3, [ %l1 + 0x2c ] executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 20136b0: f0 24 60 44 st %i0, [ %l1 + 0x44 ] executing->Wait.id = id; 20136b4: f2 24 60 20 st %i1, [ %l1 + 0x20 ] executing->Wait.return_argument = buffer; 20136b8: f4 24 60 28 st %i2, [ %l1 + 0x28 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 20136bc: c2 26 20 30 st %g1, [ %i0 + 0x30 ] executing->Wait.return_argument_1 = (void *)size; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 20136c0: 7f ff bb 95 call 2002514 20136c4: 35 00 80 37 sethi %hi(0x200dc00), %i2 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 20136c8: b2 10 00 1d mov %i5, %i1 20136cc: 7f ff e9 08 call 200daec <_Thread_queue_Enqueue_with_handler> 20136d0: 95 ee a3 84 restore %i2, 0x384, %o2 20136d4: 01 00 00 00 nop 020136f4 <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, boolean wait, Watchdog_Interval timeout ) { 20136f4: 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 ) { 20136f8: 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, boolean wait, Watchdog_Interval timeout ) { 20136fc: 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 ) { 2013700: 80 a6 80 01 cmp %i2, %g1 2013704: 18 80 00 3f bgu 2013800 <_CORE_message_queue_Submit+0x10c> 2013708: 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 ) { 201370c: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 2013710: 80 a0 60 00 cmp %g1, 0 2013714: 32 80 00 0f bne,a 2013750 <_CORE_message_queue_Submit+0x5c> 2013718: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 201371c: 7f ff e8 86 call 200d934 <_Thread_queue_Dequeue> 2013720: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 2013724: a0 92 20 00 orcc %o0, 0, %l0 2013728: 02 80 00 09 be 201374c <_CORE_message_queue_Submit+0x58> 201372c: 90 10 00 19 mov %i1, %o0 _CORE_message_queue_Copy_buffer( 2013730: d2 04 20 28 ld [ %l0 + 0x28 ], %o1 2013734: 7f ff ff e9 call 20136d8 <_CORE_message_queue_Copy_buffer> 2013738: 94 10 00 1a mov %i2, %o2 buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 201373c: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 2013740: fa 24 20 24 st %i5, [ %l0 + 0x24 ] _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 2013744: 10 80 00 15 b 2013798 <_CORE_message_queue_Submit+0xa4> 2013748: f4 20 40 00 st %i2, [ %g1 ] /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 201374c: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 2013750: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 2013754: 80 a0 80 01 cmp %g2, %g1 2013758: 1a 80 00 12 bcc 20137a0 <_CORE_message_queue_Submit+0xac> 201375c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 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 *) 2013760: 7f ff de 64 call 200b0f0 <_Chain_Get> 2013764: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 2013768: a0 92 20 00 orcc %o0, 0, %l0 201376c: 02 80 00 27 be 2013808 <_CORE_message_queue_Submit+0x114> 2013770: 90 10 00 19 mov %i1, %o0 return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; } _CORE_message_queue_Copy_buffer( 2013774: 92 04 20 10 add %l0, 0x10, %o1 2013778: 7f ff ff d8 call 20136d8 <_CORE_message_queue_Copy_buffer> 201377c: 94 10 00 1a mov %i2, %o2 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 2013780: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 2013784: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 2013788: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 201378c: 92 10 00 10 mov %l0, %o1 2013790: 40 00 0b dd call 2016704 <_CORE_message_queue_Insert_message> 2013794: 94 10 00 1d mov %i5, %o2 2013798: 81 c7 e0 08 ret 201379c: 91 e8 20 00 restore %g0, 0, %o0 * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 20137a0: 80 a0 60 00 cmp %g1, 0 20137a4: 02 80 00 17 be 2013800 <_CORE_message_queue_Submit+0x10c> 20137a8: 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() ) { 20137ac: 03 00 80 9e sethi %hi(0x2027800), %g1 20137b0: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 2027b18 <_ISR_Nest_level> 20137b4: 80 a0 60 00 cmp %g1, 0 20137b8: 12 80 00 14 bne 2013808 <_CORE_message_queue_Submit+0x114> 20137bc: 03 00 80 9e sethi %hi(0x2027800), %g1 */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 20137c0: 7f ff bb 51 call 2002504 20137c4: e0 00 63 30 ld [ %g1 + 0x330 ], %l0 ! 2027b30 <_Thread_Executing> 20137c8: 82 10 20 01 mov 1, %g1 _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 = buffer; executing->Wait.option = size; executing->Wait.count = submit_type; 20137cc: fa 24 20 24 st %i5, [ %l0 + 0x24 ] 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; 20137d0: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument = buffer; 20137d4: f2 24 20 28 st %i1, [ %l0 + 0x28 ] executing->Wait.option = size; 20137d8: f4 24 20 30 st %i2, [ %l0 + 0x30 ] { 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; 20137dc: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 20137e0: c2 24 60 30 st %g1, [ %l1 + 0x30 ] executing->Wait.id = id; executing->Wait.return_argument = buffer; executing->Wait.option = size; executing->Wait.count = submit_type; _ISR_Enable( level ); 20137e4: 7f ff bb 4c call 2002514 20137e8: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 20137ec: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 20137f0: 90 10 00 11 mov %l1, %o0 20137f4: 15 00 80 37 sethi %hi(0x200dc00), %o2 20137f8: 7f ff e8 bd call 200daec <_Thread_queue_Enqueue_with_handler> 20137fc: 94 12 a3 84 or %o2, 0x384, %o2 ! 200df84 <_Thread_queue_Timeout> 2013800: 81 c7 e0 08 ret 2013804: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 2013808: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED } 201380c: 81 c7 e0 08 ret <== NOT EXECUTED 2013810: 81 e8 00 00 restore <== NOT EXECUTED 0200699c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 200699c: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20069a0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20069a4: 80 a0 60 02 cmp %g1, 2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 20069a8: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 20069ac: 12 80 00 0a bne 20069d4 <_CORE_mutex_Seize_interrupt_blocking+0x38> 20069b0: d2 00 63 d0 ld [ %g1 + 0x3d0 ], %o1 ! 2018bd0 <_Thread_Executing> if ( the_mutex->holder->current_priority > executing->current_priority ) { 20069b4: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 20069b8: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 20069bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 20069c0: 80 a0 40 09 cmp %g1, %o1 20069c4: 28 80 00 05 bleu,a 20069d8 <_CORE_mutex_Seize_interrupt_blocking+0x3c> 20069c8: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_Change_priority( 20069cc: 40 00 07 47 call 20086e8 <_Thread_Change_priority> 20069d0: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 20069d4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069d8: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 20069dc: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069e0: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 20069e4: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 20069e8: 15 00 80 25 sethi %hi(0x2009400), %o2 20069ec: 40 00 0a 13 call 2009238 <_Thread_queue_Enqueue_with_handler> 20069f0: 94 12 a2 d0 or %o2, 0x2d0, %o2 ! 20096d0 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20069f4: 05 00 80 62 sethi %hi(0x2018800), %g2 20069f8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20069fc: 82 00 7f ff add %g1, -1, %g1 2006a00: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2006a04: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2006a08: 80 a0 60 00 cmp %g1, 0 2006a0c: 12 80 00 04 bne 2006a1c <_CORE_mutex_Seize_interrupt_blocking+0x80> 2006a10: 01 00 00 00 nop _Thread_Dispatch(); 2006a14: 40 00 08 72 call 2008bdc <_Thread_Dispatch> 2006a18: 81 e8 00 00 restore 2006a1c: 81 c7 e0 08 ret <== NOT EXECUTED 2006a20: 81 e8 00 00 restore <== NOT EXECUTED 02006a24 <_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 ) { 2006a24: 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 ) { 2006a28: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2006a2c: 80 a0 60 00 cmp %g1, 0 2006a30: 02 80 00 07 be 2006a4c <_CORE_mutex_Surrender+0x28> 2006a34: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006a38: 03 00 80 62 sethi %hi(0x2018800), %g1 2006a3c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2006a40: 80 a2 00 01 cmp %o0, %g1 2006a44: 12 80 00 51 bne 2006b88 <_CORE_mutex_Surrender+0x164> 2006a48: 84 10 20 03 mov 3, %g2 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 2006a4c: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2006a50: 80 a0 60 00 cmp %g1, 0 2006a54: 02 80 00 4c be 2006b84 <_CORE_mutex_Surrender+0x160> 2006a58: 82 00 7f ff add %g1, -1, %g1 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { 2006a5c: 80 a0 60 00 cmp %g1, 0 2006a60: 02 80 00 09 be 2006a84 <_CORE_mutex_Surrender+0x60> 2006a64: c2 26 20 54 st %g1, [ %i0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2006a68: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2006a6c: 80 a0 60 00 cmp %g1, 0 2006a70: 02 80 00 46 be 2006b88 <_CORE_mutex_Surrender+0x164> 2006a74: 84 10 20 00 clr %g2 2006a78: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2006a7c: 02 80 00 43 be 2006b88 <_CORE_mutex_Surrender+0x164> <== NOT EXECUTED 2006a80: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 2006a84: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006a88: 80 a0 60 02 cmp %g1, 2 2006a8c: 22 80 00 06 be,a 2006aa4 <_CORE_mutex_Surrender+0x80> 2006a90: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006a94: 80 a0 60 03 cmp %g1, 3 2006a98: 32 80 00 07 bne,a 2006ab4 <_CORE_mutex_Surrender+0x90> 2006a9c: c0 26 20 5c clr [ %i0 + 0x5c ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 2006aa0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006aa4: 82 00 7f ff add %g1, -1, %g1 2006aa8: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 2006aac: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 the_mutex->holder = NULL; 2006ab0: c0 26 20 5c clr [ %i0 + 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 ) || 2006ab4: 80 a0 60 02 cmp %g1, 2 2006ab8: 02 80 00 05 be 2006acc <_CORE_mutex_Surrender+0xa8> 2006abc: c0 26 20 60 clr [ %i0 + 0x60 ] 2006ac0: 80 a0 60 03 cmp %g1, 3 2006ac4: 12 80 00 0d bne 2006af8 <_CORE_mutex_Surrender+0xd4> 2006ac8: 01 00 00 00 nop _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 2006acc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006ad0: 80 a0 60 00 cmp %g1, 0 2006ad4: 12 80 00 09 bne 2006af8 <_CORE_mutex_Surrender+0xd4> 2006ad8: 01 00 00 00 nop 2006adc: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 2006ae0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006ae4: 80 a2 40 01 cmp %o1, %g1 2006ae8: 02 80 00 04 be 2006af8 <_CORE_mutex_Surrender+0xd4> 2006aec: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 2006af0: 40 00 06 fe call 20086e8 <_Thread_Change_priority> 2006af4: 94 10 20 01 mov 1, %o2 ! 1 /* * 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 ) ) ) { 2006af8: 40 00 09 62 call 2009080 <_Thread_queue_Dequeue> 2006afc: 90 10 00 18 mov %i0, %o0 2006b00: 86 92 20 00 orcc %o0, 0, %g3 2006b04: 02 80 00 1f be 2006b80 <_CORE_mutex_Surrender+0x15c> 2006b08: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006b0c: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 2006b10: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2006b14: c2 26 20 60 st %g1, [ %i0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 2006b18: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 2006b1c: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 2006b20: 80 a0 a0 02 cmp %g2, 2 2006b24: 02 80 00 07 be 2006b40 <_CORE_mutex_Surrender+0x11c> 2006b28: c2 26 20 54 st %g1, [ %i0 + 0x54 ] 2006b2c: 80 a0 a0 03 cmp %g2, 3 2006b30: 12 80 00 16 bne 2006b88 <_CORE_mutex_Surrender+0x164> 2006b34: 84 10 20 00 clr %g2 break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 2006b38: 10 80 00 07 b 2006b54 <_CORE_mutex_Surrender+0x130> 2006b3c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 switch ( the_mutex->Attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; 2006b40: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2006b44: 84 10 20 00 clr %g2 2006b48: 82 00 60 01 inc %g1 2006b4c: 10 80 00 0f b 2006b88 <_CORE_mutex_Surrender+0x164> 2006b50: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 2006b54: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 break; case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; 2006b58: 82 00 60 01 inc %g1 2006b5c: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 2006b60: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 2006b64: 80 a2 40 02 cmp %o1, %g2 2006b68: 3a 80 00 08 bcc,a 2006b88 <_CORE_mutex_Surrender+0x164> 2006b6c: 84 10 20 00 clr %g2 <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 2006b70: 40 00 06 de call 20086e8 <_Thread_Change_priority> 2006b74: 94 10 20 00 clr %o2 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 2006b78: 10 80 00 04 b 2006b88 <_CORE_mutex_Surrender+0x164> 2006b7c: 84 10 20 00 clr %g2 2006b80: c2 26 20 50 st %g1, [ %i0 + 0x50 ] 2006b84: 84 10 20 00 clr %g2 return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006b88: 81 c7 e0 08 ret 2006b8c: 91 e8 00 02 restore %g0, %g2, %o0 0200770c <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 200770c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 2007710: 7f ff eb 35 call 20023e4 2007714: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007718: c2 06 20 04 ld [ %i0 + 4 ], %g1 200771c: 80 a0 60 00 cmp %g1, 0 2007720: 12 80 00 06 bne 2007738 <_CORE_spinlock_Release+0x2c> 2007724: 03 00 80 51 sethi %hi(0x2014400), %g1 _ISR_Enable( level ); 2007728: 7f ff eb 33 call 20023f4 200772c: b0 10 20 06 mov 6, %i0 2007730: 81 c7 e0 08 ret 2007734: 81 e8 00 00 restore } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 2007738: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 200773c: c4 06 20 0c ld [ %i0 + 0xc ], %g2 2007740: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007744: 80 a0 80 01 cmp %g2, %g1 2007748: 02 80 00 06 be 2007760 <_CORE_spinlock_Release+0x54> 200774c: 01 00 00 00 nop _ISR_Enable( level ); 2007750: 7f ff eb 29 call 20023f4 <== NOT EXECUTED 2007754: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 2007758: 81 c7 e0 08 ret <== NOT EXECUTED 200775c: 81 e8 00 00 restore <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 2007760: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007764: 82 00 7f ff add %g1, -1, %g1 2007768: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 200776c: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 2007770: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 2007774: 7f ff eb 20 call 20023f4 2007778: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 200777c: 81 c7 e0 08 ret 2007780: 81 e8 00 00 restore 02007784 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, boolean wait, Watchdog_Interval timeout ) { 2007784: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 2007788: 03 00 80 51 sethi %hi(0x2014400), %g1 200778c: c2 00 63 64 ld [ %g1 + 0x364 ], %g1 ! 2014764 <_Watchdog_Ticks_since_boot> _ISR_Disable( level ); 2007790: 7f ff eb 15 call 20023e4 2007794: a2 06 80 01 add %i2, %g1, %l1 2007798: 86 10 00 08 mov %o0, %g3 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 200779c: c2 06 20 04 ld [ %i0 + 4 ], %g1 20077a0: 80 a0 60 01 cmp %g1, 1 20077a4: 12 80 00 0c bne 20077d4 <_CORE_spinlock_Wait+0x50> 20077a8: 03 00 80 51 sethi %hi(0x2014400), %g1 20077ac: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 20146c0 <_Thread_Executing> 20077b0: c4 06 20 0c ld [ %i0 + 0xc ], %g2 20077b4: c2 00 60 08 ld [ %g1 + 8 ], %g1 20077b8: 80 a0 80 01 cmp %g2, %g1 20077bc: 12 80 00 06 bne 20077d4 <_CORE_spinlock_Wait+0x50> 20077c0: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 20077c4: 7f ff eb 0c call 20023f4 20077c8: b0 10 20 01 mov 1, %i0 ! 1 20077cc: 81 c7 e0 08 ret 20077d0: 81 e8 00 00 restore return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 20077d4: c2 06 20 08 ld [ %i0 + 8 ], %g1 } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 20077d8: 25 00 80 51 sethi %hi(0x2014400), %l2 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 20077dc: 82 00 60 01 inc %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20077e0: 21 00 80 51 sethi %hi(0x2014400), %l0 20077e4: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 20077e8: c2 06 20 04 ld [ %i0 + 4 ], %g1 20077ec: 80 a0 60 00 cmp %g1, 0 20077f0: 12 80 00 0d bne 2007824 <_CORE_spinlock_Wait+0xa0> 20077f4: 80 a6 60 00 cmp %i1, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 20077f8: 03 00 80 51 sethi %hi(0x2014400), %g1 20077fc: c4 00 62 c0 ld [ %g1 + 0x2c0 ], %g2 ! 20146c0 <_Thread_Executing> return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { the_spinlock->lock = CORE_SPINLOCK_LOCKED; 2007800: 82 10 20 01 mov 1, %g1 2007804: c2 26 20 04 st %g1, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 2007808: c2 00 a0 08 ld [ %g2 + 8 ], %g1 200780c: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 2007810: b0 10 20 00 clr %i0 2007814: 7f ff ea f8 call 20023f4 2007818: 90 10 00 03 mov %g3, %o0 200781c: 81 c7 e0 08 ret 2007820: 81 e8 00 00 restore } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 2007824: 12 80 00 0a bne 200784c <_CORE_spinlock_Wait+0xc8> 2007828: 80 a6 a0 00 cmp %i2, 0 the_spinlock->users -= 1; 200782c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007830: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007834: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007838: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200783c: 7f ff ea ee call 20023f4 <== NOT EXECUTED 2007840: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 2007844: 81 c7 e0 08 ret <== NOT EXECUTED 2007848: 81 e8 00 00 restore <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 200784c: 02 80 00 0e be 2007884 <_CORE_spinlock_Wait+0x100> 2007850: 01 00 00 00 nop 2007854: c2 04 a3 64 ld [ %l2 + 0x364 ], %g1 <== NOT EXECUTED 2007858: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200785c: 18 80 00 0a bgu 2007884 <_CORE_spinlock_Wait+0x100> <== NOT EXECUTED 2007860: 01 00 00 00 nop <== NOT EXECUTED the_spinlock->users -= 1; 2007864: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007868: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200786c: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007870: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 2007874: 7f ff ea e0 call 20023f4 <== NOT EXECUTED 2007878: 90 10 00 03 mov %g3, %o0 <== NOT EXECUTED 200787c: 81 c7 e0 08 ret <== NOT EXECUTED 2007880: 81 e8 00 00 restore <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 2007884: 7f ff ea dc call 20023f4 2007888: 90 10 00 03 mov %g3, %o0 200788c: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 2007890: 82 00 7f ff add %g1, -1, %g1 2007894: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] 2007898: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 200789c: 80 a0 60 00 cmp %g1, 0 20078a0: 12 80 00 04 bne 20078b0 <_CORE_spinlock_Wait+0x12c> 20078a4: 01 00 00 00 nop _Thread_Dispatch(); 20078a8: 40 00 07 b5 call 200977c <_Thread_Dispatch> 20078ac: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20078b0: c2 04 21 e0 ld [ %l0 + 0x1e0 ], %g1 20078b4: 82 00 60 01 inc %g1 20078b8: c2 24 21 e0 st %g1, [ %l0 + 0x1e0 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 20078bc: 7f ff ea ca call 20023e4 20078c0: 01 00 00 00 nop 20078c4: 86 10 00 08 mov %o0, %g3 20078c8: 30 bf ff c8 b,a 20077e8 <_CORE_spinlock_Wait+0x64> 0200ca9c <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 200ca9c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200caa0: c2 00 63 d4 ld [ %g1 + 0x3d4 ], %g1 ! 2018bd4 <_Debug_Level> <== NOT EXECUTED 200caa4: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 200caa8: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200caac: 81 c3 e0 08 retl <== NOT EXECUTED 200cab0: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 020050cc <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 20050cc: 9d e3 bf 98 save %sp, -104, %sp rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Event_Sync_states sync_state; executing = _Thread_Executing; 20050d0: 03 00 80 62 sethi %hi(0x2018800), %g1 20050d4: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 20050d8: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 20050dc: 7f ff f3 20 call 2001d5c 20050e0: e4 04 21 70 ld [ %l0 + 0x170 ], %l2 20050e4: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 20050e8: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 20050ec: a2 8e 00 01 andcc %i0, %g1, %l1 20050f0: 02 80 00 0e be 2005128 <_Event_Seize+0x5c> 20050f4: 80 8e 60 01 btst 1, %i1 20050f8: 80 a4 40 18 cmp %l1, %i0 20050fc: 02 80 00 04 be 200510c <_Event_Seize+0x40> 2005100: 80 8e 60 02 btst 2, %i1 2005104: 02 80 00 09 be 2005128 <_Event_Seize+0x5c> 2005108: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 200510c: 82 28 40 11 andn %g1, %l1, %g1 2005110: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 2005114: 7f ff f3 16 call 2001d6c 2005118: 01 00 00 00 nop 200511c: e2 26 c0 00 st %l1, [ %i3 ] 2005120: 81 c7 e0 08 ret 2005124: 81 e8 00 00 restore *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 2005128: 22 80 00 09 be,a 200514c <_Event_Seize+0x80> 200512c: 23 00 80 65 sethi %hi(0x2019400), %l1 _ISR_Enable( level ); 2005130: 7f ff f3 0f call 2001d6c 2005134: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 2005138: 82 10 20 0d mov 0xd, %g1 200513c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 2005140: e2 26 c0 00 st %l1, [ %i3 ] 2005144: 81 c7 e0 08 ret 2005148: 81 e8 00 00 restore return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 200514c: 82 10 20 01 mov 1, %g1 executing->Wait.option = (uint32_t ) option_set; 2005150: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 2005154: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 2005158: f6 24 20 28 st %i3, [ %l0 + 0x28 ] executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 200515c: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 2005160: 7f ff f3 03 call 2001d6c 2005164: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 2005168: 80 a6 a0 00 cmp %i2, 0 200516c: 02 80 00 0f be 20051a8 <_Event_Seize+0xdc> 2005170: 90 10 00 10 mov %l0, %o0 _Watchdog_Initialize( 2005174: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005178: 11 00 80 62 sethi %hi(0x2018800), %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200517c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005180: 03 00 80 15 sethi %hi(0x2005400), %g1 2005184: 82 10 60 54 or %g1, 0x54, %g1 ! 2005454 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2005188: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200518c: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2005190: c0 24 20 6c clr [ %l0 + 0x6c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005194: c2 24 20 64 st %g1, [ %l0 + 0x64 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005198: 90 12 23 f0 or %o0, 0x3f0, %o0 200519c: 40 00 13 a1 call 200a020 <_Watchdog_Insert> 20051a0: 92 04 20 48 add %l0, 0x48, %o1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20051a4: 90 10 00 10 mov %l0, %o0 20051a8: 40 00 11 a2 call 2009830 <_Thread_Set_state> 20051ac: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20051b0: 7f ff f2 eb call 2001d5c 20051b4: 01 00 00 00 nop 20051b8: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20051bc: c4 04 60 d4 ld [ %l1 + 0xd4 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20051c0: c0 24 60 d4 clr [ %l1 + 0xd4 ] switch ( sync_state ) { 20051c4: 80 a0 a0 02 cmp %g2, 2 20051c8: 02 80 00 08 be 20051e8 <_Event_Seize+0x11c> 20051cc: 80 a0 a0 03 cmp %g2, 3 20051d0: 02 80 00 09 be 20051f4 <_Event_Seize+0x128> 20051d4: 80 a0 a0 01 cmp %g2, 1 20051d8: 12 80 00 15 bne 200522c <_Event_Seize+0x160> 20051dc: 01 00 00 00 nop * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 20051e0: 7f ff f2 e3 call 2001d6c 20051e4: 81 e8 00 00 restore return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 20051e8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20051ec: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20051f0: 30 80 00 0b b,a 200521c <_Event_Seize+0x150> <== NOT EXECUTED _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 20051f4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20051f8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20051fc: 12 80 00 08 bne 200521c <_Event_Seize+0x150> <== NOT EXECUTED 2005200: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2005204: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 2005208: 7f ff f2 d9 call 2001d6c <== NOT EXECUTED 200520c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 2005210: 40 00 13 dc call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 2005214: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 2005218: 30 80 00 03 b,a 2005224 <_Event_Seize+0x158> <== NOT EXECUTED } else _ISR_Enable( level ); 200521c: 7f ff f2 d4 call 2001d6c <== NOT EXECUTED 2005220: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED _Thread_Unblock( executing ); 2005224: 7f ff ff a4 call 20050b4 <_Thread_Unblock> <== NOT EXECUTED 2005228: 81 e8 00 00 restore <== NOT EXECUTED 200522c: 81 c7 e0 08 ret <== NOT EXECUTED 2005230: 81 e8 00 00 restore <== NOT EXECUTED 0200534c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 200534c: 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 ]; 2005350: e2 06 21 70 ld [ %i0 + 0x170 ], %l1 option_set = (rtems_option) the_thread->Wait.option; 2005354: e6 06 20 30 ld [ %i0 + 0x30 ], %l3 _ISR_Disable( level ); 2005358: 7f ff f2 81 call 2001d5c 200535c: a0 10 00 18 mov %i0, %l0 2005360: a4 10 00 08 mov %o0, %l2 pending_events = api->pending_events; 2005364: c8 04 60 40 ld [ %l1 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 2005368: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 200536c: 86 88 80 04 andcc %g2, %g4, %g3 2005370: 02 80 00 36 be 2005448 <_Event_Surrender+0xfc> 2005374: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 2005378: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 200537c: 80 88 61 00 btst 0x100, %g1 2005380: 02 80 00 1e be 20053f8 <_Event_Surrender+0xac> 2005384: 1b 00 80 65 sethi %hi(0x2019400), %o5 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 2005388: 80 a0 c0 02 cmp %g3, %g2 200538c: 02 80 00 04 be 200539c <_Event_Surrender+0x50> 2005390: 80 8c e0 02 btst 2, %l3 2005394: 02 80 00 19 be 20053f8 <_Event_Surrender+0xac> 2005398: 01 00 00 00 nop api->pending_events = 200539c: 82 29 00 03 andn %g4, %g3, %g1 20053a0: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20053a4: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 if ( !_Event_sets_Is_empty( seized_events ) ) { if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 20053a8: c0 24 20 24 clr [ %l0 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20053ac: c6 20 40 00 st %g3, [ %g1 ] _ISR_Flash( level ); 20053b0: 7f ff f2 6f call 2001d6c 20053b4: 01 00 00 00 nop 20053b8: 7f ff f2 69 call 2001d5c 20053bc: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20053c0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 20053c4: 80 a0 60 02 cmp %g1, 2 20053c8: 02 80 00 05 be 20053dc <_Event_Surrender+0x90> 20053cc: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20053d0: 7f ff f2 67 call 2001d6c 20053d4: 90 10 00 12 mov %l2, %o0 20053d8: 30 80 00 06 b,a 20053f0 <_Event_Surrender+0xa4> 20053dc: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20053e0: 7f ff f2 63 call 2001d6c 20053e4: 90 10 00 12 mov %l2, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 20053e8: 40 00 13 66 call 200a180 <_Watchdog_Remove> 20053ec: 90 04 20 48 add %l0, 0x48, %o0 _Thread_Unblock( the_thread ); 20053f0: 7f ff ff d1 call 2005334 <_Thread_Unblock> 20053f4: 81 e8 00 00 restore } return; } } switch ( _Event_Sync_state ) { 20053f8: c2 03 60 d4 ld [ %o5 + 0xd4 ], %g1 <== NOT EXECUTED 20053fc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005400: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2005404: 18 80 00 11 bgu 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005408: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 200540c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2005410: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2005414: 12 80 00 0d bne 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005418: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 200541c: 02 80 00 04 be 200542c <_Event_Surrender+0xe0> <== NOT EXECUTED 2005420: 80 8c e0 02 btst 2, %l3 <== NOT EXECUTED 2005424: 02 80 00 09 be 2005448 <_Event_Surrender+0xfc> <== NOT EXECUTED 2005428: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 200542c: 82 29 00 03 andn %g4, %g3, %g1 <== NOT EXECUTED 2005430: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005434: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED break; 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; 2005438: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 200543c: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 2005440: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2005444: c2 23 60 d4 st %g1, [ %o5 + 0xd4 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 2005448: 7f ff f2 49 call 2001d6c 200544c: 91 e8 00 12 restore %g0, %l2, %o0 2005450: 01 00 00 00 nop 02005454 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 2005454: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2005458: 92 96 20 00 orcc %i0, 0, %o1 200545c: 12 80 00 0a bne 2005484 <_Event_Timeout+0x30> 2005460: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005464: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005468: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200546c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2005470: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== NOT EXECUTED 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; 2005474: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005478: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 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; 200547c: 10 80 00 18 b 20054dc <_Event_Timeout+0x88> <== NOT EXECUTED 2005480: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 2005484: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2005488: 80 a0 a0 04 cmp %g2, 4 200548c: 18 80 00 0e bgu 20054c4 <_Event_Timeout+0x70> 2005490: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005494: 83 32 60 1b srl %o1, 0x1b, %g1 2005498: 80 a0 60 01 cmp %g1, 1 200549c: 12 80 00 0a bne 20054c4 <_Event_Timeout+0x70> 20054a0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20054a4: 83 28 a0 02 sll %g2, 2, %g1 20054a8: 05 00 80 62 sethi %hi(0x2018800), %g2 20054ac: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 20054b0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20054b4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20054b8: 80 a2 20 00 cmp %o0, 0 20054bc: 12 80 00 05 bne 20054d0 <_Event_Timeout+0x7c> 20054c0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20054c4: b0 10 20 00 clr %i0 <== NOT EXECUTED 20054c8: 10 80 00 05 b 20054dc <_Event_Timeout+0x88> <== NOT EXECUTED 20054cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20054d0: 40 00 08 be call 20077c8 <_Objects_Get> 20054d4: 94 07 bf f4 add %fp, -12, %o2 20054d8: b0 10 00 08 mov %o0, %i0 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20054dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20054e0: 80 a0 60 00 cmp %g1, 0 20054e4: 12 80 00 27 bne 2005580 <_Event_Timeout+0x12c> 20054e8: 01 00 00 00 nop * 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. */ _ISR_Disable( level ); 20054ec: 7f ff f2 1c call 2001d5c 20054f0: 01 00 00 00 nop 20054f4: 86 10 00 08 mov %o0, %g3 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 20054f8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 20054fc: 80 a0 60 00 cmp %g1, 0 2005500: 02 80 00 1a be 2005568 <_Event_Timeout+0x114> 2005504: 05 00 80 65 sethi %hi(0x2019400), %g2 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 2005508: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 ! 20194d4 <_Event_Sync_state> 200550c: 80 a0 60 00 cmp %g1, 0 2005510: 02 80 00 0d be 2005544 <_Event_Timeout+0xf0> 2005514: c0 26 20 24 clr [ %i0 + 0x24 ] 2005518: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200551c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2005520: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2005524: 12 80 00 09 bne 2005548 <_Event_Timeout+0xf4> <== NOT EXECUTED 2005528: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 200552c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED 2005530: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2005534: 02 80 00 03 be 2005540 <_Event_Timeout+0xec> <== NOT EXECUTED 2005538: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 200553c: c2 20 a0 d4 st %g1, [ %g2 + 0xd4 ] <== NOT EXECUTED } _ISR_Enable( level ); 2005540: 30 80 00 0a b,a 2005568 <_Event_Timeout+0x114> <== NOT EXECUTED } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005544: 82 10 20 06 mov 6, %g1 2005548: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 200554c: 7f ff f2 08 call 2001d6c 2005550: 90 10 00 03 mov %g3, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005554: 90 10 00 18 mov %i0, %o0 2005558: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200555c: 40 00 0c d5 call 20088b0 <_Thread_Clear_state> 2005560: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 2005564: 30 80 00 03 b,a 2005570 <_Event_Timeout+0x11c> _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 2005568: 7f ff f2 01 call 2001d6c <== NOT EXECUTED 200556c: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005570: 05 00 80 62 sethi %hi(0x2018800), %g2 2005574: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005578: 82 00 7f ff add %g1, -1, %g1 200557c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005580: 81 c7 e0 08 ret 2005584: 81 e8 00 00 restore 02018140 <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 2018140: da 02 20 08 ld [ %o0 + 8 ], %o5 <== NOT EXECUTED ) { Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 2018144: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 2018148: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 201814c: 10 80 00 0e b 2018184 <_Heap_Get_free_information+0x44> <== NOT EXECUTED 2018150: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED 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++; 2018154: c2 02 40 00 ld [ %o1 ], %g1 <== NOT EXECUTED info->total += the_size; 2018158: c4 02 60 08 ld [ %o1 + 8 ], %g2 <== NOT EXECUTED if ( info->largest < the_size ) 201815c: c8 02 60 04 ld [ %o1 + 4 ], %g4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 2018160: 86 08 ff fe and %g3, -2, %g3 <== NOT EXECUTED 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++; 2018164: 82 00 60 01 inc %g1 <== NOT EXECUTED info->total += the_size; 2018168: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED 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++; 201816c: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED info->total += the_size; if ( info->largest < the_size ) 2018170: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 2018174: 1a 80 00 03 bcc 2018180 <_Heap_Get_free_information+0x40> <== NOT EXECUTED 2018178: c4 22 60 08 st %g2, [ %o1 + 8 ] <== NOT EXECUTED info->largest = the_size; 201817c: c6 22 60 04 st %g3, [ %o1 + 4 ] <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 2018180: da 03 60 08 ld [ %o5 + 8 ], %o5 <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 2018184: 80 a3 40 08 cmp %o5, %o0 <== NOT EXECUTED 2018188: 32 bf ff f3 bne,a 2018154 <_Heap_Get_free_information+0x14> <== NOT EXECUTED 201818c: c6 03 60 04 ld [ %o5 + 4 ], %g3 <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 2018190: 81 c3 e0 08 retl <== NOT EXECUTED 2018194: 01 00 00 00 nop 020070dc <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 20070dc: 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) 20070e0: 80 a6 e0 00 cmp %i3, 0 20070e4: 12 80 00 05 bne 20070f8 <_Heap_Initialize+0x1c> 20070e8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] page_size = CPU_ALIGNMENT; 20070ec: 82 10 20 08 mov 8, %g1 <== NOT EXECUTED 20070f0: 10 80 00 05 b 2007104 <_Heap_Initialize+0x28> <== NOT EXECUTED 20070f4: c2 27 a0 50 st %g1, [ %fp + 0x50 ] <== NOT EXECUTED else _Heap_Align_up( &page_size, CPU_ALIGNMENT ); 20070f8: 90 07 a0 50 add %fp, 0x50, %o0 20070fc: 7f ff ff b0 call 2006fbc <_Heap_Align_up> 2007100: 92 10 20 08 mov 8, %o1 /* 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; _Heap_Align_up_uptr ( &aligned_start, page_size ); 2007104: e0 07 a0 50 ld [ %fp + 0x50 ], %l0 /* 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; 2007108: a4 06 60 08 add %i1, 8, %l2 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 200710c: 92 10 00 10 mov %l0, %o1 2007110: 40 00 38 fd call 2015504 <.urem> 2007114: 90 10 00 12 mov %l2, %o0 *value = r ? v - r + a : v; 2007118: 80 a2 20 00 cmp %o0, 0 200711c: 02 80 00 05 be 2007130 <_Heap_Initialize+0x54> 2007120: 82 10 20 10 mov 0x10, %g1 2007124: 82 04 80 10 add %l2, %l0, %g1 2007128: a4 20 40 08 sub %g1, %o0, %l2 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 200712c: 82 10 20 10 mov 0x10, %g1 _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007130: 92 10 00 10 mov %l0, %o1 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; /* Calculate 'min_block_size'. It's HEAP_MIN_BLOCK_SIZE aligned up to the nearest multiple of 'page_size'. */ the_heap->min_block_size = HEAP_MIN_BLOCK_SIZE; 2007134: c2 26 20 14 st %g1, [ %i0 + 0x14 ] _Heap_Align_up ( &the_heap->min_block_size, page_size ); 2007138: 7f ff ff a1 call 2006fbc <_Heap_Align_up> 200713c: 90 06 20 14 add %i0, 0x14, %o0 (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; _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 2007140: b6 04 bf f8 add %l2, -8, %i3 /* 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); 2007144: 82 26 c0 19 sub %i3, %i1, %g1 2007148: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 200714c: 80 a6 80 01 cmp %i2, %g1 2007150: 0a 80 00 2b bcs 20071fc <_Heap_Initialize+0x120> 2007154: e2 07 a0 50 ld [ %fp + 0x50 ], %l1 return 0; /* Too small area for the heap */ the_size = size - overhead; 2007158: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200715c: 92 10 00 11 mov %l1, %o1 2007160: 40 00 38 e9 call 2015504 <.urem> 2007164: 90 10 00 10 mov %l0, %o0 _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 2007168: a0 a4 00 08 subcc %l0, %o0, %l0 200716c: 02 80 00 24 be 20071fc <_Heap_Initialize+0x120> 2007170: 07 00 80 61 sethi %hi(0x2018400), %g3 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 2007174: e2 26 20 10 st %l1, [ %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; 2007178: e2 24 bf f8 st %l1, [ %l2 + -8 ] the_block->size = the_size | HEAP_PREV_USED; 200717c: 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++; 2007180: c4 00 e3 10 ld [ %g3 + 0x310 ], %g2 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 2007184: c2 26 e0 04 st %g1, [ %i3 + 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 */ 2007188: e0 26 c0 10 st %l0, [ %i3 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200718c: 88 06 c0 10 add %i3, %l0, %g4 the_block->size = page_size; 2007190: e2 21 20 04 st %l1, [ %g4 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 2007194: f0 26 e0 08 st %i0, [ %i3 + 8 ] the_block->prev = _Heap_Head( the_heap ); 2007198: f0 26 e0 0c st %i0, [ %i3 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 200719c: c4 26 20 28 st %g2, [ %i0 + 0x28 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20071a0: 82 10 20 01 mov 1, %g1 the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 20071a4: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; stats->max_free_blocks = 1; 20071a8: c2 26 20 3c st %g1, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 20071ac: c2 26 20 38 st %g1, [ %i0 + 0x38 ] the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; stats->free_size = the_size; 20071b0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 20071b4: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 20071b8: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 20071bc: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 20071c0: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 20071c4: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 20071c8: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 20071cc: c0 26 20 54 clr [ %i0 + 0x54 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 20071d0: 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++; 20071d4: 84 00 a0 01 inc %g2 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 20071d8: 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; 20071dc: 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; 20071e0: f6 26 20 08 st %i3, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 20071e4: f6 26 20 0c st %i3, [ %i0 + 0xc ] the_heap->start = the_block; 20071e8: f6 26 20 20 st %i3, [ %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 */ 20071ec: c8 26 20 24 st %g4, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 20071f0: c4 20 e3 10 st %g2, [ %g3 + 0x310 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 20071f4: 81 c7 e0 08 ret 20071f8: 91 ec 3f fc restore %l0, -4, %o0 } 20071fc: 81 c7 e0 08 ret 2007200: 91 e8 20 00 restore %g0, 0, %o0 0200cc9c <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 200cc9c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 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; uint32_t const page_size = the_heap->page_size; 200cca0: e6 06 20 10 ld [ %i0 + 0x10 ], %l3 <== NOT EXECUTED 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; 200cca4: ea 06 20 14 ld [ %i0 + 0x14 ], %l5 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 200cca8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 200ccac: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED /* 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); 200ccb0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200ccb4: 40 00 22 14 call 2015504 <.urem> <== NOT EXECUTED 200ccb8: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _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 ); 200ccbc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED /* 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); 200ccc0: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200ccc4: a4 02 3f f8 add %o0, -8, %l2 <== NOT EXECUTED _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)) 200ccc8: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 200cccc: 0a 80 00 78 bcs 200ceac <_Heap_Resize_block+0x210> <== NOT EXECUTED 200ccd0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED 200ccd4: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 200ccd8: 38 80 00 78 bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ccdc: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 200cce0: c6 04 a0 04 ld [ %l2 + 4 ], %g3 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 200cce4: ae 08 ff fe and %g3, -2, %l7 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200cce8: a2 04 80 17 add %l2, %l7, %l1 <== NOT EXECUTED 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) || 200ccec: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200ccf0: 2a 80 00 72 bcs,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ccf4: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200ccf8: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200ccfc: 38 80 00 6f bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cd00: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Heap_Is_prev_used ( Heap_Block *the_block ) { return (the_block->size & HEAP_PREV_USED); 200cd04: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 200cd08: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200cd0c: 02 80 00 68 be 200ceac <_Heap_Resize_block+0x210> <== NOT EXECUTED 200cd10: a8 08 7f fe and %g1, -2, %l4 <== NOT EXECUTED !_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) || 200cd14: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200cd18: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 200cd1c: 02 80 00 04 be 200cd2c <_Heap_Resize_block+0x90> <== NOT EXECUTED 200cd20: ba 04 40 14 add %l1, %l4, %i5 <== NOT EXECUTED 200cd24: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 200cd28: ac 08 60 01 and %g1, 1, %l6 <== NOT EXECUTED _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) 200cd2c: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 200cd30: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 200cd34: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 200cd38: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED 200cd3c: 08 80 00 1f bleu 200cdb8 <_Heap_Resize_block+0x11c> <== NOT EXECUTED 200cd40: b6 08 e0 01 and %g3, 1, %i3 <== NOT EXECUTED /* 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 */ 200cd44: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200cd48: 12 80 00 5b bne 200ceb4 <_Heap_Resize_block+0x218> <== NOT EXECUTED 200cd4c: a0 26 80 01 sub %i2, %g1, %l0 <== NOT EXECUTED uint32_t alignment ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; 200cd50: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200cd54: 40 00 21 ec call 2015504 <.urem> <== NOT EXECUTED 200cd58: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 200cd5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200cd60: 02 80 00 05 be 200cd74 <_Heap_Resize_block+0xd8> <== NOT EXECUTED 200cd64: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200cd68: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 200cd6c: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 200cd70: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 200cd74: 1a 80 00 03 bcc 200cd80 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 200cd78: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200cd7c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 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) 200cd80: 80 a2 00 14 cmp %o0, %l4 <== NOT EXECUTED 200cd84: 38 80 00 4d bgu,a 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cd88: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 200cd8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200cd90: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 200cd94: 7f ff e8 a8 call 2007034 <_Heap_Block_allocate> <== NOT EXECUTED 200cd98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _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; 200cd9c: 90 02 00 17 add %o0, %l7, %o0 <== NOT EXECUTED 200cda0: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 200cda4: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 200cda8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 200cdac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200cdb0: 10 80 00 3a b 200ce98 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200cdb4: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 200cdb8: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200cdbc: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200cdc0: 40 00 21 d1 call 2015504 <.urem> <== NOT EXECUTED 200cdc4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 200cdc8: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 200cdcc: 22 80 00 34 be,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200cdd0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED /* 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; 200cdd4: 84 25 c0 10 sub %l7, %l0, %g2 <== NOT EXECUTED if (new_block_size < min_block_size) { 200cdd8: 80 a0 80 15 cmp %g2, %l5 <== NOT EXECUTED 200cddc: 1a 80 00 08 bcc 200cdfc <_Heap_Resize_block+0x160> <== NOT EXECUTED 200cde0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 200cde4: 82 25 40 02 sub %l5, %g2, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 200cde8: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 200cdec: 22 80 00 2c be,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200cdf0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 200cdf4: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED _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) { 200cdf8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200cdfc: 12 80 00 15 bne 200ce50 <_Heap_Resize_block+0x1b4> <== NOT EXECUTED 200ce00: 80 a4 00 15 cmp %l0, %l5 <== NOT EXECUTED 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; 200ce04: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED 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; 200ce08: 86 04 00 14 add %l0, %l4, %g3 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 200ce0c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 200ce10: 82 10 e0 01 or %g3, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200ce14: 84 04 80 02 add %l2, %g2, %g2 <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 200ce18: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200ce1c: da 04 60 0c ld [ %l1 + 0xc ], %o5 <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 200ce20: c8 04 60 08 ld [ %l1 + 8 ], %g4 <== NOT EXECUTED _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; 200ce24: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED 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; 200ce28: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 200ce2c: c8 20 a0 08 st %g4, [ %g2 + 8 ] <== NOT EXECUTED 200ce30: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 200ce34: da 20 a0 0c st %o5, [ %g2 + 0xc ] <== NOT EXECUTED 200ce38: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 200ce3c: 86 00 ff fc add %g3, -4, %g3 <== NOT EXECUTED next->prev = prev->next = block; 200ce40: c4 21 20 0c st %g2, [ %g4 + 0xc ] <== NOT EXECUTED 200ce44: c4 23 60 08 st %g2, [ %o5 + 8 ] <== NOT EXECUTED 200ce48: 10 80 00 14 b 200ce98 <_Heap_Resize_block+0x1fc> <== NOT EXECUTED 200ce4c: c6 27 00 00 st %g3, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 200ce50: 2a 80 00 13 bcs,a 200ce9c <_Heap_Resize_block+0x200> <== NOT EXECUTED 200ce54: c2 06 20 54 ld [ %i0 + 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; 200ce58: 82 10 80 1b or %g2, %i3, %g1 <== NOT EXECUTED 200ce5c: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200ce60: 82 14 20 01 or %l0, 1, %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200ce64: 92 04 80 02 add %l2, %g2, %o1 <== NOT EXECUTED 200ce68: c2 22 60 04 st %g1, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 200ce6c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce70: c4 06 20 50 ld [ %i0 + 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 */ 200ce74: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce78: 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 */ 200ce7c: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200ce80: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 200ce84: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 200ce88: 7f ff e7 db call 2006df4 <_Heap_Free> <== NOT EXECUTED 200ce8c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 200ce90: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 200ce94: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED } } } ++stats->resizes; 200ce98: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200ce9c: 84 10 20 00 clr %g2 <== NOT EXECUTED 200cea0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200cea4: 10 80 00 05 b 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200cea8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; 200ceac: 10 80 00 03 b 200ceb8 <_Heap_Resize_block+0x21c> <== NOT EXECUTED 200ceb0: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200ceb4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 200ceb8: 81 c7 e0 08 ret <== NOT EXECUTED 200cebc: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED 0200cec0 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200cec0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 200cec4: e2 06 20 20 ld [ %i0 + 0x20 ], %l1 <== NOT EXECUTED 200cec8: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 200cecc: 0a 80 00 1f bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200ced0: e0 06 20 24 ld [ %i0 + 0x24 ], %l0 <== NOT EXECUTED 200ced4: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 200ced8: 18 80 00 1c bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cedc: 01 00 00 00 nop <== NOT EXECUTED /* 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); 200cee0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED 200cee4: 40 00 21 88 call 2015504 <.urem> <== NOT EXECUTED 200cee8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200ceec: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200cef0: 90 02 3f f8 add %o0, -8, %o0 <== NOT EXECUTED 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 ) ) 200cef4: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200cef8: 0a 80 00 14 bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cefc: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200cf00: 18 80 00 12 bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf04: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200cf08: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200cf0c: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200cf10: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 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 ( 200cf14: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200cf18: 0a 80 00 0c bcs 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf1c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200cf20: 18 80 00 0a bgu 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf24: 01 00 00 00 nop <== NOT EXECUTED 200cf28: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200cf2c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200cf30: 02 80 00 06 be 200cf48 <_Heap_Size_of_user_area+0x88> <== NOT EXECUTED 200cf34: 82 22 00 19 sub %o0, %i1, %g1 <== NOT EXECUTED 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 ) 200cf38: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 200cf3c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 200cf40: 81 c7 e0 08 ret <== NOT EXECUTED 200cf44: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 200cf48: 81 c7 e0 08 ret <== NOT EXECUTED 200cf4c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020065c8 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 20065c8: 9d e3 bf 98 save %sp, -104, %sp 20065cc: 23 00 80 65 sethi %hi(0x2019400), %l1 /* * 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 ) 20065d0: 80 a6 80 19 cmp %i2, %i1 20065d4: 18 80 00 06 bgu 20065ec <_IO_Manager_initialization+0x24> 20065d8: 25 00 80 65 sethi %hi(0x2019400), %l2 * 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; 20065dc: f0 24 61 28 st %i0, [ %l1 + 0x128 ] _IO_Number_of_drivers = number_of_drivers; 20065e0: f2 24 a1 24 st %i1, [ %l2 + 0x124 ] 20065e4: 81 c7 e0 08 ret 20065e8: 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 *) 20065ec: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 20065f0: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 20065f4: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 20065f8: 40 00 0f 35 call 200a2cc <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 20065fc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 2006600: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED _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; 2006604: f4 24 a1 24 st %i2, [ %l2 + 0x124 ] <== NOT EXECUTED /* * 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 *) 2006608: d0 24 61 28 st %o0, [ %l1 + 0x128 ] <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 200660c: 40 00 21 77 call 200ebe8 <== NOT EXECUTED 2006610: 92 10 20 00 clr %o1 <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; 2006614: e2 04 61 28 ld [ %l1 + 0x128 ], %l1 <== NOT EXECUTED 2006618: b4 10 20 00 clr %i2 <== NOT EXECUTED 200661c: 10 80 00 07 b 2006638 <_IO_Manager_initialization+0x70> <== NOT EXECUTED 2006620: a0 10 20 00 clr %l0 <== NOT EXECUTED 2006624: 92 04 00 18 add %l0, %i0, %o1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006628: b4 06 a0 01 inc %i2 <== NOT EXECUTED 200662c: a0 04 20 18 add %l0, 0x18, %l0 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006630: 40 00 21 41 call 200eb34 <== NOT EXECUTED 2006634: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006638: 80 a6 80 19 cmp %i2, %i1 <== NOT EXECUTED 200663c: 12 bf ff fa bne 2006624 <_IO_Manager_initialization+0x5c> <== NOT EXECUTED 2006640: 90 04 00 11 add %l0, %l1, %o0 <== NOT EXECUTED 2006644: 81 c7 e0 08 ret <== NOT EXECUTED 2006648: 81 e8 00 00 restore <== NOT EXECUTED 02007244 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 2007244: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 2007248: 03 00 80 63 sethi %hi(0x2018c00), %g1 200724c: c0 20 60 78 clr [ %g1 + 0x78 ] ! 2018c78 <_ISR_Signals_to_thread_executing> _ISR_Nest_level = 0; 2007250: 03 00 80 62 sethi %hi(0x2018800), %g1 _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 2007254: 90 10 24 00 mov 0x400, %o0 void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; 2007258: c0 20 63 b8 clr [ %g1 + 0x3b8 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 200725c: 40 00 0c 1c call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007260: 01 00 00 00 nop _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007264: 03 00 80 62 sethi %hi(0x2018800), %g1 2007268: a0 10 63 04 or %g1, 0x304, %l0 ! 2018b04 <_CPU_Table> 200726c: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 { _ISR_Signals_to_thread_executing = FALSE; _ISR_Nest_level = 0; _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 2007270: 03 00 80 62 sethi %hi(0x2018800), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007274: 80 a0 af ff cmp %g2, 0xfff 2007278: 18 80 00 06 bgu 2007290 <_ISR_Handler_initialization+0x4c> 200727c: d0 20 63 94 st %o0, [ %g1 + 0x394 ] _Internal_error_Occurred( 2007280: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007284: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007288: 7f ff ff df call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200728c: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 2007290: 40 00 0c 0f call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007294: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 2007298: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 200729c: 03 00 80 62 sethi %hi(0x2018800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20072a0: 84 02 00 02 add %o0, %g2, %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 20072a4: d0 20 63 00 st %o0, [ %g1 + 0x300 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 20072a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20072ac: c4 20 62 4c st %g2, [ %g1 + 0x24c ] ! 2018a4c <_CPU_Interrupt_stack_high> #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 20072b0: 81 c7 e0 08 ret 20072b4: 81 e8 00 00 restore 02016834 <_Objects_Copy_name_raw>: const size_t length ) { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; 2016834: 10 80 00 05 b 2016848 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 2016838: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) *destination_p++ = *source_p++; 201683c: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 2016840: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED 2016844: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED { uint32_t *source_p = (uint32_t *) source; uint32_t *destination_p = (uint32_t *) destination; size_t tmp_length = length / OBJECTS_NAME_ALIGNMENT; while ( tmp_length-- ) 2016848: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 201684c: 80 a2 bf ff cmp %o2, -1 <== NOT EXECUTED 2016850: 32 bf ff fb bne,a 201683c <_Objects_Copy_name_raw+0x8> <== NOT EXECUTED 2016854: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *destination_p++ = *source_p++; } 2016858: 81 c3 e0 08 retl <== NOT EXECUTED 201685c: 01 00 00 00 nop 02007394 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 2007394: 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; 2007398: 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 ) 200739c: e0 16 20 10 lduh [ %i0 + 0x10 ], %l0 20073a0: 03 00 00 3f sethi %hi(0xfc00), %g1 20073a4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20073a8: a2 08 80 01 and %g2, %g1, %l1 20073ac: 80 a4 00 11 cmp %l0, %l1 20073b0: 3a 80 00 06 bcc,a 20073c8 <_Objects_Extend_information+0x34> 20073b4: e4 06 20 18 ld [ %i0 + 0x18 ], %l2 20073b8: ac 10 00 11 mov %l1, %l6 20073bc: 90 10 20 00 clr %o0 20073c0: 10 80 00 12 b 2007408 <_Objects_Extend_information+0x74> 20073c4: b8 10 20 00 clr %i4 block_count = 0; else { block_count = information->maximum / information->allocation_size; 20073c8: 90 10 00 10 mov %l0, %o0 20073cc: 92 10 00 12 mov %l2, %o1 20073d0: 40 00 37 a1 call 2015254 <.udiv> 20073d4: ac 10 00 11 mov %l1, %l6 20073d8: 10 80 00 09 b 20073fc <_Objects_Extend_information+0x68> 20073dc: b8 10 20 00 clr %i4 for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 20073e0: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 20073e4: c2 00 40 02 ld [ %g1 + %g2 ], %g1 20073e8: 80 a0 60 00 cmp %g1, 0 20073ec: 02 80 00 08 be 200740c <_Objects_Extend_information+0x78> 20073f0: 80 a5 80 10 cmp %l6, %l0 break; else index_base += information->allocation_size; 20073f4: ac 05 80 12 add %l6, %l2, %l6 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 20073f8: b8 07 20 01 inc %i4 20073fc: 80 a7 00 08 cmp %i4, %o0 2007400: 12 bf ff f8 bne 20073e0 <_Objects_Extend_information+0x4c> 2007404: 85 2f 20 02 sll %i4, 2, %g2 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007408: 80 a5 80 10 cmp %l6, %l0 200740c: 2a 80 00 63 bcs,a 2007598 <_Objects_Extend_information+0x204> 2007410: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 2007414: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007418: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 200741c: ae 04 00 01 add %l0, %g1, %l7 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007420: 80 a0 a0 00 cmp %g2, 0 /* * Up the block count and maximum */ block_count++; 2007424: a0 02 20 01 add %o0, 1, %l0 2007428: 82 05 c0 11 add %l7, %l1, %g1 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 200742c: 02 80 00 0b be 2007458 <_Objects_Extend_information+0xc4> 2007430: 91 2c 20 01 sll %l0, 1, %o0 object_blocks = (void**) 2007434: 90 02 00 10 add %o0, %l0, %o0 2007438: 90 00 40 08 add %g1, %o0, %o0 200743c: 7f ff ff cf call 2007378 <_Workspace_Allocate> 2007440: 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 ) 2007444: a4 92 20 00 orcc %o0, 0, %l2 2007448: 32 80 00 0a bne,a 2007470 <_Objects_Extend_information+0xdc> 200744c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 2007450: 81 c7 e0 08 ret <== NOT EXECUTED 2007454: 81 e8 00 00 restore <== NOT EXECUTED return; } else { object_blocks = (void**) 2007458: 90 02 00 10 add %o0, %l0, %o0 200745c: 90 00 40 08 add %g1, %o0, %o0 2007460: 40 00 0b 9b call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007464: 91 2a 20 02 sll %o0, 2, %o0 2007468: a4 10 00 08 mov %o0, %l2 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 200746c: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 2007470: ba 04 3f ff add %l0, -1, %i5 if ( information->maximum > minimum_index ) { 2007474: 80 a0 40 11 cmp %g1, %l1 2007478: 84 10 20 00 clr %g2 200747c: 83 2c 20 02 sll %l0, 2, %g1 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 2007480: a8 04 80 01 add %l2, %g1, %l4 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 2007484: aa 05 00 01 add %l4, %g1, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2007488: 08 80 00 19 bleu 20074ec <_Objects_Extend_information+0x158> 200748c: a6 05 40 01 add %l5, %g1, %l3 /* * 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, 2007490: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 2007494: a1 2f 60 02 sll %i5, 2, %l0 2007498: 90 10 00 12 mov %l2, %o0 200749c: 40 00 1d a6 call 200eb34 20074a0: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 20074a4: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 20074a8: 94 10 00 10 mov %l0, %o2 20074ac: 40 00 1d a2 call 200eb34 20074b0: 90 10 00 14 mov %l4, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 20074b4: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 20074b8: 94 10 00 10 mov %l0, %o2 20074bc: 40 00 1d 9e call 200eb34 20074c0: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 20074c4: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 20074c8: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 20074cc: 94 02 80 11 add %o2, %l1, %o2 20074d0: 90 10 00 13 mov %l3, %o0 20074d4: 40 00 1d 98 call 200eb34 20074d8: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 20074dc: 10 80 00 08 b 20074fc <_Objects_Extend_information+0x168> 20074e0: 83 2f 60 02 sll %i5, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 20074e4: 84 00 a0 01 inc %g2 local_table[ index ] = NULL; 20074e8: c0 20 40 13 clr [ %g1 + %l3 ] else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 20074ec: 80 a0 80 11 cmp %g2, %l1 20074f0: 32 bf ff fd bne,a 20074e4 <_Objects_Extend_information+0x150> 20074f4: 83 28 a0 02 sll %g2, 2, %g1 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 20074f8: 83 2f 60 02 sll %i5, 2, %g1 inactive_per_block[block_count] = 0; 20074fc: c0 25 00 01 clr [ %l4 + %g1 ] /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007500: c0 24 80 01 clr [ %l2 + %g1 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 2007504: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; name_table[block_count] = NULL; 2007508: c0 25 40 01 clr [ %l5 + %g1 ] for ( index=index_base ; index < ( information->allocation_size + index_base ); 200750c: 83 2d a0 02 sll %l6, 2, %g1 2007510: 86 05 80 02 add %l6, %g2, %g3 2007514: 84 04 c0 01 add %l3, %g1, %g2 2007518: 10 80 00 04 b 2007528 <_Objects_Extend_information+0x194> 200751c: 82 10 00 16 mov %l6, %g1 index++ ) { local_table[ index ] = NULL; 2007520: c0 20 bf fc clr [ %g2 + -4 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 2007524: 82 00 60 01 inc %g1 object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 2007528: 80 a0 40 03 cmp %g1, %g3 200752c: 0a bf ff fd bcs 2007520 <_Objects_Extend_information+0x18c> 2007530: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 2007534: 7f ff ea 0a call 2001d5c 2007538: 01 00 00 00 nop 200753c: a0 10 00 08 mov %o0, %l0 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007540: d0 06 00 00 ld [ %i0 ], %o0 2007544: d2 16 20 04 lduh [ %i0 + 4 ], %o1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 2007548: e8 26 20 38 st %l4, [ %i0 + 0x38 ] information->name_table = name_table; 200754c: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 2007550: e6 26 20 20 st %l3, [ %i0 + 0x20 ] information->maximum = maximum; 2007554: ee 36 20 10 sth %l7, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 2007558: 97 2d e0 10 sll %l7, 0x10, %o3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 200755c: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007560: 97 32 e0 10 srl %o3, 0x10, %o3 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 2007564: e4 26 20 3c st %l2, [ %i0 + 0x3c ] information->inactive_per_block = inactive_per_block; information->name_table = name_table; information->local_table = local_table; information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007568: 7f ff ff 7d call 200735c <_Objects_Build_id> 200756c: 94 10 20 01 mov 1, %o2 2007570: d0 26 20 0c st %o0, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 2007574: 7f ff e9 fe call 2001d6c 2007578: 90 10 00 10 mov %l0, %o0 if ( old_tables ) 200757c: 80 a4 60 00 cmp %l1, 0 2007580: 02 80 00 05 be 2007594 <_Objects_Extend_information+0x200> 2007584: 11 00 80 62 sethi %hi(0x2018800), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2007588: 92 10 00 11 mov %l1, %o1 200758c: 7f ff fe 1a call 2006df4 <_Heap_Free> 2007590: 90 12 23 3c or %o0, 0x33c, %o0 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 2007594: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007598: e2 06 20 3c ld [ %i0 + 0x3c ], %l1 200759c: 80 a0 60 00 cmp %g1, 0 20075a0: a1 2f 20 02 sll %i4, 2, %l0 20075a4: d0 16 20 44 lduh [ %i0 + 0x44 ], %o0 20075a8: 02 80 00 11 be 20075ec <_Objects_Extend_information+0x258> 20075ac: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 information->object_blocks[ block ] = 20075b0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075b4: 91 2a 20 10 sll %o0, 0x10, %o0 20075b8: 91 32 20 10 srl %o0, 0x10, %o0 20075bc: 40 00 36 ec call 201516c <.umul> 20075c0: 90 02 00 01 add %o0, %g1, %o0 20075c4: 7f ff ff 6d call 2007378 <_Workspace_Allocate> 20075c8: 01 00 00 00 nop _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 20075cc: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 20075d0: d0 24 00 11 st %o0, [ %l0 + %l1 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 20075d4: c2 00 40 10 ld [ %g1 + %l0 ], %g1 20075d8: 80 a0 60 00 cmp %g1, 0 20075dc: 32 80 00 0d bne,a 2007610 <_Objects_Extend_information+0x27c> 20075e0: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075e4: 81 c7 e0 08 ret <== NOT EXECUTED 20075e8: 81 e8 00 00 restore <== NOT EXECUTED return; } else { information->object_blocks[ block ] = 20075ec: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20075f0: 91 2a 20 10 sll %o0, 0x10, %o0 20075f4: 91 32 20 10 srl %o0, 0x10, %o0 20075f8: 40 00 36 dd call 201516c <.umul> 20075fc: 90 02 00 01 add %o0, %g1, %o0 2007600: 40 00 0b 33 call 200a2cc <_Workspace_Allocate_or_fatal_error> 2007604: 01 00 00 00 nop 2007608: d0 24 00 11 st %o0, [ %l0 + %l1 ] 200760c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007610: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007614: 40 00 36 d6 call 201516c <.umul> 2007618: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); } name_area = (Objects_Name *) _Addresses_Add_offset( 200761c: a7 2f 20 02 sll %i4, 2, %l3 information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007620: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 2007624: c2 04 00 13 ld [ %l0 + %l3 ], %g1 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007628: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 200762c: a2 02 00 01 add %o0, %g1, %l1 2007630: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007634: e2 20 80 13 st %l1, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007638: d2 04 00 13 ld [ %l0 + %l3 ], %o1 200763c: 90 07 bf ec add %fp, -20, %o0 2007640: a4 10 00 16 mov %l6, %l2 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 2007644: aa 10 00 08 mov %o0, %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007648: 40 00 15 3d call 200cb3c <_Chain_Initialize> 200764c: a8 06 20 28 add %i0, 0x28, %l4 2007650: 30 80 00 0c b,a 2007680 <_Objects_Extend_information+0x2ec> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007654: d2 16 20 04 lduh [ %i0 + 4 ], %o1 2007658: d0 06 00 00 ld [ %i0 ], %o0 200765c: 7f ff ff 40 call 200735c <_Objects_Build_id> 2007660: a4 04 a0 01 inc %l2 2007664: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 2007668: d0 24 20 08 st %o0, [ %l0 + 8 ] information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 200766c: e2 24 20 0c st %l1, [ %l0 + 0xc ] name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 2007670: 92 10 00 10 mov %l0, %o1 2007674: a2 04 40 01 add %l1, %g1, %l1 2007678: 7f ff fc 7b call 2006864 <_Chain_Append> 200767c: 90 10 00 14 mov %l4, %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 ) { 2007680: 7f ff fc 85 call 2006894 <_Chain_Get> 2007684: 90 10 00 15 mov %l5, %o0 the_object->id = _Objects_Build_id( 2007688: 96 10 00 12 mov %l2, %o3 * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 200768c: a0 10 00 08 mov %o0, %l0 2007690: 80 a2 20 00 cmp %o0, 0 2007694: 12 bf ff f0 bne 2007654 <_Objects_Extend_information+0x2c0> 2007698: 94 10 20 01 mov 1, %o2 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 200769c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20076a0: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 information->inactive += information->allocation_size; 20076a4: c6 16 20 34 lduh [ %i0 + 0x34 ], %g3 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 20076a8: c2 20 80 13 st %g1, [ %g2 + %l3 ] information->inactive += information->allocation_size; 20076ac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20076b0: 82 00 40 03 add %g1, %g3, %g1 20076b4: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 20076b8: 81 c7 e0 08 ret 20076bc: 81 e8 00 00 restore 0200921c <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 200921c: 9d e3 bf 88 save %sp, -120, %sp 2009220: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 2009224: 80 a6 60 00 cmp %i1, 0 2009228: 02 80 00 43 be 2009334 <_Objects_Get_name_as_string+0x118> 200922c: b0 10 00 1a mov %i2, %i0 return NULL; if ( name == NULL ) 2009230: 80 a6 a0 00 cmp %i2, 0 2009234: 02 80 00 3e be 200932c <_Objects_Get_name_as_string+0x110> 2009238: 85 32 60 16 srl %o1, 0x16, %g2 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 200923c: 03 00 80 95 sethi %hi(0x2025400), %g1 2009240: 84 08 a0 1c and %g2, 0x1c, %g2 2009244: 82 10 62 60 or %g1, 0x260, %g1 2009248: c4 00 40 02 ld [ %g1 + %g2 ], %g2 200924c: 83 32 60 1b srl %o1, 0x1b, %g1 2009250: 83 28 60 02 sll %g1, 2, %g1 2009254: e0 00 80 01 ld [ %g2 + %g1 ], %l0 return NULL; information = _Objects_Get_information( id ); if ( !information ) 2009258: 80 a4 20 00 cmp %l0, 0 200925c: 22 80 00 34 be,a 200932c <_Objects_Get_name_as_string+0x110> 2009260: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 2009264: 90 10 00 10 mov %l0, %o0 2009268: 40 00 00 36 call 2009340 <_Objects_Get> 200926c: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 2009270: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009274: 80 a0 60 00 cmp %g1, 0 2009278: 32 80 00 2d bne,a 200932c <_Objects_Get_name_as_string+0x110> 200927c: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 2009280: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2009284: 80 a0 60 00 cmp %g1, 0 2009288: 12 80 00 0b bne 20092b4 <_Objects_Get_name_as_string+0x98> 200928c: d0 02 20 0c ld [ %o0 + 0xc ], %o0 s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 2009290: 83 32 20 18 srl %o0, 0x18, %g1 2009294: c2 2f bf ef stb %g1, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; 2009298: 83 32 20 10 srl %o0, 0x10, %g1 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 200929c: d0 2f bf f2 stb %o0, [ %fp + -14 ] s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; 20092a0: c2 2f bf f0 stb %g1, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092a4: c0 2f bf f3 clrb [ %fp + -13 ] } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20092a8: 83 32 20 08 srl %o0, 8, %g1 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092ac: 90 07 bf ef add %fp, -17, %o0 } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20092b0: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20092b4: 84 10 00 18 mov %i0, %g2 20092b8: 88 10 20 01 mov 1, %g4 s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { *d = (!isprint(*s)) ? '*' : *s; 20092bc: 10 80 00 09 b 20092e0 <_Objects_Get_name_as_string+0xc4> 20092c0: 19 00 80 73 sethi %hi(0x201cc00), %o4 20092c4: c2 03 23 98 ld [ %o4 + 0x398 ], %g1 ! 201cf98 <__ctype_ptr> 20092c8: c2 48 40 03 ldsb [ %g1 + %g3 ], %g1 20092cc: 80 88 60 97 btst 0x97, %g1 20092d0: 22 80 00 02 be,a 20092d8 <_Objects_Get_name_as_string+0xbc> 20092d4: 9a 10 20 2a mov 0x2a, %o5 <== NOT EXECUTED 20092d8: da 28 80 00 stb %o5, [ %g2 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 20092dc: 84 00 a0 01 inc %g2 20092e0: 80 a1 00 19 cmp %g4, %i1 20092e4: 02 80 00 07 be 2009300 <_Objects_Get_name_as_string+0xe4> 20092e8: 82 02 00 04 add %o0, %g4, %g1 20092ec: c6 48 7f ff ldsb [ %g1 + -1 ], %g3 20092f0: 88 01 20 01 inc %g4 20092f4: 80 a0 e0 00 cmp %g3, 0 20092f8: 12 bf ff f3 bne 20092c4 <_Objects_Get_name_as_string+0xa8> 20092fc: da 08 7f ff ldub [ %g1 + -1 ], %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 2009300: c0 28 80 00 clrb [ %g2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2009304: 03 00 80 95 sethi %hi(0x2025400), %g1 2009308: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 200930c: 84 00 bf ff add %g2, -1, %g2 2009310: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 2009314: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 2009318: 80 a0 60 00 cmp %g1, 0 200931c: 12 80 00 07 bne 2009338 <_Objects_Get_name_as_string+0x11c> 2009320: 01 00 00 00 nop _Thread_Dispatch(); 2009324: 40 00 04 cd call 200a658 <_Thread_Dispatch> 2009328: 01 00 00 00 nop 200932c: 81 c7 e0 08 ret 2009330: 81 e8 00 00 restore 2009334: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 2009338: 81 c7 e0 08 ret <== NOT EXECUTED 200933c: 81 e8 00 00 restore <== NOT EXECUTED 02016860 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 2016860: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 2016864: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 2016868: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 201686c: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 2016870: 22 80 00 02 be,a 2016878 <_Objects_Get_next+0x18> <== NOT EXECUTED 2016874: f2 06 20 08 ld [ %i0 + 8 ], %i1 <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 2016878: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 201687c: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 2016880: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 2016884: 82 0e 40 10 and %i1, %l0, %g1 <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 2016888: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201688c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 2016890: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2016894: 18 80 00 0a bgu 20168bc <_Objects_Get_next+0x5c> <== NOT EXECUTED 2016898: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 201689c: 7f ff d5 e2 call 200c024 <_Objects_Get> <== NOT EXECUTED 20168a0: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 20168a4: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 20168a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20168ac: 32 bf ff f6 bne,a 2016884 <_Objects_Get_next+0x24> <== NOT EXECUTED 20168b0: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 20168b4: 10 80 00 07 b 20168d0 <_Objects_Get_next+0x70> <== NOT EXECUTED 20168b8: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 20168bc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20168c0: 90 10 20 00 clr %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 20168c4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 20168c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 20168cc: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED return 0; } 20168d0: 81 c7 e0 08 ret <== NOT EXECUTED 20168d4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 02014a60 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2014a60: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 2014a64: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 2014a68: 92 22 40 01 sub %o1, %g1, %o1 2014a6c: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 2014a70: 80 a0 80 01 cmp %g2, %g1 2014a74: 0a 80 00 0b bcs 2014aa0 <_Objects_Get_no_protection+0x40> 2014a78: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 2014a7c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2014a80: d0 00 80 01 ld [ %g2 + %g1 ], %o0 2014a84: 80 a2 20 00 cmp %o0, 0 2014a88: 02 80 00 04 be 2014a98 <_Objects_Get_no_protection+0x38> 2014a8c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 2014a90: 81 c3 e0 08 retl 2014a94: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; 2014a98: 81 c3 e0 08 retl <== NOT EXECUTED 2014a9c: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED return NULL; } *location = OBJECTS_ERROR; 2014aa0: 82 10 20 02 mov 2, %g1 2014aa4: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 2014aa8: 81 c3 e0 08 retl 2014aac: c2 22 80 00 st %g1, [ %o2 ] 02007a2c <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 2007a2c: 80 a2 20 00 cmp %o0, 0 2007a30: 22 80 00 05 be,a 2007a44 <_Objects_Handler_initialization+0x18> 2007a34: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007a38: 80 a2 00 09 cmp %o0, %o1 2007a3c: 08 80 00 07 bleu 2007a58 <_Objects_Handler_initialization+0x2c> 2007a40: 90 10 20 00 clr %o0 _Internal_error_Occurred( 2007a44: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007a48: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 2007a4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2007a50: 7f ff fd ed call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007a54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2007a58: 81 c3 e0 08 retl 2007a5c: 01 00 00 00 nop 02008e70 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2008e70: 9d e3 bf 90 save %sp, -112, %sp 2008e74: 92 10 00 18 mov %i0, %o1 uint32_t the_class; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 2008e78: 80 a6 60 00 cmp %i1, 0 2008e7c: 02 80 00 26 be 2008f14 <_Objects_Id_to_name+0xa4> 2008e80: b0 10 20 01 mov 1, %i0 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2008e84: 83 32 60 18 srl %o1, 0x18, %g1 2008e88: 82 08 60 07 and %g1, 7, %g1 return OBJECTS_INVALID_NAME; the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) 2008e8c: 80 a0 60 04 cmp %g1, 4 2008e90: 18 80 00 23 bgu 2008f1c <_Objects_Id_to_name+0xac> 2008e94: 85 28 60 02 sll %g1, 2, %g2 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 2008e98: 03 00 80 75 sethi %hi(0x201d400), %g1 2008e9c: 82 10 61 70 or %g1, 0x170, %g1 ! 201d570 <_Objects_Information_table> 2008ea0: c4 00 40 02 ld [ %g1 + %g2 ], %g2 2008ea4: 83 32 60 1b srl %o1, 0x1b, %g1 2008ea8: 83 28 60 02 sll %g1, 2, %g1 2008eac: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !information ) 2008eb0: 80 a2 20 00 cmp %o0, 0 2008eb4: 02 80 00 18 be 2008f14 <_Objects_Id_to_name+0xa4> 2008eb8: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; if ( information->is_string ) 2008ebc: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 2008ec0: 80 a0 60 00 cmp %g1, 0 2008ec4: 12 80 00 17 bne 2008f20 <_Objects_Id_to_name+0xb0> 2008ec8: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 2008ecc: 7f ff ff c4 call 2008ddc <_Objects_Get> 2008ed0: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 2008ed4: 80 a2 20 00 cmp %o0, 0 2008ed8: 02 80 00 0f be 2008f14 <_Objects_Id_to_name+0xa4> 2008edc: b0 10 20 03 mov 3, %i0 return OBJECTS_INVALID_ID; *name = the_object->name; 2008ee0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 2008ee4: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008ee8: 05 00 80 75 sethi %hi(0x201d400), %g2 2008eec: c2 00 a2 10 ld [ %g2 + 0x210 ], %g1 ! 201d610 <_Thread_Dispatch_disable_level> 2008ef0: b0 10 20 00 clr %i0 2008ef4: 82 00 7f ff add %g1, -1, %g1 2008ef8: c2 20 a2 10 st %g1, [ %g2 + 0x210 ] 2008efc: c2 00 a2 10 ld [ %g2 + 0x210 ], %g1 2008f00: 80 a0 60 00 cmp %g1, 0 2008f04: 12 80 00 07 bne 2008f20 <_Objects_Id_to_name+0xb0> 2008f08: 01 00 00 00 nop _Thread_Dispatch(); 2008f0c: 40 00 04 e7 call 200a2a8 <_Thread_Dispatch> 2008f10: 01 00 00 00 nop 2008f14: 81 c7 e0 08 ret 2008f18: 81 e8 00 00 restore 2008f1c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 2008f20: 81 c7 e0 08 ret <== NOT EXECUTED 2008f24: 81 e8 00 00 restore <== NOT EXECUTED 02007930 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 2007930: 9d e3 bf 98 save %sp, -104, %sp 2007934: a2 10 00 18 mov %i0, %l1 Objects_Control *the_object; uint32_t index; uint32_t name_length; Objects_Name_comparators compare_them; if ( !id ) 2007938: 80 a6 e0 00 cmp %i3, 0 200793c: 02 80 00 3a be 2007a24 <_Objects_Name_to_id+0xf4> 2007940: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 2007944: 80 a6 60 00 cmp %i1, 0 2007948: 02 80 00 2d be 20079fc <_Objects_Name_to_id+0xcc> 200794c: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007950: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2007954: 80 a0 60 00 cmp %g1, 0 2007958: 02 80 00 29 be 20079fc <_Objects_Name_to_id+0xcc> 200795c: 80 a6 a0 00 cmp %i2, 0 2007960: 22 80 00 2a be,a 2007a08 <_Objects_Name_to_id+0xd8> 2007964: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2007968: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 200796c: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 2007970: 80 a6 80 01 cmp %i2, %g1 2007974: 02 80 00 24 be 2007a04 <_Objects_Name_to_id+0xd4> 2007978: 80 a6 a0 01 cmp %i2, 1 200797c: 22 80 00 23 be,a 2007a08 <_Objects_Name_to_id+0xd8> 2007980: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 2007984: 81 c7 e0 08 ret 2007988: 91 e8 20 01 restore %g0, 1, %o0 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 200798c: a4 10 63 60 or %g1, 0x360, %l2 for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 2007990: 83 28 a0 10 sll %g2, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007994: a0 10 20 01 mov 1, %l0 for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 2007998: 10 80 00 15 b 20079ec <_Objects_Name_to_id+0xbc> 200799c: b1 30 60 10 srl %g1, 0x10, %i0 if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 20079a0: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 20079a4: a0 04 20 01 inc %l0 the_object = information->local_table[ index ]; 20079a8: f4 00 40 02 ld [ %g1 + %g2 ], %i2 if ( !the_object || !the_object->name ) 20079ac: 80 a6 a0 00 cmp %i2, 0 20079b0: 02 80 00 0f be 20079ec <_Objects_Name_to_id+0xbc> 20079b4: 90 10 00 19 mov %i1, %o0 20079b8: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 20079bc: 80 a2 60 00 cmp %o1, 0 20079c0: 02 80 00 0b be 20079ec <_Objects_Name_to_id+0xbc> 20079c4: 94 10 00 18 mov %i0, %o2 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 20079c8: 9f c4 80 00 call %l2 20079cc: 01 00 00 00 nop 20079d0: 80 a2 20 00 cmp %o0, 0 20079d4: 22 80 00 07 be,a 20079f0 <_Objects_Name_to_id+0xc0> 20079d8: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 *id = the_object->id; 20079dc: c2 06 a0 08 ld [ %i2 + 8 ], %g1 20079e0: c2 26 c0 00 st %g1, [ %i3 ] 20079e4: 81 c7 e0 08 ret 20079e8: 91 e8 20 00 restore %g0, 0, %o0 name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; else compare_them = _Objects_Compare_name_raw; for ( index = 1; index <= information->maximum; index++ ) { 20079ec: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 20079f0: 80 a4 00 01 cmp %l0, %g1 20079f4: 08 bf ff eb bleu 20079a0 <_Objects_Name_to_id+0x70> 20079f8: 85 2c 20 02 sll %l0, 2, %g2 20079fc: 81 c7 e0 08 ret 2007a00: 91 e8 20 01 restore %g0, 1, %o0 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007a04: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 _Objects_Is_local_node( node ) )) search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; 2007a08: c4 14 60 44 lduh [ %l1 + 0x44 ], %g2 if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007a0c: 80 a0 60 00 cmp %g1, 0 2007a10: 03 00 80 33 sethi %hi(0x200cc00), %g1 2007a14: 02 bf ff df be 2007990 <_Objects_Name_to_id+0x60> 2007a18: a4 10 63 50 or %g1, 0x350, %l2 ! 200cf50 <_Objects_Compare_name_raw> if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007a1c: 10 bf ff dc b 200798c <_Objects_Name_to_id+0x5c> 2007a20: 03 00 80 33 sethi %hi(0x200cc00), %g1 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 2007a24: 81 c7 e0 08 ret <== NOT EXECUTED 2007a28: 81 e8 00 00 restore <== NOT EXECUTED 02007a60 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2007a60: 9d e3 bf 98 save %sp, -104, %sp 2007a64: 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; 2007a68: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 2007a6c: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2007a70: 03 00 00 3f sethi %hi(0xfc00), %g1 2007a74: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007a78: 92 10 00 10 mov %l0, %o1 2007a7c: a2 08 80 01 and %g2, %g1, %l1 2007a80: 40 00 35 f5 call 2015254 <.udiv> 2007a84: 90 22 00 11 sub %o0, %l1, %o0 2007a88: 86 10 20 00 clr %g3 2007a8c: 10 80 00 33 b 2007b58 <_Objects_Shrink_information+0xf8> 2007a90: a4 10 20 00 clr %l2 for ( block = 0; block < block_count; block++ ) { 2007a94: 86 00 e0 01 inc %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 2007a98: c2 00 40 12 ld [ %g1 + %l2 ], %g1 2007a9c: 80 a0 40 10 cmp %g1, %l0 2007aa0: 12 80 00 2c bne 2007b50 <_Objects_Shrink_information+0xf0> 2007aa4: 84 04 a0 04 add %l2, 4, %g2 /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 2007aa8: e0 06 20 28 ld [ %i0 + 0x28 ], %l0 2007aac: 03 00 00 3f sethi %hi(0xfc00), %g1 2007ab0: a6 10 63 ff or %g1, 0x3ff, %l3 ! ffff 2007ab4: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007ab8: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2007abc: 80 a0 80 11 cmp %g2, %l1 2007ac0: 2a 80 00 0c bcs,a 2007af0 <_Objects_Shrink_information+0x90> 2007ac4: e0 04 00 00 ld [ %l0 ], %l0 2007ac8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007acc: 82 04 40 01 add %l1, %g1, %g1 2007ad0: 80 a0 80 01 cmp %g2, %g1 2007ad4: 1a 80 00 06 bcc 2007aec <_Objects_Shrink_information+0x8c> 2007ad8: 90 10 00 10 mov %l0, %o0 if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 2007adc: 40 00 14 0e call 200cb14 <_Chain_Extract> 2007ae0: e0 04 00 00 ld [ %l0 ], %l0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2007ae4: 10 80 00 04 b 2007af4 <_Objects_Shrink_information+0x94> 2007ae8: 80 a4 20 00 cmp %l0, 0 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 2007aec: e0 04 00 00 ld [ %l0 ], %l0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2007af0: 80 a4 20 00 cmp %l0, 0 2007af4: 22 80 00 07 be,a 2007b10 <_Objects_Shrink_information+0xb0> 2007af8: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2007afc: c2 04 00 00 ld [ %l0 ], %g1 2007b00: 80 a0 60 00 cmp %g1, 0 2007b04: 32 bf ff ed bne,a 2007ab8 <_Objects_Shrink_information+0x58> 2007b08: c2 04 20 08 ld [ %l0 + 8 ], %g1 2007b0c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 2007b10: 11 00 80 62 sethi %hi(0x2018800), %o0 2007b14: d2 00 40 12 ld [ %g1 + %l2 ], %o1 2007b18: 7f ff fc b7 call 2006df4 <_Heap_Free> 2007b1c: 90 12 23 3c or %o0, 0x33c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007b20: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 2007b24: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2007b28: c0 20 40 12 clr [ %g1 + %l2 ] * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 2007b2c: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b30: c2 16 20 34 lduh [ %i0 + 0x34 ], %g1 2007b34: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 2007b38: c0 20 c0 12 clr [ %g3 + %l2 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b3c: 82 20 40 02 sub %g1, %g2, %g1 * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; 2007b40: c0 21 00 12 clr [ %g4 + %l2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2007b44: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007b48: 81 c7 e0 08 ret 2007b4c: 81 e8 00 00 restore return; } index_base += information->allocation_size; 2007b50: a2 04 40 10 add %l1, %l0, %l1 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 2007b54: a4 10 00 02 mov %g2, %l2 2007b58: 80 a0 c0 08 cmp %g3, %o0 2007b5c: 32 bf ff ce bne,a 2007a94 <_Objects_Shrink_information+0x34> 2007b60: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2007b64: 81 c7 e0 08 ret 2007b68: 81 e8 00 00 restore 0200664c <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 200664c: 9d e3 bf 98 save %sp, -104, %sp /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 2006650: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 if ( !api_configuration ) 2006654: 80 a6 20 00 cmp %i0, 0 2006658: 32 80 00 05 bne,a 200666c <_POSIX_API_Initialize+0x20> 200665c: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 2006660: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 2006664: b0 10 62 dc or %g1, 0x2dc, %i0 ! 20186dc <_POSIX_Default_configuration> <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 2006668: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 200666c: 05 00 80 62 sethi %hi(0x2018800), %g2 2006670: 03 00 80 64 sethi %hi(0x2019000), %g1 2006674: 82 10 60 88 or %g1, 0x88, %g1 ! 2019088 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 2006678: 40 00 16 ab call 200c124 <_POSIX_signals_Manager_Initialization> 200667c: c2 20 a2 5c st %g1, [ %g2 + 0x25c ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 2006680: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 2006684: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 2006688: 40 00 17 1b call 200c2f4 <_POSIX_Threads_Manager_initialization> 200668c: d0 06 00 00 ld [ %i0 ], %o0 api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 2006690: 40 00 16 53 call 200bfdc <_POSIX_Condition_variables_Manager_initialization> 2006694: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 2006698: 40 00 16 5d call 200c00c <_POSIX_Key_Manager_initialization> 200669c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 20066a0: 40 00 16 7d call 200c094 <_POSIX_Mutex_Manager_initialization> 20066a4: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 20066a8: 40 00 16 65 call 200c03c <_POSIX_Message_queue_Manager_initialization> 20066ac: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 20066b0: 40 00 17 ce call 200c5e8 <_POSIX_Semaphore_Manager_initialization> 20066b4: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 20066b8: 40 00 17 bf call 200c5b4 <_POSIX_Timer_Manager_initialization> 20066bc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 20066c0: 40 00 16 81 call 200c0c4 <_POSIX_Barrier_Manager_initialization> 20066c4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 20066c8: 40 00 16 8b call 200c0f4 <_POSIX_RWLock_Manager_initialization> 20066cc: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 20066d0: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 20066d4: 40 00 16 f2 call 200c29c <_POSIX_Spinlock_Manager_initialization> 20066d8: 81 e8 00 00 restore 20066dc: 01 00 00 00 nop 0200d5ac <_POSIX_Barrier_Translate_core_barrier_return_code>: int _POSIX_Barrier_Translate_core_barrier_return_code( CORE_barrier_Status the_barrier_status ) { if ( the_barrier_status <= CORE_BARRIER_TIMEOUT ) 200d5ac: 80 a2 20 03 cmp %o0, 3 200d5b0: 08 80 00 05 bleu 200d5c4 <_POSIX_Barrier_Translate_core_barrier_return_code+0x18> 200d5b4: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); 200d5b8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200d5bc: 7f ff e2 a1 call 2006040 <== NOT EXECUTED 200d5c0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 200d5c4: 03 00 80 61 sethi %hi(0x2018400), %g1 200d5c8: 82 10 61 f8 or %g1, 0x1f8, %g1 ! 20185f8 <_POSIX_Barrier_Return_codes> 200d5cc: 81 c3 e0 08 retl 200d5d0: d0 00 40 02 ld [ %g1 + %g2 ], %o0 020063bc <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, boolean is_broadcast ) { 20063bc: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 20063c0: 80 a6 20 00 cmp %i0, 0 20063c4: 02 80 00 0d be 20063f8 <_POSIX_Condition_variables_Signal_support+0x3c> 20063c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20063cc: c2 06 00 00 ld [ %i0 ], %g1 20063d0: 80 a0 7f ff cmp %g1, -1 20063d4: 32 80 00 0c bne,a 2006404 <_POSIX_Condition_variables_Signal_support+0x48> 20063d8: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20063dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20063e0: 7f ff ff ba call 20062c8 <== NOT EXECUTED 20063e4: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20063e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20063ec: 22 80 00 06 be,a 2006404 <_POSIX_Condition_variables_Signal_support+0x48> <== NOT EXECUTED 20063f0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20063f4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20063f8: a0 10 20 00 clr %l0 20063fc: 10 80 00 07 b 2006418 <_POSIX_Condition_variables_Signal_support+0x5c> 2006400: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 2006404: 11 00 80 63 sethi %hi(0x2018c00), %o0 2006408: 94 07 bf f4 add %fp, -12, %o2 200640c: 40 00 0e b8 call 2009eec <_Objects_Get> 2006410: 90 12 20 6c or %o0, 0x6c, %o0 2006414: a0 10 00 08 mov %o0, %l0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 2006418: c2 07 bf f4 ld [ %fp + -12 ], %g1 200641c: 80 a0 60 00 cmp %g1, 0 2006420: 02 80 00 06 be 2006438 <_POSIX_Condition_variables_Signal_support+0x7c> 2006424: b0 04 20 18 add %l0, 0x18, %i0 2006428: 80 a0 60 02 cmp %g1, 2 200642c: 08 80 00 1c bleu 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006430: 90 10 20 16 mov 0x16, %o0 2006434: 30 80 00 18 b,a 2006494 <_POSIX_Condition_variables_Signal_support+0xd8> <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 2006438: 40 00 14 9c call 200b6a8 <_Thread_queue_Dequeue> 200643c: 90 10 00 18 mov %i0, %o0 if ( !the_thread ) 2006440: 80 a2 20 00 cmp %o0, 0 2006444: 22 80 00 02 be,a 200644c <_POSIX_Condition_variables_Signal_support+0x90> 2006448: c0 24 20 14 clr [ %l0 + 0x14 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 200644c: 80 a6 60 00 cmp %i1, 0 2006450: 02 80 00 04 be 2006460 <_POSIX_Condition_variables_Signal_support+0xa4> 2006454: 80 a2 20 00 cmp %o0, 0 2006458: 12 bf ff f8 bne 2006438 <_POSIX_Condition_variables_Signal_support+0x7c> 200645c: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006460: 03 00 80 61 sethi %hi(0x2018400), %g1 2006464: c4 00 63 20 ld [ %g1 + 0x320 ], %g2 ! 2018720 <_Thread_Dispatch_disable_level> 2006468: 90 10 20 00 clr %o0 200646c: 84 00 bf ff add %g2, -1, %g2 2006470: c4 20 63 20 st %g2, [ %g1 + 0x320 ] 2006474: c2 00 63 20 ld [ %g1 + 0x320 ], %g1 2006478: 80 a0 60 00 cmp %g1, 0 200647c: 12 80 00 08 bne 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006480: 01 00 00 00 nop _Thread_Dispatch(); 2006484: 40 00 13 60 call 200b204 <_Thread_Dispatch> 2006488: 01 00 00 00 nop 200648c: 10 80 00 04 b 200649c <_POSIX_Condition_variables_Signal_support+0xe0> 2006490: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006494: 40 00 04 47 call 20075b0 <== NOT EXECUTED 2006498: 01 00 00 00 nop <== NOT EXECUTED } 200649c: 81 c7 e0 08 ret 20064a0: 91 e8 00 08 restore %g0, %o0, %o0 0200653c <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, boolean already_timedout ) { 200653c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2006540: 80 a6 60 00 cmp %i1, 0 2006544: 22 80 00 40 be,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> 2006548: b0 10 20 16 mov 0x16, %i0 200654c: c2 06 40 00 ld [ %i1 ], %g1 2006550: 80 a0 7f ff cmp %g1, -1 2006554: 32 80 00 09 bne,a 2006578 <_POSIX_Condition_variables_Wait_support+0x3c> 2006558: d2 06 40 00 ld [ %i1 ], %o1 200655c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2006560: 40 00 00 c2 call 2006868 <== NOT EXECUTED 2006564: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006568: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200656c: 32 80 00 36 bne,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> <== NOT EXECUTED 2006570: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2006574: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED 2006578: 11 00 80 62 sethi %hi(0x2018800), %o0 200657c: 94 07 bf f4 add %fp, -12, %o2 2006580: 40 00 0e 5b call 2009eec <_Objects_Get> 2006584: 90 12 23 84 or %o0, 0x384, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 2006588: 80 a2 20 00 cmp %o0, 0 200658c: 22 80 00 2e be,a 2006644 <_POSIX_Condition_variables_Wait_support+0x108> 2006590: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2006594: 05 00 80 61 sethi %hi(0x2018400), %g2 2006598: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 2018720 <_Thread_Dispatch_disable_level> ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 200659c: 80 a6 20 00 cmp %i0, 0 20065a0: 82 00 7f ff add %g1, -1, %g1 20065a4: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] 20065a8: 02 80 00 0d be 20065dc <_POSIX_Condition_variables_Wait_support+0xa0> 20065ac: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20065b0: c2 06 00 00 ld [ %i0 ], %g1 20065b4: 80 a0 7f ff cmp %g1, -1 20065b8: 32 80 00 0c bne,a 20065e8 <_POSIX_Condition_variables_Wait_support+0xac> 20065bc: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20065c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20065c4: 7f ff ff 41 call 20062c8 <== NOT EXECUTED 20065c8: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20065cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20065d0: 22 80 00 06 be,a 20065e8 <_POSIX_Condition_variables_Wait_support+0xac> <== NOT EXECUTED 20065d4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20065d8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20065dc: a2 10 20 00 clr %l1 20065e0: 10 80 00 07 b 20065fc <_POSIX_Condition_variables_Wait_support+0xc0> 20065e4: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 20065e8: 11 00 80 63 sethi %hi(0x2018c00), %o0 20065ec: 94 07 bf f4 add %fp, -12, %o2 20065f0: 40 00 0e 3f call 2009eec <_Objects_Get> 20065f4: 90 12 20 6c or %o0, 0x6c, %o0 20065f8: a2 10 00 08 mov %o0, %l1 } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 20065fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006600: 80 a0 60 00 cmp %g1, 0 2006604: 22 80 00 07 be,a 2006620 <_POSIX_Condition_variables_Wait_support+0xe4> 2006608: c4 04 60 14 ld [ %l1 + 0x14 ], %g2 200660c: 80 a0 60 02 cmp %g1, 2 2006610: 18 80 00 36 bgu 20066e8 <_POSIX_Condition_variables_Wait_support+0x1ac> 2006614: 01 00 00 00 nop if ( mutex_status ) return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 2006618: 81 c7 e0 08 ret 200661c: 91 e8 20 16 restore %g0, 0x16, %o0 #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 2006620: 80 a0 a0 00 cmp %g2, 0 2006624: 02 80 00 0a be 200664c <_POSIX_Condition_variables_Wait_support+0x110> 2006628: 01 00 00 00 nop 200662c: c2 06 40 00 ld [ %i1 ], %g1 2006630: 80 a0 80 01 cmp %g2, %g1 2006634: 02 80 00 06 be 200664c <_POSIX_Condition_variables_Wait_support+0x110> 2006638: 01 00 00 00 nop _Thread_Enable_dispatch(); 200663c: 7f ff ff b3 call 2006508 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006640: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 2006644: 81 c7 e0 08 ret 2006648: 81 e8 00 00 restore return EINVAL; } (void) pthread_mutex_unlock( mutex ); 200664c: 40 00 01 95 call 2006ca0 2006650: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 2006654: 80 a6 e0 00 cmp %i3, 0 2006658: 12 80 00 1b bne 20066c4 <_POSIX_Condition_variables_Wait_support+0x188> 200665c: 21 00 80 62 sethi %hi(0x2018800), %l0 the_cond->Mutex = *mutex; 2006660: c2 06 40 00 ld [ %i1 ], %g1 2006664: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006668: c2 04 20 00 ld [ %l0 ], %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 200666c: c6 06 00 00 ld [ %i0 ], %g3 if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 2006670: 84 04 60 18 add %l1, 0x18, %g2 _Thread_Executing->Wait.id = *cond; 2006674: c6 20 60 20 st %g3, [ %g1 + 0x20 ] if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 2006678: c4 20 60 44 st %g2, [ %g1 + 0x44 ] _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 200667c: 92 10 00 1a mov %i2, %o1 2006680: 90 10 00 02 mov %g2, %o0 if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006684: c0 20 60 34 clr [ %g1 + 0x34 ] _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 2006688: 15 00 80 2f sethi %hi(0x200bc00), %o2 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 200668c: 82 10 20 01 mov 1, %g1 2006690: 94 12 a1 80 or %o2, 0x180, %o2 2006694: 40 00 14 73 call 200b860 <_Thread_queue_Enqueue_with_handler> 2006698: c2 24 60 48 st %g1, [ %l1 + 0x48 ] _Thread_Enable_dispatch(); 200669c: 7f ff ff 9b call 2006508 <_Thread_Enable_dispatch> 20066a0: 01 00 00 00 nop /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 20066a4: c2 04 20 00 ld [ %l0 ], %g1 20066a8: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 20066ac: 80 a6 20 00 cmp %i0, 0 20066b0: 02 80 00 07 be 20066cc <_POSIX_Condition_variables_Wait_support+0x190> 20066b4: 80 a6 20 74 cmp %i0, 0x74 20066b8: 12 80 00 0f bne 20066f4 <_POSIX_Condition_variables_Wait_support+0x1b8> 20066bc: 01 00 00 00 nop 20066c0: 30 80 00 03 b,a 20066cc <_POSIX_Condition_variables_Wait_support+0x190> return status; } else { _Thread_Enable_dispatch(); 20066c4: 7f ff ff 91 call 2006508 <_Thread_Enable_dispatch> 20066c8: b0 10 20 74 mov 0x74, %i0 /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 20066cc: 40 00 00 c7 call 20069e8 20066d0: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 20066d4: 80 a2 20 00 cmp %o0, 0 20066d8: 02 80 00 07 be 20066f4 <_POSIX_Condition_variables_Wait_support+0x1b8> 20066dc: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 20066e0: 81 c7 e0 08 ret 20066e4: 91 e8 20 16 restore %g0, 0x16, %o0 20066e8: 40 00 03 b2 call 20075b0 <== NOT EXECUTED 20066ec: 01 00 00 00 nop <== NOT EXECUTED 20066f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } 20066f4: 81 c7 e0 08 ret 20066f8: 81 e8 00 00 restore 0200da64 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 200da64: 9d e3 bf 98 save %sp, -104, %sp uint32_t iterations; boolean are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 200da68: c2 06 20 08 ld [ %i0 + 8 ], %g1 the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 200da6c: 05 00 00 3f sethi %hi(0xfc00), %g2 200da70: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200da74: 84 08 40 02 and %g1, %g2, %g2 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 200da78: 83 30 60 16 srl %g1, 0x16, %g1 200da7c: a7 28 a0 02 sll %g2, 2, %l3 200da80: a8 08 60 1c and %g1, 0x1c, %l4 200da84: a4 10 20 00 clr %l2 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200da88: 03 00 80 63 sethi %hi(0x2018c00), %g1 200da8c: aa 10 63 f0 or %g1, 0x3f0, %l5 ! 2018ff0 <_POSIX_Keys_Information> the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 200da90: a0 10 20 01 mov 1, %l0 200da94: 10 80 00 1b b 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200da98: a2 10 20 01 mov 1, %l1 are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { the_key = (POSIX_Keys_Control *) 200da9c: c2 05 60 20 ld [ %l5 + 0x20 ], %g1 200daa0: c4 00 40 02 ld [ %g1 + %g2 ], %g2 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 200daa4: 80 a0 a0 00 cmp %g2, 0 200daa8: 02 80 00 16 be 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200daac: a0 04 20 01 inc %l0 200dab0: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200dab4: 80 a0 60 00 cmp %g1, 0 200dab8: 02 80 00 12 be 200db00 <_POSIX_Keys_Run_destructors+0x9c> 200dabc: b0 05 00 02 add %l4, %g2, %i0 200dac0: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2 200dac4: 80 a0 a0 00 cmp %g2, 0 200dac8: 22 80 00 0f be,a 200db04 <_POSIX_Keys_Run_destructors+0xa0> 200dacc: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 200dad0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200dad4: c2 00 40 13 ld [ %g1 + %l3 ], %g1 if ( value ) { 200dad8: 90 90 60 00 orcc %g1, 0, %o0 200dadc: 22 80 00 0a be,a 200db04 <_POSIX_Keys_Run_destructors+0xa0> 200dae0: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 200dae4: 9f c0 80 00 call %g2 200dae8: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 200daec: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200daf0: c2 00 40 13 ld [ %g1 + %l3 ], %g1 200daf4: 80 a0 00 01 cmp %g0, %g1 200daf8: 82 40 3f ff addx %g0, -1, %g1 200dafc: a2 0c 40 01 and %l1, %g1, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200db00: c2 15 60 10 lduh [ %l5 + 0x10 ], %g1 200db04: 80 a4 00 01 cmp %l0, %g1 200db08: 08 bf ff e5 bleu 200da9c <_POSIX_Keys_Run_destructors+0x38> 200db0c: 85 2c 20 02 sll %l0, 2, %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 200db10: 80 a4 60 01 cmp %l1, 1 200db14: 02 80 00 05 be 200db28 <_POSIX_Keys_Run_destructors+0xc4> 200db18: a4 04 a0 01 inc %l2 * loop. It seems rude to unnecessarily lock up a system. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS ) 200db1c: 80 a4 a0 04 cmp %l2, 4 200db20: 12 bf ff dd bne 200da94 <_POSIX_Keys_Run_destructors+0x30> 200db24: a0 10 20 01 mov 1, %l0 200db28: 81 c7 e0 08 ret 200db2c: 81 e8 00 00 restore 02012bb8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bb8: 9d e3 bf 88 save %sp, -120, %sp CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 2012bbc: 92 10 20 ff mov 0xff, %o1 2012bc0: 40 00 11 be call 20172b8 2012bc4: 90 10 00 18 mov %i0, %o0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bc8: a8 10 00 18 mov %i0, %l4 CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 2012bcc: a0 10 00 08 mov %o0, %l0 const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2012bd0: 92 10 00 1a mov %i2, %o1 struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); if ( n > NAME_MAX ) 2012bd4: 80 a2 20 ff cmp %o0, 0xff 2012bd8: 18 80 00 62 bgu 2012d60 <_POSIX_Message_queue_Create_support+0x1a8> 2012bdc: b0 10 20 5b mov 0x5b, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2012be0: 05 00 80 8e sethi %hi(0x2023800), %g2 2012be4: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2012be8: 82 00 60 01 inc %g1 2012bec: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 2012bf0: a4 10 20 10 mov 0x10, %l2 2012bf4: 80 a6 a0 00 cmp %i2, 0 2012bf8: 02 80 00 14 be 2012c48 <_POSIX_Message_queue_Create_support+0x90> 2012bfc: a2 10 20 0a mov 0xa, %l1 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 2012c00: c2 06 a0 04 ld [ %i2 + 4 ], %g1 2012c04: 80 a0 60 00 cmp %g1, 0 2012c08: 04 80 00 06 ble 2012c20 <_POSIX_Message_queue_Create_support+0x68> 2012c0c: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 2012c10: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2012c14: 80 a0 60 00 cmp %g1, 0 2012c18: 34 80 00 08 bg,a 2012c38 <_POSIX_Message_queue_Create_support+0x80> 2012c1c: 90 07 bf e8 add %fp, -24, %o0 _Thread_Enable_dispatch(); 2012c20: 7f ff ff d9 call 2012b84 <_Thread_Enable_dispatch> 2012c24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 2012c28: 40 00 0a 5b call 2015594 <__errno> 2012c2c: 01 00 00 00 nop 2012c30: 10 80 00 3a b 2012d18 <_POSIX_Message_queue_Create_support+0x160> 2012c34: 82 10 20 16 mov 0x16, %g1 ! 16 } attr = *attr_ptr; 2012c38: 40 00 0c 3d call 2015d2c 2012c3c: 94 10 20 10 mov 0x10, %o2 2012c40: e4 07 bf f0 ld [ %fp + -16 ], %l2 2012c44: e2 07 bf ec ld [ %fp + -20 ], %l1 */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) 2012c48: 27 00 80 8f sethi %hi(0x2023c00), %l3 2012c4c: 7f ff ec 39 call 200dd30 <_Objects_Allocate> 2012c50: 90 14 e1 68 or %l3, 0x168, %o0 ! 2023d68 <_POSIX_Message_queue_Information> rtems_set_errno_and_return_minus_one( ENFILE ); } #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 2012c54: b4 92 20 00 orcc %o0, 0, %i2 2012c58: 32 80 00 08 bne,a 2012c78 <_POSIX_Message_queue_Create_support+0xc0> 2012c5c: 82 10 20 01 mov 1, %g1 _Thread_Enable_dispatch(); 2012c60: 7f ff ff c9 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012c64: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 2012c68: 40 00 0a 4b call 2015594 <__errno> <== NOT EXECUTED 2012c6c: 01 00 00 00 nop <== NOT EXECUTED 2012c70: 10 80 00 2a b 2012d18 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 2012c74: 82 10 20 17 mov 0x17, %g1 ! 17 <== NOT EXECUTED } the_mq->process_shared = pshared; 2012c78: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] 2012c7c: 92 10 00 10 mov %l0, %o1 the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 2012c80: c2 26 a0 18 st %g1, [ %i2 + 0x18 ] _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; 2012c84: c2 26 a0 14 st %g1, [ %i2 + 0x14 ] the_mq->open_count = 1; 2012c88: c2 26 a0 1c st %g1, [ %i2 + 0x1c ] 2012c8c: 21 00 80 8e sethi %hi(0x2023800), %l0 2012c90: 7f ff ea d0 call 200d7d0 <_Heap_Allocate> 2012c94: 90 14 21 9c or %l0, 0x19c, %o0 ! 202399c <_Workspace_Area> * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); if (!name) { 2012c98: b2 92 20 00 orcc %o0, 0, %i1 2012c9c: 12 80 00 0a bne 2012cc4 <_POSIX_Message_queue_Create_support+0x10c> 2012ca0: 01 00 00 00 nop _POSIX_Message_queue_Free( the_mq ); 2012ca4: 7f ff ff b1 call 2012b68 <_POSIX_Message_queue_Free> <== NOT EXECUTED 2012ca8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012cac: 7f ff ff b6 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012cb0: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 2012cb4: 40 00 0a 38 call 2015594 <__errno> <== NOT EXECUTED 2012cb8: 01 00 00 00 nop <== NOT EXECUTED 2012cbc: 10 80 00 17 b 2012d18 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 2012cc0: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED } strcpy( name, name_arg ); 2012cc4: 40 00 0f 18 call 2016924 2012cc8: 92 10 00 14 mov %l4, %o1 */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 2012ccc: 94 10 00 11 mov %l1, %o2 * Note that thread blocking discipline should be based on the * current scheduling policy. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 2012cd0: c0 26 a0 60 clr [ %i2 + 0x60 ] if ( ! _CORE_message_queue_Initialize( 2012cd4: 96 10 00 12 mov %l2, %o3 2012cd8: 90 06 a0 20 add %i2, 0x20, %o0 2012cdc: 40 00 03 56 call 2013a34 <_CORE_message_queue_Initialize> 2012ce0: 92 06 a0 60 add %i2, 0x60, %o1 2012ce4: 80 a2 20 00 cmp %o0, 0 2012ce8: 12 80 00 0f bne 2012d24 <_POSIX_Message_queue_Create_support+0x16c> 2012cec: 90 14 e1 68 or %l3, 0x168, %o0 #if 0 && defined(RTEMS_MULTIPROCESSING) if ( pshared == PTHREAD_PROCESS_SHARED ) _Objects_MP_Close( &_POSIX_Message_queue_Information, the_mq->Object.id ); #endif _POSIX_Message_queue_Free( the_mq ); 2012cf0: 7f ff ff 9e call 2012b68 <_POSIX_Message_queue_Free> <== NOT EXECUTED 2012cf4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2012cf8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2012cfc: 7f ff ea dc call 200d86c <_Heap_Free> <== NOT EXECUTED 2012d00: 90 14 21 9c or %l0, 0x19c, %o0 <== NOT EXECUTED _Workspace_Free(name); _Thread_Enable_dispatch(); 2012d04: 7f ff ff a0 call 2012b84 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012d08: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 2012d0c: 40 00 0a 22 call 2015594 <__errno> <== NOT EXECUTED 2012d10: 01 00 00 00 nop <== NOT EXECUTED 2012d14: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 2012d18: c2 22 00 00 st %g1, [ %o0 ] 2012d1c: 81 c7 e0 08 ret 2012d20: 91 e8 3f ff restore %g0, -1, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2012d24: c2 06 a0 08 ld [ %i2 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012d28: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2012d2c: 05 00 00 3f sethi %hi(0xfc00), %g2 2012d30: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012d34: 82 08 40 02 and %g1, %g2, %g1 2012d38: 80 a0 40 03 cmp %g1, %g3 2012d3c: 38 80 00 06 bgu,a 2012d54 <_POSIX_Message_queue_Create_support+0x19c> 2012d40: f4 26 c0 00 st %i2, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2012d44: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2012d48: 83 28 60 02 sll %g1, 2, %g1 2012d4c: f4 20 80 01 st %i2, [ %g2 + %g1 ] &_POSIX_Message_queue_Information, &the_mq->Object, (char *) name ); *message_queue = the_mq; 2012d50: f4 26 c0 00 st %i2, [ %i3 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2012d54: f2 26 a0 0c st %i1, [ %i2 + 0xc ] (char *) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2012d58: 7f ff ff 8b call 2012b84 <_Thread_Enable_dispatch> 2012d5c: b0 10 20 00 clr %i0 return 0; } 2012d60: 81 c7 e0 08 ret 2012d64: 81 e8 00 00 restore 02009980 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 2009980: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 2009984: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2009988: 80 a0 60 00 cmp %g1, 0 200998c: 12 80 00 1f bne 2009a08 <_POSIX_Message_queue_Delete+0x88> 2009990: b2 10 00 18 mov %i0, %i1 2009994: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 2009998: 80 a0 60 00 cmp %g1, 0 200999c: 12 80 00 1b bne 2009a08 <_POSIX_Message_queue_Delete+0x88> 20099a0: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ if ( the_mq->Object.name ) 20099a4: d2 06 20 0c ld [ %i0 + 0xc ], %o1 20099a8: 80 a2 60 00 cmp %o1, 0 20099ac: 02 80 00 04 be 20099bc <_POSIX_Message_queue_Delete+0x3c> 20099b0: 11 00 80 8e sethi %hi(0x2023800), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20099b4: 40 00 0f ae call 200d86c <_Heap_Free> <== NOT EXECUTED 20099b8: 90 12 21 9c or %o0, 0x19c, %o0 ! 202399c <_Workspace_Area> <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20099bc: 03 00 80 8f sethi %hi(0x2023c00), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20099c0: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20099c4: b0 10 61 68 or %g1, 0x168, %i0 20099c8: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 20099cc: 03 00 00 3f sethi %hi(0xfc00), %g1 20099d0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20099d4: 82 08 c0 01 and %g3, %g1, %g1 20099d8: 80 a0 40 02 cmp %g1, %g2 20099dc: 18 80 00 05 bgu 20099f0 <_POSIX_Message_queue_Delete+0x70> 20099e0: 90 06 60 20 add %i1, 0x20, %o0 information->local_table[ index ] = the_object; 20099e4: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 20099e8: 83 28 60 02 sll %g1, 2, %g1 20099ec: c0 20 80 01 clr [ %g2 + %g1 ] _Workspace_Free( the_mq->Object.name ); _Objects_Close( &_POSIX_Message_queue_Information, &the_mq->Object ); _CORE_message_queue_Close( 20099f0: 92 10 20 00 clr %o1 20099f4: 94 10 20 05 mov 5, %o2 20099f8: 40 00 0d 7a call 200cfe0 <_CORE_message_queue_Close> 20099fc: c0 26 60 0c clr [ %i1 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 2009a00: 40 00 11 ce call 200e138 <_Objects_Free> 2009a04: 81 e8 00 00 restore 2009a08: 81 c7 e0 08 ret 2009a0c: 81 e8 00 00 restore 02012b68 <_POSIX_Message_queue_Free>: */ RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { 2012b68: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 2012b6c: 11 00 80 8f sethi %hi(0x2023c00), %o0 <== NOT EXECUTED 2012b70: 90 12 21 68 or %o0, 0x168, %o0 ! 2023d68 <_POSIX_Message_queue_Information> <== NOT EXECUTED 2012b74: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2012b78: 7f ff ed 70 call 200e138 <_Objects_Free> <== NOT EXECUTED 2012b7c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2012b80: 01 00 00 00 nop 02009eb0 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 2009eb0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) 2009eb4: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009eb8: 94 07 bf f4 add %fp, -12, %o2 2009ebc: 90 12 23 20 or %o0, 0x320, %o0 2009ec0: 40 00 10 e0 call 200e240 <_Objects_Get> 2009ec4: 92 10 00 18 mov %i0, %o1 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009ec8: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 2009ecc: 94 10 00 19 mov %i1, %o2 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009ed0: 80 a0 60 01 cmp %g1, 1 2009ed4: 02 80 00 09 be 2009ef8 <_POSIX_Message_queue_Receive_support+0x48> 2009ed8: 9a 10 00 1d mov %i5, %o5 2009edc: 80 a0 60 01 cmp %g1, 1 2009ee0: 2a 80 00 0c bcs,a 2009f10 <_POSIX_Message_queue_Receive_support+0x60> 2009ee4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2009ee8: 80 a0 60 02 cmp %g1, 2 2009eec: 12 80 00 3f bne 2009fe8 <_POSIX_Message_queue_Receive_support+0x138> 2009ef0: 01 00 00 00 nop 2009ef4: 30 80 00 0d b,a 2009f28 <_POSIX_Message_queue_Receive_support+0x78> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2009ef8: 40 00 15 98 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009efc: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009f00: 40 00 05 c9 call 200b624 <== NOT EXECUTED 2009f04: 01 00 00 00 nop <== NOT EXECUTED _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 2009f08: 81 c7 e0 08 ret <== NOT EXECUTED 2009f0c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 2009f10: 82 08 a0 03 and %g2, 3, %g1 2009f14: 80 a0 60 01 cmp %g1, 1 2009f18: 32 80 00 0a bne,a 2009f40 <_POSIX_Message_queue_Receive_support+0x90> 2009f1c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 _Thread_Enable_dispatch(); 2009f20: 7f ff ff d7 call 2009e7c <_Thread_Enable_dispatch> 2009f24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); 2009f28: 40 00 2d 9b call 2015594 <__errno> 2009f2c: 01 00 00 00 nop 2009f30: 82 10 20 09 mov 9, %g1 ! 9 2009f34: c2 22 00 00 st %g1, [ %o0 ] 2009f38: 10 80 00 2e b 2009ff0 <_POSIX_Message_queue_Receive_support+0x140> 2009f3c: 90 10 3f ff mov -1, %o0 } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 2009f40: c2 02 20 6c ld [ %o0 + 0x6c ], %g1 2009f44: 80 a6 80 01 cmp %i2, %g1 2009f48: 1a 80 00 08 bcc 2009f68 <_POSIX_Message_queue_Receive_support+0xb8> 2009f4c: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 2009f50: 7f ff ff cb call 2009e7c <_Thread_Enable_dispatch> 2009f54: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EMSGSIZE ); 2009f58: 40 00 2d 8f call 2015594 <__errno> 2009f5c: 01 00 00 00 nop 2009f60: 10 bf ff f5 b 2009f34 <_POSIX_Message_queue_Receive_support+0x84> 2009f64: 82 10 20 7a mov 0x7a, %g1 ! 7a length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 2009f68: 02 80 00 05 be 2009f7c <_POSIX_Message_queue_Receive_support+0xcc> 2009f6c: 98 10 20 00 clr %o4 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 2009f70: 83 30 a0 0e srl %g2, 0xe, %g1 2009f74: 82 18 60 01 xor %g1, 1, %g1 2009f78: 98 08 60 01 and %g1, 1, %o4 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 2009f7c: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 2009f80: 90 02 20 20 add %o0, 0x20, %o0 2009f84: 92 10 00 18 mov %i0, %o1 2009f88: 96 07 bf f0 add %fp, -16, %o3 2009f8c: 40 00 0c 42 call 200d094 <_CORE_message_queue_Seize> 2009f90: c2 27 bf f0 st %g1, [ %fp + -16 ] &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 2009f94: 7f ff ff ba call 2009e7c <_Thread_Enable_dispatch> 2009f98: 3b 00 80 8e sethi %hi(0x2023800), %i5 *msg_prio = 2009f9c: c4 07 62 30 ld [ %i5 + 0x230 ], %g2 ! 2023a30 <_Thread_Executing> 2009fa0: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009fa4: c6 00 a0 34 ld [ %g2 + 0x34 ], %g3 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 2009fa8: 85 38 60 1f sra %g1, 0x1f, %g2 2009fac: 82 18 80 01 xor %g2, %g1, %g1 2009fb0: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 2009fb4: 80 a0 e0 00 cmp %g3, 0 2009fb8: 12 80 00 04 bne 2009fc8 <_POSIX_Message_queue_Receive_support+0x118> 2009fbc: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 2009fc0: 10 80 00 0c b 2009ff0 <_POSIX_Message_queue_Receive_support+0x140> 2009fc4: d0 07 bf f0 ld [ %fp + -16 ], %o0 rtems_set_errno_and_return_minus_one( 2009fc8: 40 00 2d 73 call 2015594 <__errno> 2009fcc: 01 00 00 00 nop 2009fd0: c2 07 62 30 ld [ %i5 + 0x230 ], %g1 2009fd4: a0 10 00 08 mov %o0, %l0 2009fd8: 40 00 00 d2 call 200a320 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 2009fdc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 2009fe0: 10 bf ff d6 b 2009f38 <_POSIX_Message_queue_Receive_support+0x88> 2009fe4: d0 24 00 00 st %o0, [ %l0 ] _POSIX_Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); 2009fe8: 40 00 05 85 call 200b5fc <== NOT EXECUTED 2009fec: 01 00 00 00 nop <== NOT EXECUTED } 2009ff0: b0 10 00 08 mov %o0, %i0 2009ff4: 81 c7 e0 08 ret 2009ff8: 81 e8 00 00 restore 0200a048 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, boolean wait, Watchdog_Interval timeout ) { 200a048: 9d e3 bf 88 save %sp, -120, %sp /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 200a04c: 80 a6 e0 20 cmp %i3, 0x20 200a050: 28 80 00 06 bleu,a 200a068 <_POSIX_Message_queue_Send_support+0x20> 200a054: 11 00 80 8f sethi %hi(0x2023c00), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 200a058: 40 00 2d 4f call 2015594 <__errno> 200a05c: 01 00 00 00 nop 200a060: 10 80 00 12 b 200a0a8 <_POSIX_Message_queue_Send_support+0x60> 200a064: 82 10 20 16 mov 0x16, %g1 ! 16 200a068: 92 10 00 18 mov %i0, %o1 200a06c: 90 12 23 20 or %o0, 0x320, %o0 200a070: 40 00 10 74 call 200e240 <_Objects_Get> 200a074: 94 07 bf f4 add %fp, -12, %o2 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a078: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a07c: 80 a0 60 01 cmp %g1, 1 200a080: 02 80 00 0d be 200a0b4 <_POSIX_Message_queue_Send_support+0x6c> 200a084: 01 00 00 00 nop 200a088: 2a 80 00 11 bcs,a 200a0cc <_POSIX_Message_queue_Send_support+0x84> 200a08c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 200a090: 80 a0 60 02 cmp %g1, 2 200a094: 12 80 00 35 bne 200a168 <_POSIX_Message_queue_Send_support+0x120> 200a098: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a09c: 40 00 2d 3e call 2015594 <__errno> 200a0a0: 01 00 00 00 nop 200a0a4: 82 10 20 09 mov 9, %g1 ! 9 200a0a8: c2 22 00 00 st %g1, [ %o0 ] 200a0ac: 10 80 00 31 b 200a170 <_POSIX_Message_queue_Send_support+0x128> 200a0b0: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 200a0b4: 40 00 15 29 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 200a0b8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a0bc: 40 00 05 5a call 200b624 <== NOT EXECUTED 200a0c0: 01 00 00 00 nop <== NOT EXECUTED msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 200a0c4: 81 c7 e0 08 ret <== NOT EXECUTED 200a0c8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 200a0cc: 80 88 a0 03 btst 3, %g2 200a0d0: 12 80 00 05 bne 200a0e4 <_POSIX_Message_queue_Send_support+0x9c> 200a0d4: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); 200a0d8: 7f ff ff cf call 200a014 <_Thread_Enable_dispatch> 200a0dc: 01 00 00 00 nop 200a0e0: 30 bf ff ef b,a 200a09c <_POSIX_Message_queue_Send_support+0x54> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 200a0e4: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 200a0e8: 02 80 00 05 be 200a0fc <_POSIX_Message_queue_Send_support+0xb4> 200a0ec: 82 10 20 00 clr %g1 do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 200a0f0: 83 30 a0 0e srl %g2, 0xe, %g1 200a0f4: 82 18 60 01 xor %g1, 1, %g1 200a0f8: 82 08 60 01 and %g1, 1, %g1 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 200a0fc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200a100: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 200a104: 92 10 00 19 mov %i1, %o1 200a108: 94 10 00 1a mov %i2, %o2 200a10c: 96 10 00 18 mov %i0, %o3 200a110: 9a 20 00 1b neg %i3, %o5 200a114: 98 10 20 00 clr %o4 200a118: 40 00 0c 2c call 200d1c8 <_CORE_message_queue_Submit> 200a11c: 90 02 20 20 add %o0, 0x20, %o0 _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 200a120: 7f ff ff bd call 200a014 <_Thread_Enable_dispatch> 200a124: ba 10 00 08 mov %o0, %i5 * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 200a128: 80 a7 60 07 cmp %i5, 7 200a12c: 12 80 00 06 bne 200a144 <_POSIX_Message_queue_Send_support+0xfc> 200a130: 80 a7 60 00 cmp %i5, 0 msg_status = _Thread_Executing->Wait.return_code; 200a134: 03 00 80 8e sethi %hi(0x2023800), %g1 200a138: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 2023a30 <_Thread_Executing> 200a13c: fa 00 60 34 ld [ %g1 + 0x34 ], %i5 if ( !msg_status ) 200a140: 80 a7 60 00 cmp %i5, 0 200a144: 02 80 00 0b be 200a170 <_POSIX_Message_queue_Send_support+0x128> 200a148: 90 10 20 00 clr %o0 return msg_status; rtems_set_errno_and_return_minus_one( 200a14c: 40 00 2d 12 call 2015594 <__errno> 200a150: 01 00 00 00 nop 200a154: a0 10 00 08 mov %o0, %l0 200a158: 40 00 00 72 call 200a320 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 200a15c: 90 10 00 1d mov %i5, %o0 200a160: 10 bf ff d3 b 200a0ac <_POSIX_Message_queue_Send_support+0x64> 200a164: d0 24 00 00 st %o0, [ %l0 ] _POSIX_Message_queue_Translate_core_message_queue_return_code( msg_status ) ); } return POSIX_BOTTOM_REACHED(); 200a168: 40 00 05 25 call 200b5fc <== NOT EXECUTED 200a16c: 01 00 00 00 nop <== NOT EXECUTED } 200a170: b0 10 00 08 mov %o0, %i0 200a174: 81 c7 e0 08 ret 200a178: 81 e8 00 00 restore 0200a320 <_POSIX_Message_queue_Translate_core_message_queue_return_code>: */ int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { 200a320: 9d e3 bf 98 save %sp, -104, %sp switch ( the_message_queue_status ) { 200a324: 80 a6 20 03 cmp %i0, 3 200a328: 02 80 00 1c be 200a398 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x78> 200a32c: 94 10 00 18 mov %i0, %o2 200a330: 80 a6 20 03 cmp %i0, 3 200a334: 18 80 00 0a bgu 200a35c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x3c> 200a338: 80 a6 20 05 cmp %i0, 5 200a33c: 80 a6 20 01 cmp %i0, 1 200a340: 02 80 00 1e be 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a344: b0 10 20 7a mov 0x7a, %i0 200a348: 80 a2 a0 01 cmp %o2, 1 200a34c: 38 80 00 1b bgu,a 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a350: b0 10 20 0b mov 0xb, %i0 200a354: 81 c7 e0 08 ret <== NOT EXECUTED 200a358: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 200a35c: 02 80 00 11 be 200a3a0 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x80> 200a360: 80 a6 20 05 cmp %i0, 5 200a364: 2a 80 00 15 bcs,a 200a3b8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x98> 200a368: b0 10 20 0b mov 0xb, %i0 200a36c: 80 a6 20 06 cmp %i0, 6 200a370: 02 80 00 08 be 200a390 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x70> 200a374: 03 00 44 44 sethi %hi(0x1111000), %g1 200a378: 82 10 61 11 or %g1, 0x111, %g1 ! 1111111 <== NOT EXECUTED 200a37c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 200a380: 12 80 00 0a bne 200a3a8 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x88> <== NOT EXECUTED 200a384: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 200a388: 81 c7 e0 08 ret <== NOT EXECUTED 200a38c: 91 e8 20 58 restore %g0, 0x58, %o0 <== NOT EXECUTED 200a390: 81 c7 e0 08 ret 200a394: 91 e8 20 74 restore %g0, 0x74, %o0 /* * Bad message size */ case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: return EMSGSIZE; 200a398: 81 c7 e0 08 ret <== NOT EXECUTED 200a39c: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED /* * Out of message buffers to queue pending message */ case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED: return ENOMEM; 200a3a0: 81 c7 e0 08 ret 200a3a4: 91 e8 20 09 restore %g0, 9, %o0 * RTEMS POSIX API implementation does not support multiprocessing. */ case THREAD_STATUS_PROXY_BLOCKING: return ENOSYS; } _Internal_error_Occurred( 200a3a8: 40 00 0e 35 call 200dc7c <_Internal_error_Occurred> <== NOT EXECUTED 200a3ac: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 200a3b0: 40 00 04 93 call 200b5fc <== NOT EXECUTED 200a3b4: 81 e8 00 00 restore <== NOT EXECUTED } 200a3b8: 81 c7 e0 08 ret 200a3bc: 81 e8 00 00 restore 0200f788 <_POSIX_Mutex_From_core_mutex_status>: */ int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { 200f788: 9d e3 bf 98 save %sp, -104, %sp switch ( status ) { 200f78c: 80 a6 20 06 cmp %i0, 6 200f790: 18 80 00 14 bgu 200f7e0 <_POSIX_Mutex_From_core_mutex_status+0x58> 200f794: 92 10 20 32 mov 0x32, %o1 200f798: 83 2e 20 02 sll %i0, 2, %g1 200f79c: 05 00 80 3d sethi %hi(0x200f400), %g2 200f7a0: 84 10 a3 6c or %g2, 0x36c, %g2 ! 200f76c <_POSIX_Message_queue_Manager_initialization+0x58> 200f7a4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200f7a8: 81 c0 40 00 jmp %g1 200f7ac: 01 00 00 00 nop 200f7b0: 81 c7 e0 08 ret 200f7b4: 91 e8 20 74 restore %g0, 0x74, %o0 200f7b8: 81 c7 e0 08 ret 200f7bc: 91 e8 20 16 restore %g0, 0x16, %o0 200f7c0: 81 c7 e0 08 ret 200f7c4: 91 e8 20 00 restore %g0, 0, %o0 case CORE_MUTEX_STATUS_SUCCESSFUL: return 0; 200f7c8: 81 c7 e0 08 ret 200f7cc: 91 e8 20 10 restore %g0, 0x10, %o0 case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT: return EBUSY; 200f7d0: 81 c7 e0 08 ret 200f7d4: 91 e8 20 2d restore %g0, 0x2d, %o0 case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED: return EDEADLK; 200f7d8: 81 c7 e0 08 ret 200f7dc: 91 e8 20 01 restore %g0, 1, %o0 case CORE_MUTEX_STATUS_CEILING_VIOLATED: return EINVAL; default: break; } assert( 0 ); 200f7e0: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 200f7e4: 15 00 80 5b sethi %hi(0x2016c00), %o2 <== NOT EXECUTED 200f7e8: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED 200f7ec: 94 12 a3 e0 or %o2, 0x3e0, %o2 <== NOT EXECUTED 200f7f0: 7f ff d1 90 call 2003e30 <__assert> <== NOT EXECUTED 200f7f4: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 200f7f8: 81 c7 e0 08 ret <== NOT EXECUTED 200f7fc: 81 e8 00 00 restore <== NOT EXECUTED 02007440 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, boolean blocking, Watchdog_Interval timeout ) { 2007440: 9d e3 bf 90 save %sp, -112, %sp ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007444: 80 a6 20 00 cmp %i0, 0 2007448: 32 80 00 05 bne,a 200745c <_POSIX_Mutex_Lock_support+0x1c> 200744c: c2 06 00 00 ld [ %i0 ], %g1 2007450: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007454: 10 80 00 15 b 20074a8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 2007458: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED 200745c: 80 a0 7f ff cmp %g1, -1 2007460: 32 80 00 0c bne,a 2007490 <_POSIX_Mutex_Lock_support+0x50> 2007464: d2 06 00 00 ld [ %i0 ], %o1 2007468: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200746c: 7f ff ff 8f call 20072a8 <== NOT EXECUTED 2007470: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007474: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007478: 22 80 00 06 be,a 2007490 <_POSIX_Mutex_Lock_support+0x50> <== NOT EXECUTED 200747c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2007480: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007484: b0 10 20 00 clr %i0 <== NOT EXECUTED 2007488: 10 80 00 08 b 20074a8 <_POSIX_Mutex_Lock_support+0x68> <== NOT EXECUTED 200748c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007490: 11 00 80 6a sethi %hi(0x201a800), %o0 2007494: 94 07 bf f4 add %fp, -12, %o2 2007498: 90 12 21 64 or %o0, 0x164, %o0 200749c: 40 00 0e 1d call 200ad10 <_Objects_Get_isr_disable> 20074a0: 96 07 bf f0 add %fp, -16, %o3 20074a4: b0 10 00 08 mov %o0, %i0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 20074a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20074ac: 80 a0 60 00 cmp %g1, 0 20074b0: 22 80 00 06 be,a 20074c8 <_POSIX_Mutex_Lock_support+0x88> 20074b4: 03 00 80 69 sethi %hi(0x201a400), %g1 20074b8: 80 a0 60 02 cmp %g1, 2 20074bc: 08 80 00 86 bleu 20076d4 <_POSIX_Mutex_Lock_support+0x294> 20074c0: 90 10 20 16 mov 0x16, %o0 20074c4: 30 80 00 82 b,a 20076cc <_POSIX_Mutex_Lock_support+0x28c> <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 20074c8: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 20074cc: 80 a0 60 00 cmp %g1, 0 20074d0: 02 80 00 0e be 2007508 <_POSIX_Mutex_Lock_support+0xc8> 20074d4: 03 00 80 69 sethi %hi(0x201a400), %g1 20074d8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 20074dc: 02 80 00 0c be 200750c <_POSIX_Mutex_Lock_support+0xcc> <== NOT EXECUTED 20074e0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 <== NOT EXECUTED 20074e4: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED 20074e8: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201a6e0 <_System_state_Current> <== NOT EXECUTED 20074ec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20074f0: 08 80 00 05 bleu 2007504 <_POSIX_Mutex_Lock_support+0xc4> <== NOT EXECUTED 20074f4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20074f8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20074fc: 40 00 0c b2 call 200a7c4 <_Internal_error_Occurred> <== NOT EXECUTED 2007500: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007504: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED 2007508: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201a5e0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 200750c: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007510: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007514: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 2007518: 80 a0 60 00 cmp %g1, 0 200751c: 22 80 00 3a be,a 2007604 <_POSIX_Mutex_Lock_support+0x1c4> 2007520: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2007524: c0 26 20 64 clr [ %i0 + 0x64 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007528: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200752c: c6 06 20 5c ld [ %i0 + 0x5c ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007530: c2 26 20 74 st %g1, [ %i0 + 0x74 ] 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; 2007534: c4 26 20 70 st %g2, [ %i0 + 0x70 ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007538: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200753c: 80 a0 e0 02 cmp %g3, 2 2007540: 02 80 00 05 be 2007554 <_POSIX_Mutex_Lock_support+0x114> 2007544: c2 26 20 68 st %g1, [ %i0 + 0x68 ] 2007548: 80 a0 e0 03 cmp %g3, 3 200754c: 32 80 00 06 bne,a 2007564 <_POSIX_Mutex_Lock_support+0x124> 2007550: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007554: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007558: 82 00 60 01 inc %g1 200755c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007560: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 2007564: 80 a0 60 03 cmp %g1, 3 2007568: 22 80 00 03 be,a 2007574 <_POSIX_Mutex_Lock_support+0x134> 200756c: c6 06 20 60 ld [ %i0 + 0x60 ], %g3 _ISR_Enable( level ); 2007570: 30 80 00 35 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007574: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 if ( current == ceiling ) { 2007578: 80 a0 40 03 cmp %g1, %g3 200757c: 12 80 00 03 bne 2007588 <_POSIX_Mutex_Lock_support+0x148> 2007580: 01 00 00 00 nop _ISR_Enable( level ); 2007584: 30 80 00 30 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007588: 08 80 00 17 bleu 20075e4 <_POSIX_Mutex_Lock_support+0x1a4> 200758c: 82 10 20 06 mov 6, %g1 2007590: 21 00 80 69 sethi %hi(0x201a400), %l0 2007594: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007598: 82 00 60 01 inc %g1 200759c: c2 24 21 00 st %g1, [ %l0 + 0x100 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 20075a0: 7f ff f1 be call 2003c98 20075a4: 01 00 00 00 nop _Thread_Change_priority( 20075a8: d2 06 20 60 ld [ %i0 + 0x60 ], %o1 20075ac: d0 06 20 70 ld [ %i0 + 0x70 ], %o0 20075b0: 40 00 11 7f call 200bbac <_Thread_Change_priority> 20075b4: 94 10 20 00 clr %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20075b8: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 20075bc: 82 00 7f ff add %g1, -1, %g1 20075c0: c2 24 21 00 st %g1, [ %l0 + 0x100 ] 20075c4: c2 04 21 00 ld [ %l0 + 0x100 ], %g1 20075c8: 80 a0 60 00 cmp %g1, 0 20075cc: 32 80 00 3b bne,a 20076b8 <_POSIX_Mutex_Lock_support+0x278> 20075d0: 03 00 80 69 sethi %hi(0x201a400), %g1 <== NOT EXECUTED _Thread_Dispatch(); 20075d4: 40 00 12 b3 call 200c0a0 <_Thread_Dispatch> 20075d8: 01 00 00 00 nop the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 20075dc: 10 80 00 37 b 20076b8 <_POSIX_Mutex_Lock_support+0x278> 20075e0: 03 00 80 69 sethi %hi(0x201a400), %g1 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20075e4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; 20075e8: 82 10 20 01 mov 1, %g1 the_mutex->nest_count = 0; /* undo locking above */ 20075ec: c0 26 20 68 clr [ %i0 + 0x68 ] _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; the_mutex->lock = CORE_MUTEX_UNLOCKED; 20075f0: c2 26 20 64 st %g1, [ %i0 + 0x64 ] the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20075f4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20075f8: 82 00 7f ff add %g1, -1, %g1 20075fc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2007600: 30 80 00 11 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> /* * 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 ) ) { 2007604: 80 a0 40 02 cmp %g1, %g2 2007608: 12 80 00 13 bne 2007654 <_POSIX_Mutex_Lock_support+0x214> 200760c: 80 a6 60 00 cmp %i1, 0 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007610: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2007614: 80 a0 60 00 cmp %g1, 0 2007618: 22 80 00 07 be,a 2007634 <_POSIX_Mutex_Lock_support+0x1f4> 200761c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED 2007620: 80 a0 60 01 cmp %g1, 1 2007624: 12 80 00 0c bne 2007654 <_POSIX_Mutex_Lock_support+0x214> 2007628: 80 a6 60 00 cmp %i1, 0 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; 200762c: 10 80 00 05 b 2007640 <_POSIX_Mutex_Lock_support+0x200> 2007630: 82 10 20 02 mov 2, %g1 * 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++; 2007634: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007638: c2 26 20 68 st %g1, [ %i0 + 0x68 ] <== NOT EXECUTED _ISR_Enable( level ); 200763c: 30 80 00 02 b,a 2007644 <_POSIX_Mutex_Lock_support+0x204> <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007640: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] _ISR_Enable( level ); 2007644: 7f ff f1 95 call 2003c98 2007648: 01 00 00 00 nop 200764c: 10 80 00 1b b 20076b8 <_POSIX_Mutex_Lock_support+0x278> 2007650: 03 00 80 69 sethi %hi(0x201a400), %g1 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 2007654: 12 80 00 08 bne 2007674 <_POSIX_Mutex_Lock_support+0x234> 2007658: 21 00 80 69 sethi %hi(0x201a400), %l0 200765c: 7f ff f1 8f call 2003c98 2007660: d0 07 bf f0 ld [ %fp + -16 ], %o0 2007664: c4 04 21 e0 ld [ %l0 + 0x1e0 ], %g2 2007668: 82 10 20 01 mov 1, %g1 200766c: 10 80 00 12 b 20076b4 <_POSIX_Mutex_Lock_support+0x274> 2007670: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2007674: c8 04 21 e0 ld [ %l0 + 0x1e0 ], %g4 2007678: c6 06 20 08 ld [ %i0 + 8 ], %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200767c: 05 00 80 69 sethi %hi(0x201a400), %g2 2007680: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007684: c6 21 20 20 st %g3, [ %g4 + 0x20 ] 2007688: 82 00 60 01 inc %g1 200768c: a0 06 20 14 add %i0, 0x14, %l0 2007690: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007694: e0 21 20 44 st %l0, [ %g4 + 0x44 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2007698: 82 10 20 01 mov 1, %g1 200769c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] 20076a0: 7f ff f1 7e call 2003c98 20076a4: d0 07 bf f0 ld [ %fp + -16 ], %o0 20076a8: 90 10 00 10 mov %l0, %o0 20076ac: 40 00 09 fe call 2009ea4 <_CORE_mutex_Seize_interrupt_blocking> 20076b0: 92 10 00 1a mov %i2, %o1 the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 20076b4: 03 00 80 69 sethi %hi(0x201a400), %g1 20076b8: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 ! 201a5e0 <_Thread_Executing> 20076bc: 40 00 20 33 call 200f788 <_POSIX_Mutex_From_core_mutex_status> 20076c0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20076c4: 81 c7 e0 08 ret 20076c8: 91 e8 00 08 restore %g0, %o0, %o0 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 20076cc: 40 00 03 4b call 20083f8 <== NOT EXECUTED 20076d0: 01 00 00 00 nop <== NOT EXECUTED } 20076d4: b0 10 00 08 mov %o0, %i0 20076d8: 81 c7 e0 08 ret 20076dc: 81 e8 00 00 restore 0200626c <_POSIX_RWLock_Translate_core_RWLock_return_code>: int _POSIX_RWLock_Translate_core_RWLock_return_code( CORE_RWLock_Status the_rwlock_status ) { if ( the_rwlock_status <= CORE_RWLOCK_STATUS_LAST ) 200626c: 80 a2 20 03 cmp %o0, 3 2006270: 08 80 00 05 bleu 2006284 <_POSIX_RWLock_Translate_core_RWLock_return_code+0x18> 2006274: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); 2006278: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200627c: 40 00 02 68 call 2006c1c <== NOT EXECUTED 2006280: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 2006284: 03 00 80 65 sethi %hi(0x2019400), %g1 2006288: 82 10 62 e4 or %g1, 0x2e4, %g1 ! 20196e4 <_POSIX_RWLock_Return_codes> 200628c: 81 c3 e0 08 retl 2006290: d0 00 40 02 ld [ %g1 + %g2 ], %o0 0200e850 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 200e850: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e854: 03 00 80 77 sethi %hi(0x201dc00), %g1 200e858: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 200e85c: 84 00 a0 01 inc %g2 200e860: c4 20 63 50 st %g2, [ %g1 + 0x350 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 200e864: 80 a6 60 00 cmp %i1, 0 200e868: 02 80 00 08 be 200e888 <_POSIX_Semaphore_Create_support+0x38> 200e86c: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 200e870: 7f ff ff eb call 200e81c <_Thread_Enable_dispatch> 200e874: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSYS ); 200e878: 40 00 08 a8 call 2010b18 <__errno> 200e87c: 01 00 00 00 nop 200e880: 10 80 00 19 b 200e8e4 <_POSIX_Semaphore_Create_support+0x94> 200e884: 82 10 20 58 mov 0x58, %g1 ! 58 } if ( name ) { 200e888: 02 80 00 0d be 200e8bc <_POSIX_Semaphore_Create_support+0x6c> 200e88c: 11 00 80 78 sethi %hi(0x201e000), %o0 if( strlen(name) > PATH_MAX ) { 200e890: 40 00 0f 1a call 20124f8 200e894: 90 10 00 18 mov %i0, %o0 200e898: 80 a2 20 ff cmp %o0, 0xff 200e89c: 28 80 00 08 bleu,a 200e8bc <_POSIX_Semaphore_Create_support+0x6c> 200e8a0: 11 00 80 78 sethi %hi(0x201e000), %o0 _Thread_Enable_dispatch(); 200e8a4: 7f ff ff de call 200e81c <_Thread_Enable_dispatch> <== NOT EXECUTED 200e8a8: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200e8ac: 40 00 08 9b call 2010b18 <__errno> <== NOT EXECUTED 200e8b0: 01 00 00 00 nop <== NOT EXECUTED 200e8b4: 10 80 00 0c b 200e8e4 <_POSIX_Semaphore_Create_support+0x94> <== NOT EXECUTED 200e8b8: 82 10 20 5b mov 0x5b, %g1 ! 5b <== NOT EXECUTED * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 200e8bc: 7f ff ea 4f call 20091f8 <_Objects_Allocate> 200e8c0: 90 12 22 d0 or %o0, 0x2d0, %o0 } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 200e8c4: b2 92 20 00 orcc %o0, 0, %i1 200e8c8: 12 80 00 0a bne 200e8f0 <_POSIX_Semaphore_Create_support+0xa0> 200e8cc: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); 200e8d0: 7f ff ff d3 call 200e81c <_Thread_Enable_dispatch> 200e8d4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSPC ); 200e8d8: 40 00 08 90 call 2010b18 <__errno> 200e8dc: 01 00 00 00 nop 200e8e0: 82 10 20 1c mov 0x1c, %g1 ! 1c 200e8e4: c2 22 00 00 st %g1, [ %o0 ] 200e8e8: 81 c7 e0 08 ret 200e8ec: 91 e8 3f ff restore %g0, -1, %o0 } #endif the_semaphore->process_shared = pshared; if ( name ) { 200e8f0: 02 80 00 07 be 200e90c <_POSIX_Semaphore_Create_support+0xbc> 200e8f4: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; 200e8f8: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 200e8fc: c2 26 60 18 st %g1, [ %i1 + 0x18 ] #endif the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 200e900: c2 26 60 14 st %g1, [ %i1 + 0x14 ] the_semaphore->open_count = 1; 200e904: 10 80 00 05 b 200e918 <_POSIX_Semaphore_Create_support+0xc8> 200e908: c2 26 60 1c st %g1, [ %i1 + 0x1c ] the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 200e90c: c0 26 60 14 clr [ %i1 + 0x14 ] the_semaphore->open_count = 0; 200e910: c0 26 60 1c clr [ %i1 + 0x1c ] the_semaphore->linked = FALSE; 200e914: c0 26 60 18 clr [ %i1 + 0x18 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200e918: 82 10 3f ff mov -1, %g1 * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 200e91c: c0 26 60 64 clr [ %i1 + 0x64 ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200e920: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200e924: 94 10 00 1a mov %i2, %o2 200e928: 90 06 60 20 add %i1, 0x20, %o0 200e92c: 7f ff e8 6d call 2008ae0 <_CORE_semaphore_Initialize> 200e930: 92 06 60 60 add %i1, 0x60, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e934: 03 00 80 78 sethi %hi(0x201e000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200e938: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e93c: 88 10 62 d0 or %g1, 0x2d0, %g4 200e940: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 200e944: 03 00 00 3f sethi %hi(0xfc00), %g1 200e948: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200e94c: 82 08 c0 01 and %g3, %g1, %g1 200e950: 80 a0 40 02 cmp %g1, %g2 200e954: 38 80 00 06 bgu,a 200e96c <_POSIX_Semaphore_Create_support+0x11c> 200e958: f0 26 60 0c st %i0, [ %i1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200e95c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200e960: 83 28 60 02 sll %g1, 2, %g1 200e964: f2 20 80 01 st %i1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200e968: f0 26 60 0c st %i0, [ %i1 + 0xc ] * Make the semaphore available for use. */ _Objects_Open(&_POSIX_Semaphore_Information, &the_semaphore->Object, name_p); *the_sem = the_semaphore; 200e96c: f2 26 c0 00 st %i1, [ %i3 ] name_p, 0 /* proxy id - Not used */ ); #endif _Thread_Enable_dispatch(); 200e970: 7f ff ff ab call 200e81c <_Thread_Enable_dispatch> 200e974: b0 10 20 00 clr %i0 return 0; } 200e978: 81 c7 e0 08 ret 200e97c: 81 e8 00 00 restore 0200ea70 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200ea70: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 200ea74: d2 06 00 00 ld [ %i0 ], %o1 200ea78: 94 07 bf f4 add %fp, -12, %o2 200ea7c: 11 00 80 78 sethi %hi(0x201e000), %o0 200ea80: 7f ff eb 22 call 2009708 <_Objects_Get> 200ea84: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 201e2d0 <_POSIX_Semaphore_Information> POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200ea88: c2 07 bf f4 ld [ %fp + -12 ], %g1 int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200ea8c: 94 10 00 19 mov %i1, %o2 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200ea90: 80 a0 60 01 cmp %g1, 1 200ea94: 02 80 00 09 be 200eab8 <_POSIX_Semaphore_Wait_support+0x48> 200ea98: 96 10 00 1a mov %i2, %o3 200ea9c: 80 a0 60 01 cmp %g1, 1 200eaa0: 2a 80 00 0c bcs,a 200ead0 <_POSIX_Semaphore_Wait_support+0x60> 200eaa4: d2 02 20 08 ld [ %o0 + 8 ], %o1 200eaa8: 80 a0 60 02 cmp %g1, 2 200eaac: 12 80 00 29 bne 200eb50 <_POSIX_Semaphore_Wait_support+0xe0> 200eab0: 01 00 00 00 nop 200eab4: 30 80 00 03 b,a 200eac0 <_POSIX_Semaphore_Wait_support+0x50> case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200eab8: 7f ff ef da call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 200eabc: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200eac0: 40 00 08 16 call 2010b18 <__errno> 200eac4: 01 00 00 00 nop 200eac8: 10 80 00 1f b 200eb44 <_POSIX_Semaphore_Wait_support+0xd4> 200eacc: 82 10 20 16 mov 0x16, %g1 ! 16 case OBJECTS_LOCAL: _CORE_semaphore_Seize( 200ead0: 40 00 01 78 call 200f0b0 <_CORE_semaphore_Seize> 200ead4: 90 02 20 20 add %o0, 0x20, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ead8: 03 00 80 77 sethi %hi(0x201dc00), %g1 200eadc: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 200eae0: 84 00 bf ff add %g2, -1, %g2 200eae4: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 200eae8: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 200eaec: 80 a0 60 00 cmp %g1, 0 200eaf0: 12 80 00 05 bne 200eb04 <_POSIX_Semaphore_Wait_support+0x94> 200eaf4: 03 00 80 78 sethi %hi(0x201e000), %g1 _Thread_Dispatch(); 200eaf8: 7f ff ef ca call 200aa20 <_Thread_Dispatch> 200eafc: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 200eb00: 03 00 80 78 sethi %hi(0x201e000), %g1 200eb04: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 ! 201e030 <_Thread_Executing> 200eb08: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 200eb0c: 80 a0 60 02 cmp %g1, 2 200eb10: 02 80 00 06 be 200eb28 <_POSIX_Semaphore_Wait_support+0xb8> 200eb14: 80 a0 60 03 cmp %g1, 3 200eb18: 02 80 00 08 be 200eb38 <_POSIX_Semaphore_Wait_support+0xc8> 200eb1c: 80 a0 60 01 cmp %g1, 1 200eb20: 12 80 00 0c bne 200eb50 <_POSIX_Semaphore_Wait_support+0xe0> 200eb24: 01 00 00 00 nop case CORE_SEMAPHORE_STATUS_SUCCESSFUL: break; case CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT: rtems_set_errno_and_return_minus_one( EAGAIN ); case CORE_SEMAPHORE_WAS_DELETED: rtems_set_errno_and_return_minus_one( EAGAIN ); 200eb28: 40 00 07 fc call 2010b18 <__errno> 200eb2c: 01 00 00 00 nop 200eb30: 10 80 00 05 b 200eb44 <_POSIX_Semaphore_Wait_support+0xd4> 200eb34: 82 10 20 0b mov 0xb, %g1 ! b case CORE_SEMAPHORE_TIMEOUT: rtems_set_errno_and_return_minus_one( ETIMEDOUT ); 200eb38: 40 00 07 f8 call 2010b18 <__errno> 200eb3c: 01 00 00 00 nop 200eb40: 82 10 20 74 mov 0x74, %g1 ! 74 200eb44: c2 22 00 00 st %g1, [ %o0 ] 200eb48: 81 c7 e0 08 ret 200eb4c: 91 e8 3f ff restore %g0, -1, %o0 */ break; } } return 0; } 200eb50: 81 c7 e0 08 ret 200eb54: 91 e8 20 00 restore %g0, 0, %o0 02005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code>: int _POSIX_Spinlock_Translate_core_spinlock_return_code( CORE_spinlock_Status the_spinlock_status ) { if ( the_spinlock_status <= CORE_SPINLOCK_STATUS_LAST ) 2005738: 80 a2 20 06 cmp %o0, 6 200573c: 08 80 00 05 bleu 2005750 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0x18> 2005740: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); 2005744: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005748: 40 00 00 6d call 20058fc <== NOT EXECUTED 200574c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED } 2005750: 03 00 80 4a sethi %hi(0x2012800), %g1 2005754: 82 10 62 64 or %g1, 0x264, %g1 ! 2012a64 <_POSIX_Spinlock_Return_codes> 2005758: 81 c3 e0 08 retl 200575c: d0 00 40 02 ld [ %g1 + %g2 ], %o0 0200c3ac <_POSIX_Threads_Create_extension>: boolean _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 200c3ac: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200c3b0: 11 00 80 62 sethi %hi(0x2018800), %o0 200c3b4: 92 10 20 e4 mov 0xe4, %o1 200c3b8: 90 12 23 3c or %o0, 0x33c, %o0 200c3bc: 7f ff ea 67 call 2006d58 <_Heap_Allocate> 200c3c0: b0 10 20 00 clr %i0 POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) 200c3c4: a2 92 20 00 orcc %o0, 0, %l1 200c3c8: 02 80 00 39 be 200c4ac <_POSIX_Threads_Create_extension+0x100> 200c3cc: 94 10 20 38 mov 0x38, %o2 return FALSE; created->API_Extensions[ THREAD_API_POSIX ] = api; 200c3d0: e2 26 61 74 st %l1, [ %i1 + 0x174 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 200c3d4: 21 00 80 5b sethi %hi(0x2016c00), %l0 200c3d8: a0 14 22 80 or %l0, 0x280, %l0 ! 2016e80 <_POSIX_Threads_Default_attributes> 200c3dc: 40 00 09 d6 call 200eb34 200c3e0: 92 10 00 10 mov %l0, %o1 api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 200c3e4: c2 04 20 34 ld [ %l0 + 0x34 ], %g1 api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 200c3e8: c4 04 20 14 ld [ %l0 + 0x14 ], %g2 created->API_Extensions[ THREAD_API_POSIX ] = api; /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 200c3ec: c2 24 60 38 st %g1, [ %l1 + 0x38 ] api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 200c3f0: c4 24 60 7c st %g2, [ %l1 + 0x7c ] api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 200c3f4: 92 04 20 18 add %l0, 0x18, %o1 200c3f8: 90 04 60 80 add %l1, 0x80, %o0 200c3fc: 40 00 09 ce call 200eb34 200c400: 94 10 20 18 mov 0x18, %o2 api->schedparam.sched_priority = 200c404: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 200c408: 82 10 20 ff mov 0xff, %g1 200c40c: 82 20 40 02 sub %g1, %g2, %g1 * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 200c410: c0 24 60 c8 clr [ %l1 + 0xc8 ] /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; api->detachstate = _POSIX_Threads_Default_attributes.detachstate; api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; api->schedparam = _POSIX_Threads_Default_attributes.schedparam; api->schedparam.sched_priority = 200c414: c2 24 60 80 st %g1, [ %l1 + 0x80 ] * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 200c418: c6 06 60 08 ld [ %i1 + 8 ], %g3 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200c41c: 82 04 60 dc add %l1, 0xdc, %g1 _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 200c420: c0 24 60 d4 clr [ %l1 + 0xd4 ] 200c424: c2 24 60 d8 st %g1, [ %l1 + 0xd8 ] api->cancelability_state = PTHREAD_CANCEL_ENABLE; 200c428: c0 24 60 cc clr [ %l1 + 0xcc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200c42c: 82 04 60 d8 add %l1, 0xd8, %g1 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 200c430: c0 24 60 d0 clr [ %l1 + 0xd0 ] 200c434: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 200c438: 83 30 e0 18 srl %g3, 0x18, %g1 200c43c: 82 08 60 07 and %g1, 7, %g1 200c440: 80 a0 60 03 cmp %g1, 3 200c444: 12 80 00 0b bne 200c470 <_POSIX_Threads_Create_extension+0xc4> 200c448: c0 24 60 dc clr [ %l1 + 0xdc ] 200c44c: 83 30 e0 1b srl %g3, 0x1b, %g1 200c450: 80 a0 60 01 cmp %g1, 1 200c454: 32 80 00 08 bne,a 200c474 <_POSIX_Threads_Create_extension+0xc8> 200c458: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 200c45c: 03 00 80 62 sethi %hi(0x2018800), %g1 200c460: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 200c464: c2 00 61 74 ld [ %g1 + 0x174 ], %g1 200c468: 10 80 00 03 b 200c474 <_POSIX_Threads_Create_extension+0xc8> 200c46c: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 } else { api->signals_blocked = 0xffffffff; 200c470: 82 10 3f ff mov -1, %g1 200c474: c2 24 60 c4 st %g1, [ %l1 + 0xc4 ] } _Thread_queue_Initialize( 200c478: 90 04 60 3c add %l1, 0x3c, %o0 200c47c: 92 10 20 00 clr %o1 200c480: 15 00 00 04 sethi %hi(0x1000), %o2 200c484: 7f ff f4 54 call 20095d4 <_Thread_queue_Initialize> 200c488: 96 10 20 00 clr %o3 THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 200c48c: c2 06 60 08 ld [ %i1 + 8 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200c490: f2 24 60 c0 st %i1, [ %l1 + 0xc0 ] void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200c494: c2 24 60 bc st %g1, [ %l1 + 0xbc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200c498: c0 24 60 a4 clr [ %l1 + 0xa4 ] the_watchdog->routine = routine; 200c49c: 03 00 80 31 sethi %hi(0x200c400), %g1 the_watchdog->id = id; the_watchdog->user_data = user_data; 200c4a0: b0 10 20 01 mov 1, %i0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200c4a4: 82 10 61 04 or %g1, 0x104, %g1 200c4a8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] created->Object.id, created ); return TRUE; } 200c4ac: 81 c7 e0 08 ret 200c4b0: 81 e8 00 00 restore 02006414 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 2006414: 9d e3 bf 58 save %sp, -168, %sp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 2006418: 03 00 80 73 sethi %hi(0x201cc00), %g1 200641c: e0 00 60 fc ld [ %g1 + 0xfc ], %l0 ! 201ccfc <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 2006420: 03 00 80 73 sethi %hi(0x201cc00), %g1 if ( !user_threads || maximum == 0 ) 2006424: 80 a4 20 00 cmp %l0, 0 2006428: 02 80 00 3b be 2006514 <_POSIX_Threads_Initialize_user_threads_body+0x100> 200642c: ec 00 61 cc ld [ %g1 + 0x1cc ], %l6 2006430: 80 a5 a0 00 cmp %l6, 0 2006434: 02 80 00 38 be 2006514 <_POSIX_Threads_Initialize_user_threads_body+0x100> 2006438: 03 00 80 6a sethi %hi(0x201a800), %g1 return; 200643c: aa 10 20 00 clr %l5 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 2006440: a8 10 60 40 or %g1, 0x40, %l4 user_threads = _POSIX_Threads_User_initialization_threads; maximum = _POSIX_Threads_Number_of_initialization_threads; if ( !user_threads || maximum == 0 ) return; 2006444: a4 10 20 00 clr %l2 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 2006448: 03 00 80 66 sethi %hi(0x2019800), %g1 * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); 200644c: a2 07 bf bc add %fp, -68, %l1 assert( !status ); 2006450: a6 10 63 a8 or %g1, 0x3a8, %l3 assert( !status ); status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); assert( !status ); status = pthread_create( 2006454: 10 80 00 2d b 2006508 <_POSIX_Threads_Initialize_user_threads_body+0xf4> 2006458: ae 07 bf f4 add %fp, -12, %l7 * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); 200645c: 40 00 1f 99 call 200e2c0 2006460: aa 05 60 01 inc %l5 assert( !status ); 2006464: 80 a2 20 00 cmp %o0, 0 2006468: 02 80 00 07 be 2006484 <_POSIX_Threads_Initialize_user_threads_body+0x70> 200646c: 92 10 20 02 mov 2, %o1 2006470: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 2006474: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 2006478: 7f ff f2 3f call 2002d74 <__assert> <== NOT EXECUTED 200647c: 92 10 20 47 mov 0x47, %o1 <== NOT EXECUTED status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 2006480: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2006484: 40 00 1f 9a call 200e2ec 2006488: 90 10 00 11 mov %l1, %o0 assert( !status ); 200648c: 80 a2 20 00 cmp %o0, 0 2006490: 02 80 00 07 be 20064ac <_POSIX_Threads_Initialize_user_threads_body+0x98> 2006494: 82 04 00 12 add %l0, %l2, %g1 2006498: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 200649c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064a0: 7f ff f2 35 call 2002d74 <__assert> <== NOT EXECUTED 20064a4: 92 10 20 4a mov 0x4a, %o1 <== NOT EXECUTED status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 20064a8: 82 04 00 12 add %l0, %l2, %g1 <== NOT EXECUTED 20064ac: d2 00 60 04 ld [ %g1 + 4 ], %o1 20064b0: 40 00 1f 9f call 200e32c 20064b4: 90 10 00 11 mov %l1, %o0 assert( !status ); 20064b8: 80 a2 20 00 cmp %o0, 0 20064bc: 22 80 00 07 be,a 20064d8 <_POSIX_Threads_Initialize_user_threads_body+0xc4> 20064c0: d4 04 80 10 ld [ %l2 + %l0 ], %o2 20064c4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064c8: 92 10 20 4d mov 0x4d, %o1 <== NOT EXECUTED 20064cc: 7f ff f2 2a call 2002d74 <__assert> <== NOT EXECUTED 20064d0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED status = pthread_create( 20064d4: d4 04 80 10 ld [ %l2 + %l0 ], %o2 <== NOT EXECUTED 20064d8: 92 10 00 11 mov %l1, %o1 20064dc: 96 10 20 00 clr %o3 20064e0: 90 10 00 17 mov %l7, %o0 20064e4: 7f ff fe fe call 20060dc 20064e8: a4 04 a0 08 add %l2, 8, %l2 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 20064ec: 80 a2 20 00 cmp %o0, 0 20064f0: 02 80 00 07 be 200650c <_POSIX_Threads_Initialize_user_threads_body+0xf8> 20064f4: 80 a5 40 16 cmp %l5, %l6 20064f8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED 20064fc: 92 10 20 55 mov 0x55, %o1 <== NOT EXECUTED 2006500: 7f ff f2 1d call 2002d74 <__assert> <== NOT EXECUTED 2006504: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 2006508: 80 a5 40 16 cmp %l5, %l6 200650c: 12 bf ff d4 bne 200645c <_POSIX_Threads_Initialize_user_threads_body+0x48> 2006510: 90 10 00 11 mov %l1, %o0 2006514: 81 c7 e0 08 ret 2006518: 81 e8 00 00 restore 0200c504 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 200c504: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200c508: f0 06 61 74 ld [ %i1 + 0x174 ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 200c50c: 40 00 03 da call 200d474 <_Timespec_To_ticks> 200c510: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 200c514: 80 a2 20 00 cmp %o0, 0 200c518: 22 80 00 02 be,a 200c520 <_POSIX_Threads_Sporadic_budget_TSR+0x1c> 200c51c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200c520: c2 06 20 98 ld [ %i0 + 0x98 ], %g1 the_thread->cpu_time_budget = ticks; new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200c524: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 200c528: 84 10 20 ff mov 0xff, %g2 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); if ( !ticks ) ticks = 1; the_thread->cpu_time_budget = ticks; 200c52c: d0 26 60 84 st %o0, [ %i1 + 0x84 ] 200c530: 92 20 80 01 sub %g2, %g1, %o1 new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200c534: 80 a0 e0 00 cmp %g3, 0 200c538: 02 80 00 06 be 200c550 <_POSIX_Threads_Sporadic_budget_TSR+0x4c> 200c53c: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 200c540: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200c544: 80 a0 40 09 cmp %g1, %o1 200c548: 08 80 00 05 bleu 200c55c <_POSIX_Threads_Sporadic_budget_TSR+0x58> 200c54c: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200c550: 90 10 00 19 mov %i1, %o0 200c554: 7f ff f0 65 call 20086e8 <_Thread_Change_priority> 200c558: 94 10 20 01 mov 1, %o2 ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 200c55c: 40 00 03 c6 call 200d474 <_Timespec_To_ticks> 200c560: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 200c564: 80 a2 20 00 cmp %o0, 0 200c568: 22 80 00 02 be,a 200c570 <_POSIX_Threads_Sporadic_budget_TSR+0x6c> 200c56c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200c570: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200c574: b2 06 20 9c add %i0, 0x9c, %i1 200c578: 31 00 80 62 sethi %hi(0x2018800), %i0 200c57c: 7f ff f6 a9 call 200a020 <_Watchdog_Insert> 200c580: 91 ee 23 f0 restore %i0, 0x3f0, %o0 200c584: 01 00 00 00 nop 0200c4b4 <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200c4b4: c2 02 21 74 ld [ %o0 + 0x174 ], %g1 the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200c4b8: c6 02 20 1c ld [ %o0 + 0x1c ], %g3 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 200c4bc: c4 00 60 84 ld [ %g1 + 0x84 ], %g2 * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 200c4c0: 82 10 3f ff mov -1, %g1 200c4c4: c2 22 20 84 st %g1, [ %o0 + 0x84 ] 200c4c8: 82 10 20 ff mov 0xff, %g1 200c4cc: 92 20 40 02 sub %g1, %g2, %o1 new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200c4d0: 80 a0 e0 00 cmp %g3, 0 200c4d4: 02 80 00 06 be 200c4ec <_POSIX_Threads_Sporadic_budget_callout+0x38> 200c4d8: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 200c4dc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 200c4e0: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED 200c4e4: 08 80 00 06 bleu 200c4fc <_POSIX_Threads_Sporadic_budget_callout+0x48> <== NOT EXECUTED 200c4e8: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200c4ec: 94 10 20 01 mov 1, %o2 ! 1 200c4f0: 82 13 c0 00 mov %o7, %g1 200c4f4: 7f ff f0 7d call 20086e8 <_Thread_Change_priority> 200c4f8: 9e 10 40 00 mov %g1, %o7 200c4fc: 81 c3 e0 08 retl <== NOT EXECUTED 200c500: 01 00 00 00 nop 02004ffc <_POSIX_Threads_cancel_run>: */ void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 2004ffc: 9d e3 bf 98 save %sp, -104, %sp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2005000: f2 06 21 74 ld [ %i0 + 0x174 ], %i1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 2005004: 82 10 20 01 mov 1, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2005008: a2 06 60 dc add %i1, 0xdc, %l1 200500c: c2 26 60 cc st %g1, [ %i1 + 0xcc ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2005010: 03 00 80 5c sethi %hi(0x2017000), %g1 2005014: 10 80 00 11 b 2005058 <_POSIX_Threads_cancel_run+0x5c> 2005018: a4 10 62 6c or %g1, 0x26c, %l2 ! 201726c <_Workspace_Area> while ( !_Chain_Is_empty( handler_stack ) ) { _ISR_Disable( level ); 200501c: 7f ff f3 8e call 2001e54 <== NOT EXECUTED 2005020: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 2005024: e0 04 60 04 ld [ %l1 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 2005028: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200502c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 2005030: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 2005034: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 2005038: 7f ff f3 8b call 2001e64 <== NOT EXECUTED 200503c: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 2005040: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 2005044: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005048: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 200504c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2005050: 40 00 0a 49 call 2007974 <_Heap_Free> <== NOT EXECUTED 2005054: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 2005058: c2 06 60 d8 ld [ %i1 + 0xd8 ], %g1 200505c: 80 a0 40 11 cmp %g1, %l1 2005060: 12 bf ff ef bne 200501c <_POSIX_Threads_cancel_run+0x20> 2005064: 03 00 80 5c sethi %hi(0x2017000), %g1 } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; _Thread_Close( 2005068: c6 06 20 08 ld [ %i0 + 8 ], %g3 200506c: 85 30 e0 16 srl %g3, 0x16, %g2 2005070: 82 10 61 80 or %g1, 0x180, %g1 2005074: 84 08 a0 1c and %g2, 0x1c, %g2 2005078: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200507c: 87 30 e0 1b srl %g3, 0x1b, %g3 2005080: 87 28 e0 02 sll %g3, 2, %g3 2005084: d0 00 40 03 ld [ %g1 + %g3 ], %o0 2005088: 92 10 00 18 mov %i0, %o1 _Workspace_Free( handler ); } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; 200508c: 82 10 3f ff mov -1, %g1 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 2005090: b2 10 00 18 mov %i0, %i1 2005094: c2 26 20 28 st %g1, [ %i0 + 0x28 ] _Thread_Close( 2005098: 40 00 10 e3 call 2009424 <_Thread_Close> 200509c: 31 00 80 5d sethi %hi(0x2017400), %i0 20050a0: 40 00 0c 68 call 2008240 <_Objects_Free> 20050a4: 91 ee 21 08 restore %i0, 0x108, %o0 20050a8: 01 00 00 00 nop 0200b170 <_POSIX_Timer_TSR>: * Description: This is the operation that is ran when a timer expires * ***************************************************************************/ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 200b170: 9d e3 bf 98 save %sp, -104, %sp boolean activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 200b174: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b178: c4 06 60 54 ld [ %i1 + 0x54 ], %g2 boolean activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 200b17c: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b180: 80 a0 a0 00 cmp %g2, 0 200b184: 12 80 00 06 bne 200b19c <_POSIX_Timer_TSR+0x2c> 200b188: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 200b18c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 200b190: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b194: 02 80 00 0f be 200b1d0 <_POSIX_Timer_TSR+0x60> <== NOT EXECUTED 200b198: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { #if 0 status = rtems_timer_fire_after( ptimer->timer_id, ptimer->ticks, _POSIX_Timer_TSR, ptimer ); #endif activated = _Watchdog_Insert_ticks_helper( 200b19c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 200b1a0: d4 06 60 08 ld [ %i1 + 8 ], %o2 200b1a4: 90 06 60 10 add %i1, 0x10, %o0 200b1a8: 17 00 80 2c sethi %hi(0x200b000), %o3 200b1ac: 98 10 00 19 mov %i1, %o4 200b1b0: 7f ff ff 68 call 200af50 <_Watchdog_Insert_ticks_helper> 200b1b4: 96 12 e1 70 or %o3, 0x170, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 200b1b8: 80 a2 20 00 cmp %o0, 0 200b1bc: 02 80 00 0a be 200b1e4 <_POSIX_Timer_TSR+0x74> 200b1c0: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 200b1c4: 40 00 09 20 call 200d644 <_TOD_Get> 200b1c8: 90 06 60 6c add %i1, 0x6c, %o0 200b1cc: 82 10 20 03 mov 3, %g1 /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 200b1d0: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 200b1d4: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 200b1d8: 40 00 20 26 call 2013270 200b1dc: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 200b1e0: c0 26 60 68 clr [ %i1 + 0x68 ] 200b1e4: 81 c7 e0 08 ret 200b1e8: 81 e8 00 00 restore 0200c28c <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 200c28c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED exit( 1 ); 200c290: 40 00 08 57 call 200e3ec <== NOT EXECUTED 200c294: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200c298: 01 00 00 00 nop 0200db30 <_POSIX_signals_Check_signal>: boolean _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, boolean is_global ) { 200db30: 9d e3 bf 88 save %sp, -120, %sp siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 200db34: 98 10 20 01 mov 1, %o4 200db38: 96 10 00 1a mov %i2, %o3 200db3c: a6 07 bf ec add %fp, -20, %l3 200db40: 90 10 00 18 mov %i0, %o0 200db44: 92 10 00 19 mov %i1, %o1 200db48: 40 00 00 2e call 200dc00 <_POSIX_signals_Clear_signals> 200db4c: 94 10 00 13 mov %l3, %o2 200db50: 80 a2 20 00 cmp %o0, 0 200db54: 02 80 00 29 be 200dbf8 <_POSIX_signals_Check_signal+0xc8> 200db58: 03 00 80 64 sethi %hi(0x2019000), %g1 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 200db5c: a4 10 61 84 or %g1, 0x184, %l2 ! 2019184 <_POSIX_signals_Vectors> 200db60: 83 2e 60 04 sll %i1, 4, %g1 200db64: 85 2e 60 02 sll %i1, 2, %g2 200db68: a2 20 40 02 sub %g1, %g2, %l1 200db6c: b4 04 40 12 add %l1, %l2, %i2 200db70: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200db74: 80 a0 60 00 cmp %g1, 0 200db78: 12 80 00 0a bne 200dba0 <_POSIX_signals_Check_signal+0x70> 200db7c: 80 a0 60 01 cmp %g1, 1 200db80: 11 00 80 5b sethi %hi(0x2016c00), %o0 <== NOT EXECUTED 200db84: 15 00 80 5c sethi %hi(0x2017000), %o2 <== NOT EXECUTED 200db88: 90 12 23 b0 or %o0, 0x3b0, %o0 <== NOT EXECUTED 200db8c: 94 12 a0 00 mov %o2, %o2 <== NOT EXECUTED 200db90: 7f ff d0 dd call 2001f04 <__assert> <== NOT EXECUTED 200db94: 92 10 20 33 mov 0x33, %o1 <== NOT EXECUTED /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 200db98: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 200db9c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200dba0: 02 80 00 16 be 200dbf8 <_POSIX_signals_Check_signal+0xc8> 200dba4: 01 00 00 00 nop /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 200dba8: e0 06 20 c4 ld [ %i0 + 0xc4 ], %l0 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200dbac: c2 06 a0 04 ld [ %i2 + 4 ], %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200dbb0: c4 04 80 11 ld [ %l2 + %l1 ], %g2 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200dbb4: 82 10 40 10 or %g1, %l0, %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200dbb8: 80 a0 a0 02 cmp %g2, 2 200dbbc: 12 80 00 09 bne 200dbe0 <_POSIX_signals_Check_signal+0xb0> 200dbc0: c2 26 20 c4 st %g1, [ %i0 + 0xc4 ] case SA_SIGINFO: /* * * assert( is_global ); */ (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 200dbc4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200dbc8: 90 10 00 19 mov %i1, %o0 200dbcc: 92 10 00 13 mov %l3, %o1 200dbd0: 9f c0 40 00 call %g1 200dbd4: 94 10 20 00 clr %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200dbd8: 10 80 00 06 b 200dbf0 <_POSIX_signals_Check_signal+0xc0> 200dbdc: e0 26 20 c4 st %l0, [ %i0 + 0xc4 ] &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 200dbe0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200dbe4: 9f c0 40 00 call %g1 200dbe8: 90 10 00 19 mov %i1, %o0 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200dbec: e0 26 20 c4 st %l0, [ %i0 + 0xc4 ] 200dbf0: 81 c7 e0 08 ret 200dbf4: 91 e8 20 01 restore %g0, 1, %o0 return TRUE; } 200dbf8: 81 c7 e0 08 ret 200dbfc: 91 e8 20 00 restore %g0, 0, %o0 0200dc00 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, boolean is_global, boolean check_blocked ) { 200dc00: 9d e3 bf 98 save %sp, -104, %sp sigset_t signals_blocked; ISR_Level level; boolean do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 200dc04: 82 10 20 01 mov 1, %g1 /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 200dc08: 80 a7 20 00 cmp %i4, 0 sigset_t signals_blocked; ISR_Level level; boolean do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 200dc0c: 84 06 7f ff add %i1, -1, %g2 /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 200dc10: b8 10 3f ff mov -1, %i4 200dc14: 02 80 00 04 be 200dc24 <_POSIX_signals_Clear_signals+0x24> 200dc18: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 200dc1c: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 200dc20: b8 38 00 01 xnor %g0, %g1, %i4 signals_blocked = SIGNAL_ALL_MASK; /* XXX this is not right for siginfo type signals yet */ /* XXX since they can't be cleared the same way */ _ISR_Disable( level ); 200dc24: 7f ff d0 4e call 2001d5c 200dc28: 01 00 00 00 nop 200dc2c: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 200dc30: 80 a6 e0 00 cmp %i3, 0 200dc34: 22 80 00 35 be,a 200dd08 <_POSIX_signals_Clear_signals+0x108> 200dc38: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 200dc3c: 03 00 80 64 sethi %hi(0x2019000), %g1 200dc40: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 ! 2019350 <_POSIX_signals_Pending> 200dc44: 82 0c 00 01 and %l0, %g1, %g1 200dc48: 80 88 40 1c btst %g1, %i4 200dc4c: 02 80 00 36 be 200dd24 <_POSIX_signals_Clear_signals+0x124> 200dc50: 83 2e 60 02 sll %i1, 2, %g1 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 200dc54: 85 2e 60 04 sll %i1, 4, %g2 200dc58: 84 20 80 01 sub %g2, %g1, %g2 200dc5c: 03 00 80 64 sethi %hi(0x2019000), %g1 200dc60: 82 10 61 84 or %g1, 0x184, %g1 ! 2019184 <_POSIX_signals_Vectors> 200dc64: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200dc68: 80 a0 60 02 cmp %g1, 2 200dc6c: 12 80 00 23 bne 200dcf8 <_POSIX_signals_Clear_signals+0xf8> 200dc70: 03 00 80 64 sethi %hi(0x2019000), %g1 psiginfo = (POSIX_signals_Siginfo_node *) 200dc74: 88 10 63 54 or %g1, 0x354, %g4 ! 2019354 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200dc78: f8 00 80 04 ld [ %g2 + %g4 ], %i4 200dc7c: 86 00 80 04 add %g2, %g4, %g3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200dc80: 9a 00 e0 04 add %g3, 4, %o5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 200dc84: 80 a7 00 0d cmp %i4, %o5 200dc88: 32 80 00 04 bne,a 200dc98 <_POSIX_signals_Clear_signals+0x98> 200dc8c: c2 07 00 00 ld [ %i4 ], %g1 200dc90: 10 80 00 04 b 200dca0 <_POSIX_signals_Clear_signals+0xa0> <== NOT EXECUTED 200dc94: b8 10 20 00 clr %i4 <== NOT EXECUTED Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 200dc98: c2 20 80 04 st %g1, [ %g2 + %g4 ] new_first->previous = _Chain_Head(the_chain); 200dc9c: c6 20 60 04 st %g3, [ %g1 + 4 ] _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 200dca0: c2 00 c0 00 ld [ %g3 ], %g1 200dca4: 80 a0 40 0d cmp %g1, %o5 200dca8: 12 80 00 05 bne 200dcbc <_POSIX_signals_Clear_signals+0xbc> 200dcac: 80 a7 20 00 cmp %i4, 0 _POSIX_signals_Clear_process_signals( mask ); 200dcb0: 40 00 01 b4 call 200e380 <_POSIX_signals_Clear_process_signals> 200dcb4: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 200dcb8: 80 a7 20 00 cmp %i4, 0 200dcbc: 02 80 00 1b be 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dcc0: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 200dcc4: 90 10 00 1a mov %i2, %o0 200dcc8: 92 07 20 08 add %i4, 8, %o1 200dccc: 40 00 03 9a call 200eb34 200dcd0: 94 10 20 0c mov 0xc, %o2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200dcd4: 03 00 80 64 sethi %hi(0x2019000), %g1 200dcd8: 82 10 63 08 or %g1, 0x308, %g1 ! 2019308 <_POSIX_signals_Inactive_siginfo+0x4> Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200dcdc: c2 27 00 00 st %g1, [ %i4 ] old_last_node = the_chain->last; 200dce0: 82 00 7f fc add %g1, -4, %g1 200dce4: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 200dce8: f8 20 60 08 st %i4, [ %g1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200dcec: c4 27 20 04 st %g2, [ %i4 + 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; 200dcf0: 10 80 00 0e b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dcf4: f8 20 80 00 st %i4, [ %g2 ] &psiginfo->Node ); } else do_callout = FALSE; } else _POSIX_signals_Clear_process_signals( mask ); 200dcf8: 40 00 01 a2 call 200e380 <_POSIX_signals_Clear_process_signals> 200dcfc: 90 10 00 10 mov %l0, %o0 do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 200dd00: 10 80 00 0a b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dd04: b0 10 20 01 mov 1, %i0 } else _POSIX_signals_Clear_process_signals( mask ); do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 200dd08: 82 0c 00 08 and %l0, %o0, %g1 200dd0c: 80 88 40 1c btst %g1, %i4 200dd10: 02 80 00 05 be 200dd24 <_POSIX_signals_Clear_signals+0x124> 200dd14: 82 2a 00 10 andn %o0, %l0, %g1 api->signals_pending &= ~mask; 200dd18: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 200dd1c: 10 80 00 03 b 200dd28 <_POSIX_signals_Clear_signals+0x128> 200dd20: b0 10 20 01 mov 1, %i0 200dd24: b0 10 20 00 clr %i0 do_callout = TRUE; } } _ISR_Enable( level ); 200dd28: 7f ff d0 11 call 2001d6c 200dd2c: 90 10 00 11 mov %l1, %o0 return do_callout; } 200dd30: 81 c7 e0 08 ret 200dd34: 81 e8 00 00 restore 020062bc <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 20062bc: 86 10 00 08 mov %o0, %g3 20062c0: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20062c4: 84 02 3f ff add %o0, -1, %g2 20062c8: 82 10 20 01 mov 1, %g1 20062cc: 83 28 40 02 sll %g1, %g2, %g1 20062d0: 80 88 40 03 btst %g1, %g3 20062d4: 12 80 00 12 bne 200631c <_POSIX_signals_Get_highest+0x60> 20062d8: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 20062dc: 90 02 20 01 inc %o0 20062e0: 80 a2 20 20 cmp %o0, 0x20 20062e4: 12 bf ff f9 bne 20062c8 <_POSIX_signals_Get_highest+0xc> 20062e8: 84 02 3f ff add %o0, -1, %g2 20062ec: 90 10 20 01 mov 1, %o0 } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 20062f0: 84 02 3f ff add %o0, -1, %g2 20062f4: 82 10 20 01 mov 1, %g1 20062f8: 83 28 40 02 sll %g1, %g2, %g1 20062fc: 80 88 40 03 btst %g1, %g3 2006300: 12 80 00 07 bne 200631c <_POSIX_signals_Get_highest+0x60> 2006304: 01 00 00 00 nop return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 2006308: 90 02 20 01 inc %o0 200630c: 80 a2 20 1b cmp %o0, 0x1b 2006310: 12 bf ff f9 bne 20062f4 <_POSIX_signals_Get_highest+0x38> 2006314: 84 02 3f ff add %o0, -1, %g2 2006318: 90 10 20 00 clr %o0 <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 200631c: 81 c3 e0 08 retl 2006320: 01 00 00 00 nop 0200c1bc <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 200c1bc: 9d e3 bf 98 save %sp, -104, %sp POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200c1c0: e0 06 21 74 ld [ %i0 + 0x174 ], %l0 * processed at all. No point in doing this loop otherwise. */ restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & 200c1c4: 23 00 80 64 sethi %hi(0x2019000), %l1 * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ restart: _ISR_Disable( level ); 200c1c8: 7f ff d6 e5 call 2001d5c 200c1cc: 01 00 00 00 nop 200c1d0: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 200c1d4: c2 04 63 50 ld [ %l1 + 0x350 ], %g1 200c1d8: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 200c1dc: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 200c1e0: 82 10 40 02 or %g1, %g2, %g1 200c1e4: 80 a8 40 03 andncc %g1, %g3, %g0 200c1e8: 12 80 00 04 bne 200c1f8 <_POSIX_signals_Post_switch_extension+0x3c> 200c1ec: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 200c1f0: 7f ff d6 df call 2001d6c 200c1f4: 81 e8 00 00 restore return; } _ISR_Enable( level ); 200c1f8: 7f ff d6 dd call 2001d6c 200c1fc: b0 10 20 1b mov 0x1b, %i0 for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 200c200: 92 10 00 18 mov %i0, %o1 200c204: 94 10 20 00 clr %o2 200c208: 40 00 06 4a call 200db30 <_POSIX_signals_Check_signal> 200c20c: 90 10 00 10 mov %l0, %o0 200c210: 80 a2 20 00 cmp %o0, 0 200c214: 12 bf ff ed bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c218: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200c21c: 90 10 00 10 mov %l0, %o0 200c220: 94 10 20 01 mov 1, %o2 200c224: 40 00 06 43 call 200db30 <_POSIX_signals_Check_signal> 200c228: b0 06 20 01 inc %i0 200c22c: 80 a2 20 00 cmp %o0, 0 200c230: 12 bf ff e6 bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c234: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); return; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 200c238: 12 bf ff f3 bne 200c204 <_POSIX_signals_Post_switch_extension+0x48> 200c23c: 92 10 00 18 mov %i0, %o1 200c240: b0 10 20 01 mov 1, %i0 /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 200c244: 92 10 00 18 mov %i0, %o1 200c248: 94 10 20 00 clr %o2 200c24c: 40 00 06 39 call 200db30 <_POSIX_signals_Check_signal> 200c250: 90 10 00 10 mov %l0, %o0 200c254: 80 a2 20 00 cmp %o0, 0 200c258: 12 bf ff dc bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c25c: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200c260: 90 10 00 10 mov %l0, %o0 200c264: 94 10 20 01 mov 1, %o2 200c268: 40 00 06 32 call 200db30 <_POSIX_signals_Check_signal> 200c26c: b0 06 20 01 inc %i0 200c270: 80 a2 20 00 cmp %o0, 0 200c274: 12 bf ff d5 bne 200c1c8 <_POSIX_signals_Post_switch_extension+0xc> 200c278: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 200c27c: 12 bf ff f3 bne 200c248 <_POSIX_signals_Post_switch_extension+0x8c> 200c280: 92 10 00 18 mov %i0, %o1 if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) goto restart; } } 200c284: 81 c7 e0 08 ret <== NOT EXECUTED 200c288: 81 e8 00 00 restore <== NOT EXECUTED 020212dc <_POSIX_signals_Unblock_thread>: boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 20212dc: 9d e3 bf 98 save %sp, -104, %sp /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20212e0: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 20212e4: 05 04 00 20 sethi %hi(0x10008000), %g2 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 20212e8: 82 06 7f ff add %i1, -1, %g1 20212ec: 9a 10 20 01 mov 1, %o5 boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 20212f0: 92 10 00 1a mov %i2, %o1 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 20212f4: 87 2b 40 01 sll %o5, %g1, %g3 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 20212f8: 82 09 00 02 and %g4, %g2, %g1 20212fc: 80 a0 40 02 cmp %g1, %g2 2021300: 12 80 00 19 bne 2021364 <_POSIX_signals_Unblock_thread+0x88> 2021304: c4 06 21 74 ld [ %i0 + 0x174 ], %g2 if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 2021308: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 202130c: 80 88 c0 01 btst %g3, %g1 2021310: 12 80 00 06 bne 2021328 <_POSIX_signals_Unblock_thread+0x4c> 2021314: 82 10 20 04 mov 4, %g1 2021318: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 202131c: 80 a8 c0 01 andncc %g3, %g1, %g0 2021320: 02 80 00 31 be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 2021324: 82 10 20 04 mov 4, %g1 the_thread->Wait.return_code = EINTR; 2021328: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 202132c: 80 a2 60 00 cmp %o1, 0 2021330: 12 80 00 06 bne 2021348 <_POSIX_signals_Unblock_thread+0x6c> 2021334: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 the_info->si_signo = signo; 2021338: f2 22 00 00 st %i1, [ %o0 ] the_info->si_code = SI_USER; 202133c: da 22 20 04 st %o5, [ %o0 + 4 ] the_info->si_value.sival_int = 0; 2021340: 10 80 00 04 b 2021350 <_POSIX_signals_Unblock_thread+0x74> 2021344: c0 22 20 08 clr [ %o0 + 8 ] } else { *the_info = *info; 2021348: 7f ff db e3 call 20182d4 202134c: 94 10 20 0c mov 0xc, %o2 } _Thread_queue_Extract_with_proxy( the_thread ); 2021350: 90 10 00 18 mov %i0, %o0 2021354: 7f ff b2 9f call 200ddd0 <_Thread_queue_Extract_with_proxy> 2021358: b0 10 20 01 mov 1, %i0 202135c: 81 c7 e0 08 ret 2021360: 81 e8 00 00 restore */ return FALSE; } if ( ~api->signals_blocked & mask ) { 2021364: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 2021368: 80 a8 c0 01 andncc %g3, %g1, %g0 202136c: 02 80 00 1e be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 2021370: 03 04 00 00 sethi %hi(0x10000000), %g1 the_thread->do_post_task_switch_extension = TRUE; if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 2021374: 80 89 00 01 btst %g4, %g1 2021378: 02 80 00 1b be 20213e4 <_POSIX_signals_Unblock_thread+0x108> 202137c: da 26 20 78 st %o5, [ %i0 + 0x78 ] the_thread->Wait.return_code = EINTR; 2021380: 82 10 20 04 mov 4, %g1 2021384: c2 26 20 34 st %g1, [ %i0 + 0x34 ] if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 2021388: 03 00 00 ef sethi %hi(0x3bc00), %g1 202138c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2021390: 80 89 00 01 btst %g4, %g1 2021394: 02 80 00 06 be 20213ac <_POSIX_signals_Unblock_thread+0xd0> 2021398: 80 89 20 08 btst 8, %g4 _Thread_queue_Extract_with_proxy( the_thread ); 202139c: 7f ff b2 8d call 200ddd0 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 20213a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 20213a4: 81 c7 e0 08 ret <== NOT EXECUTED 20213a8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED else if ( _States_Is_delaying(the_thread->current_state)){ 20213ac: 22 bf ff ec be,a 202135c <_POSIX_signals_Unblock_thread+0x80> 20213b0: b0 10 20 00 clr %i0 <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 20213b4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20213b8: 80 a0 60 02 cmp %g1, 2 20213bc: 32 80 00 05 bne,a 20213d0 <_POSIX_signals_Unblock_thread+0xf4> 20213c0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 20213c4: 7f ff b5 ba call 200eaac <_Watchdog_Remove> 20213c8: 90 06 20 48 add %i0, 0x48, %o0 20213cc: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20213d0: 90 10 00 18 mov %i0, %o0 20213d4: 7f ff af 4e call 200d10c <_Thread_Clear_state> 20213d8: 92 12 63 f8 or %o1, 0x3f8, %o1 20213dc: 81 c7 e0 08 ret 20213e0: 91 e8 20 00 restore %g0, 0, %o0 20213e4: b0 10 20 00 clr %i0 } } } return FALSE; } 20213e8: 81 c7 e0 08 ret 20213ec: 81 e8 00 00 restore 02007ba0 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 2007ba0: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 2007ba4: 7f ff e8 6e call 2001d5c 2007ba8: 01 00 00 00 nop 2007bac: a2 10 00 08 mov %o0, %l1 2007bb0: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bb4: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2007bb8: 80 a0 60 00 cmp %g1, 0 2007bbc: 02 80 00 0b be 2007be8 <_Protected_heap_Allocate+0x48> 2007bc0: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bc4: 03 00 80 63 sethi %hi(0x2018c00), %g1 2007bc8: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 2007bcc: 80 a0 60 01 cmp %g1, 1 2007bd0: 08 80 00 05 bleu 2007be4 <_Protected_heap_Allocate+0x44> 2007bd4: 90 10 20 00 clr %o0 2007bd8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007bdc: 7f ff fd 8a call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007be0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007be4: 03 00 80 62 sethi %hi(0x2018800), %g1 2007be8: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007bec: 03 00 80 62 sethi %hi(0x2018800), %g1 2007bf0: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007bf4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007bf8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2007bfc: 80 a0 60 00 cmp %g1, 0 2007c00: 22 80 00 33 be,a 2007ccc <_Protected_heap_Allocate+0x12c> 2007c04: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007c08: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007c0c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2007c10: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007c14: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 2007c18: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007c1c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007c20: 80 a0 e0 02 cmp %g3, 2 2007c24: 02 80 00 05 be 2007c38 <_Protected_heap_Allocate+0x98> 2007c28: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2007c2c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007c30: 32 80 00 06 bne,a 2007c48 <_Protected_heap_Allocate+0xa8> <== NOT EXECUTED 2007c34: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007c38: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007c3c: 82 00 60 01 inc %g1 2007c40: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007c44: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2007c48: 80 a0 60 03 cmp %g1, 3 2007c4c: 22 80 00 03 be,a 2007c58 <_Protected_heap_Allocate+0xb8> 2007c50: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007c54: 30 80 00 2c b,a 2007d04 <_Protected_heap_Allocate+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007c58: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007c5c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007c60: 12 80 00 03 bne 2007c6c <_Protected_heap_Allocate+0xcc> <== NOT EXECUTED 2007c64: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007c68: 30 80 00 27 b,a 2007d04 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007c6c: 08 80 00 10 bleu 2007cac <_Protected_heap_Allocate+0x10c> <== NOT EXECUTED 2007c70: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007c74: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007c78: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007c7c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007c80: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007c84: 7f ff e8 3a call 2001d6c <== NOT EXECUTED 2007c88: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007c8c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007c90: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007c94: 40 00 02 95 call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2007c98: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007c9c: 7f ff ff b4 call 2007b6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ca0: 01 00 00 00 nop <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007ca4: 10 80 00 32 b 2007d6c <_Protected_heap_Allocate+0x1cc> <== NOT EXECUTED 2007ca8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007cac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007cb0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007cb4: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2007cb8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007cbc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007cc0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007cc4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007cc8: 30 80 00 0f b,a 2007d04 <_Protected_heap_Allocate+0x164> <== 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 ) ) { 2007ccc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007cd0: 32 80 00 13 bne,a 2007d1c <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007cd4: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007cd8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2007cdc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007ce0: 22 80 00 07 be,a 2007cfc <_Protected_heap_Allocate+0x15c> <== NOT EXECUTED 2007ce4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007ce8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007cec: 32 80 00 0c bne,a 2007d1c <_Protected_heap_Allocate+0x17c> <== NOT EXECUTED 2007cf0: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 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; 2007cf4: 10 80 00 08 b 2007d14 <_Protected_heap_Allocate+0x174> <== NOT EXECUTED 2007cf8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 2007cfc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007d00: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007d04: 7f ff e8 1a call 2001d6c 2007d08: 90 10 00 11 mov %l1, %o0 2007d0c: 10 80 00 18 b 2007d6c <_Protected_heap_Allocate+0x1cc> 2007d10: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007d14: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007d18: 30 bf ff fb b,a 2007d04 <_Protected_heap_Allocate+0x164> <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 2007d1c: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2007d20: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007d24: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007d28: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2007d2c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007d30: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007d34: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007d38: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007d3c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2007d40: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007d44: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2007d48: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007d4c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007d50: 7f ff e8 07 call 2001d6c <== NOT EXECUTED 2007d54: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007d58: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2007d5c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007d60: 7f ff fb 0f call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007d64: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2007d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007d6c: 7f ff fb fb call 2006d58 <_Heap_Allocate> 2007d70: 92 10 00 19 mov %i1, %o1 2007d74: 05 00 80 62 sethi %hi(0x2018800), %g2 2007d78: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2007d7c: b0 10 00 08 mov %o0, %i0 2007d80: 82 00 60 01 inc %g1 2007d84: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] _RTEMS_Unlock_allocator(); 2007d88: 03 00 80 62 sethi %hi(0x2018800), %g1 2007d8c: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> 2007d90: 94 10 20 00 clr %o2 2007d94: d2 02 20 08 ld [ %o0 + 8 ], %o1 2007d98: 7f ff fb 23 call 2006a24 <_CORE_mutex_Surrender> 2007d9c: 90 02 20 10 add %o0, 0x10, %o0 2007da0: 7f ff ff 73 call 2007b6c <_Thread_Enable_dispatch> 2007da4: 01 00 00 00 nop return p; } 2007da8: 81 c7 e0 08 ret 2007dac: 81 e8 00 00 restore 02007de4 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 2007de4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007de8: 7f ff e7 dd call 2001d5c <== NOT EXECUTED 2007dec: 01 00 00 00 nop <== NOT EXECUTED 2007df0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 2007df4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007df8: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007dfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007e00: 02 80 00 0b be 2007e2c <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2007e04: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e08: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2007e0c: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 2007e10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007e14: 08 80 00 05 bleu 2007e28 <_Protected_heap_Extend+0x44> <== NOT EXECUTED 2007e18: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007e1c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007e20: 7f ff fc f9 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2007e24: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2007e28: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e2c: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007e30: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007e34: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007e38: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007e3c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2007e40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007e44: 22 80 00 33 be,a 2007f10 <_Protected_heap_Extend+0x12c> <== NOT EXECUTED 2007e48: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2007e4c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007e50: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2007e54: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 2007e58: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 2007e5c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2007e60: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007e64: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2007e68: 02 80 00 05 be 2007e7c <_Protected_heap_Extend+0x98> <== NOT EXECUTED 2007e6c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2007e70: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2007e74: 32 80 00 06 bne,a 2007e8c <_Protected_heap_Extend+0xa8> <== NOT EXECUTED 2007e78: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2007e7c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007e80: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007e84: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007e88: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 2007e8c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2007e90: 22 80 00 03 be,a 2007e9c <_Protected_heap_Extend+0xb8> <== NOT EXECUTED 2007e94: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2007e98: 30 80 00 2c b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2007e9c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2007ea0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2007ea4: 12 80 00 03 bne 2007eb0 <_Protected_heap_Extend+0xcc> <== NOT EXECUTED 2007ea8: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2007eac: 30 80 00 27 b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2007eb0: 08 80 00 10 bleu 2007ef0 <_Protected_heap_Extend+0x10c> <== NOT EXECUTED 2007eb4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007eb8: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007ebc: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007ec0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007ec4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007ec8: 7f ff e7 a9 call 2001d6c <== NOT EXECUTED 2007ecc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2007ed0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2007ed4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2007ed8: 40 00 02 04 call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2007edc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2007ee0: 7f ff ff b4 call 2007db0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ee4: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007ee8: 10 80 00 32 b 2007fb0 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007eec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007ef0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007ef4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2007ef8: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2007efc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2007f00: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2007f04: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007f08: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2007f0c: 30 80 00 0f b,a 2007f48 <_Protected_heap_Extend+0x164> <== 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 ) ) { 2007f10: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2007f14: 32 80 00 13 bne,a 2007f60 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007f18: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007f1c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2007f20: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007f24: 22 80 00 07 be,a 2007f40 <_Protected_heap_Extend+0x15c> <== NOT EXECUTED 2007f28: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2007f2c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007f30: 12 80 00 0c bne 2007f60 <_Protected_heap_Extend+0x17c> <== NOT EXECUTED 2007f34: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 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; 2007f38: 10 80 00 08 b 2007f58 <_Protected_heap_Extend+0x174> <== NOT EXECUTED 2007f3c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 2007f40: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007f44: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2007f48: 7f ff e7 89 call 2001d6c <== NOT EXECUTED 2007f4c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007f50: 10 80 00 18 b 2007fb0 <_Protected_heap_Extend+0x1cc> <== NOT EXECUTED 2007f54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2007f58: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2007f5c: 30 bf ff fb b,a 2007f48 <_Protected_heap_Extend+0x164> <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2007f60: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2007f64: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007f68: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2007f6c: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2007f70: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007f74: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007f78: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2007f7c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007f80: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2007f84: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2007f88: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2007f8c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2007f90: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2007f94: 7f ff e7 76 call 2001d6c <== NOT EXECUTED 2007f98: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2007f9c: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2007fa0: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007fa4: 7f ff fa 7e call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2007fa8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 2007fac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007fb0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2007fb4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2007fb8: 40 00 13 08 call 200cbd8 <_Heap_Extend> <== NOT EXECUTED 2007fbc: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 2007fc0: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2007fc4: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007fc8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2007fcc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007fd0: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2007fd4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2007fd8: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2007fdc: 94 10 20 00 clr %o2 <== NOT EXECUTED 2007fe0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2007fe4: 7f ff fa 90 call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 2007fe8: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2007fec: 7f ff ff 71 call 2007db0 <_Thread_Enable_dispatch> <== NOT EXECUTED 2007ff0: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 2007ff4: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2007ff8: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2007ffc: 81 c7 e0 08 ret <== NOT EXECUTED 2008000: 81 e8 00 00 restore <== NOT EXECUTED 02008038 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 2008038: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 200803c: 7f ff e7 48 call 2001d5c 2008040: 01 00 00 00 nop 2008044: a2 10 00 08 mov %o0, %l1 2008048: 03 00 80 62 sethi %hi(0x2018800), %g1 200804c: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008050: 80 a0 60 00 cmp %g1, 0 2008054: 02 80 00 0b be 2008080 <_Protected_heap_Free+0x48> 2008058: 03 00 80 62 sethi %hi(0x2018800), %g1 200805c: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2008060: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 2008064: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008068: 08 80 00 05 bleu 200807c <_Protected_heap_Free+0x44> <== NOT EXECUTED 200806c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008070: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008074: 7f ff fc 64 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008078: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200807c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008080: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008084: 03 00 80 62 sethi %hi(0x2018800), %g1 2008088: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200808c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008090: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2008094: 80 a0 60 00 cmp %g1, 0 2008098: 22 80 00 33 be,a 2008164 <_Protected_heap_Free+0x12c> 200809c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20080a0: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20080a4: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 20080a8: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20080ac: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 20080b0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20080b4: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20080b8: 80 a0 e0 02 cmp %g3, 2 20080bc: 02 80 00 05 be 20080d0 <_Protected_heap_Free+0x98> 20080c0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20080c4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20080c8: 32 80 00 06 bne,a 20080e0 <_Protected_heap_Free+0xa8> <== NOT EXECUTED 20080cc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20080d0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20080d4: 82 00 60 01 inc %g1 20080d8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20080dc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20080e0: 80 a0 60 03 cmp %g1, 3 20080e4: 22 80 00 03 be,a 20080f0 <_Protected_heap_Free+0xb8> 20080e8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20080ec: 30 80 00 2c b,a 200819c <_Protected_heap_Free+0x164> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20080f0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20080f4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20080f8: 12 80 00 03 bne 2008104 <_Protected_heap_Free+0xcc> <== NOT EXECUTED 20080fc: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2008100: 30 80 00 27 b,a 200819c <_Protected_heap_Free+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008104: 08 80 00 10 bleu 2008144 <_Protected_heap_Free+0x10c> <== NOT EXECUTED 2008108: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200810c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008110: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008114: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008118: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200811c: 7f ff e7 14 call 2001d6c <== NOT EXECUTED 2008120: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008124: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008128: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200812c: 40 00 01 6f call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2008130: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2008134: 7f ff ff b4 call 2008004 <_Thread_Enable_dispatch> <== NOT EXECUTED 2008138: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 200813c: 10 80 00 32 b 2008204 <_Protected_heap_Free+0x1cc> <== NOT EXECUTED 2008140: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008144: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008148: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200814c: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2008150: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2008154: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008158: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200815c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008160: 30 80 00 0f b,a 200819c <_Protected_heap_Free+0x164> <== 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 ) ) { 2008164: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008168: 32 80 00 13 bne,a 20081b4 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 200816c: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008170: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2008174: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008178: 22 80 00 07 be,a 2008194 <_Protected_heap_Free+0x15c> <== NOT EXECUTED 200817c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008180: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008184: 32 80 00 0c bne,a 20081b4 <_Protected_heap_Free+0x17c> <== NOT EXECUTED 2008188: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 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; 200818c: 10 80 00 08 b 20081ac <_Protected_heap_Free+0x174> <== NOT EXECUTED 2008190: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 2008194: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008198: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200819c: 7f ff e6 f4 call 2001d6c 20081a0: 90 10 00 11 mov %l1, %o0 20081a4: 10 80 00 18 b 2008204 <_Protected_heap_Free+0x1cc> 20081a8: 90 10 00 18 mov %i0, %o0 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20081ac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20081b0: 30 bf ff fb b,a 200819c <_Protected_heap_Free+0x164> <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 20081b4: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 20081b8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20081bc: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20081c0: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 20081c4: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 20081c8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20081cc: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20081d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20081d4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 20081d8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20081dc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20081e0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20081e4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20081e8: 7f ff e6 e1 call 2001d6c <== NOT EXECUTED 20081ec: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20081f0: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 20081f4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20081f8: 7f ff f9 e9 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20081fc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 2008200: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008204: 7f ff fa fc call 2006df4 <_Heap_Free> 2008208: 92 10 00 19 mov %i1, %o1 200820c: 05 00 80 62 sethi %hi(0x2018800), %g2 2008210: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008214: b0 10 00 08 mov %o0, %i0 2008218: 82 00 60 01 inc %g1 200821c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] _RTEMS_Unlock_allocator(); 2008220: 03 00 80 62 sethi %hi(0x2018800), %g1 2008224: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> 2008228: 94 10 20 00 clr %o2 200822c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2008230: 7f ff f9 fd call 2006a24 <_CORE_mutex_Surrender> 2008234: 90 02 20 10 add %o0, 0x10, %o0 2008238: 7f ff ff 73 call 2008004 <_Thread_Enable_dispatch> 200823c: 01 00 00 00 nop return status; } 2008240: 81 c7 e0 08 ret 2008244: 81 e8 00 00 restore 0200827c <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200827c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 2008280: 7f ff e6 b7 call 2001d5c <== NOT EXECUTED 2008284: 01 00 00 00 nop <== NOT EXECUTED 2008288: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200828c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008290: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008294: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008298: 02 80 00 0b be 20082c4 <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 200829c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082a0: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 20082a4: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 20082a8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20082ac: 08 80 00 05 bleu 20082c0 <_Protected_heap_Get_block_size+0x44> <== NOT EXECUTED 20082b0: 90 10 20 00 clr %o0 <== NOT EXECUTED 20082b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20082b8: 7f ff fb d3 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20082bc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20082c0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082c4: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20082c8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20082cc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20082d0: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20082d4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 20082d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20082dc: 22 80 00 33 be,a 20083a8 <_Protected_heap_Get_block_size+0x12c> <== NOT EXECUTED 20082e0: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20082e4: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20082e8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 20082ec: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 20082f0: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 20082f4: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20082f8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20082fc: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008300: 02 80 00 05 be 2008314 <_Protected_heap_Get_block_size+0x98> <== NOT EXECUTED 2008304: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008308: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200830c: 32 80 00 06 bne,a 2008324 <_Protected_heap_Get_block_size+0xa8> <== NOT EXECUTED 2008310: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008314: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008318: 82 00 60 01 inc %g1 <== NOT EXECUTED 200831c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008320: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 2008324: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2008328: 22 80 00 03 be,a 2008334 <_Protected_heap_Get_block_size+0xb8> <== NOT EXECUTED 200832c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008330: 30 80 00 2c b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2008334: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008338: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200833c: 12 80 00 03 bne 2008348 <_Protected_heap_Get_block_size+0xcc> <== NOT EXECUTED 2008340: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2008344: 30 80 00 27 b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008348: 08 80 00 10 bleu 2008388 <_Protected_heap_Get_block_size+0x10c> <== NOT EXECUTED 200834c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008350: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008354: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008358: 82 00 60 01 inc %g1 <== NOT EXECUTED 200835c: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008360: 7f ff e6 83 call 2001d6c <== NOT EXECUTED 2008364: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008368: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200836c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008370: 40 00 00 de call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2008374: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2008378: 7f ff ff b4 call 2008248 <_Thread_Enable_dispatch> <== NOT EXECUTED 200837c: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008380: 10 80 00 32 b 2008448 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 2008384: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008388: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200838c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008390: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2008394: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2008398: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200839c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20083a0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20083a4: 30 80 00 0f b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== 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 ) ) { 20083a8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20083ac: 32 80 00 13 bne,a 20083f8 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 20083b0: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20083b4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 20083b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20083bc: 22 80 00 07 be,a 20083d8 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 20083c0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20083c4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20083c8: 32 80 00 0c bne,a 20083f8 <_Protected_heap_Get_block_size+0x17c> <== NOT EXECUTED 20083cc: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 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; 20083d0: 10 80 00 08 b 20083f0 <_Protected_heap_Get_block_size+0x174> <== NOT EXECUTED 20083d4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 20083d8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20083dc: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20083e0: 7f ff e6 63 call 2001d6c <== NOT EXECUTED 20083e4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20083e8: 10 80 00 18 b 2008448 <_Protected_heap_Get_block_size+0x1cc> <== NOT EXECUTED 20083ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20083f0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20083f4: 30 bf ff fb b,a 20083e0 <_Protected_heap_Get_block_size+0x164> <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 20083f8: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 20083fc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008400: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2008404: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2008408: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 200840c: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008410: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2008414: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008418: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 200841c: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008420: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2008424: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008428: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200842c: 7f ff e6 50 call 2001d6c <== NOT EXECUTED 2008430: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008434: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2008438: 92 10 20 00 clr %o1 <== NOT EXECUTED 200843c: 7f ff f9 58 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008440: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008444: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008448: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200844c: 40 00 12 9d call 200cec0 <_Heap_Size_of_user_area> <== NOT EXECUTED 2008450: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008454: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008458: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200845c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 2008460: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008464: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 2008468: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200846c: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2008470: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008474: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008478: 7f ff f9 6b call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 200847c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2008480: 7f ff ff 72 call 2008248 <_Thread_Enable_dispatch> <== NOT EXECUTED 2008484: 01 00 00 00 nop <== NOT EXECUTED return status; } 2008488: 81 c7 e0 08 ret <== NOT EXECUTED 200848c: 81 e8 00 00 restore <== NOT EXECUTED 0200aa0c <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 200aa0c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 200aa10: 7f ff e0 5d call 2002b84 <== NOT EXECUTED 200aa14: 01 00 00 00 nop <== NOT EXECUTED 200aa18: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 200aa1c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa20: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aa24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aa28: 02 80 00 0b be 200aa54 <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200aa2c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa30: 03 00 80 e7 sethi %hi(0x2039c00), %g1 <== NOT EXECUTED 200aa34: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 2039cf0 <_System_state_Current> <== NOT EXECUTED 200aa38: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200aa3c: 08 80 00 05 bleu 200aa50 <_Protected_heap_Get_free_information+0x44> <== NOT EXECUTED 200aa40: 90 10 20 00 clr %o0 <== NOT EXECUTED 200aa44: 92 10 20 00 clr %o1 <== NOT EXECUTED 200aa48: 7f ff fb 80 call 2009848 <_Internal_error_Occurred> <== NOT EXECUTED 200aa4c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200aa50: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa54: e0 00 63 e8 ld [ %g1 + 0x3e8 ], %l0 ! 2039be8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200aa58: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200aa5c: c4 00 63 f0 ld [ %g1 + 0x3f0 ], %g2 ! 2039bf0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200aa60: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200aa64: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200aa68: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aa6c: 22 80 00 33 be,a 200ab38 <_Protected_heap_Get_free_information+0x12c> <== NOT EXECUTED 200aa70: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200aa74: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200aa78: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200aa7c: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 200aa80: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 200aa84: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200aa88: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200aa8c: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 200aa90: 02 80 00 05 be 200aaa4 <_Protected_heap_Get_free_information+0x98> <== NOT EXECUTED 200aa94: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 200aa98: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200aa9c: 32 80 00 06 bne,a 200aab4 <_Protected_heap_Get_free_information+0xa8> <== NOT EXECUTED 200aaa0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200aaa4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200aaa8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aaac: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200aab0: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200aab4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200aab8: 22 80 00 03 be,a 200aac4 <_Protected_heap_Get_free_information+0xb8> <== NOT EXECUTED 200aabc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200aac0: 30 80 00 2c b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200aac4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200aac8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200aacc: 12 80 00 03 bne 200aad8 <_Protected_heap_Get_free_information+0xcc> <== NOT EXECUTED 200aad0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200aad4: 30 80 00 27 b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200aad8: 08 80 00 10 bleu 200ab18 <_Protected_heap_Get_free_information+0x10c> <== NOT EXECUTED 200aadc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200aae0: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200aae4: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aae8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aaec: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200aaf0: 7f ff e0 29 call 2002b94 <== NOT EXECUTED 200aaf4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200aaf8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200aafc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200ab00: 40 00 00 db call 200ae6c <_Thread_Change_priority> <== NOT EXECUTED 200ab04: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200ab08: 7f ff ff b4 call 200a9d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ab0c: 01 00 00 00 nop <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200ab10: 10 80 00 32 b 200abd8 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200ab14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200ab18: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200ab1c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200ab20: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 200ab24: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200ab28: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200ab2c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200ab30: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200ab34: 30 80 00 0f b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== 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 ) ) { 200ab38: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200ab3c: 32 80 00 13 bne,a 200ab88 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200ab40: 21 00 80 e6 sethi %hi(0x2039800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200ab44: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2039850 <== NOT EXECUTED 200ab48: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ab4c: 22 80 00 07 be,a 200ab68 <_Protected_heap_Get_free_information+0x15c> <== NOT EXECUTED 200ab50: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200ab54: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200ab58: 32 80 00 0c bne,a 200ab88 <_Protected_heap_Get_free_information+0x17c> <== NOT EXECUTED 200ab5c: 21 00 80 e6 sethi %hi(0x2039800), %l0 <== NOT EXECUTED 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; 200ab60: 10 80 00 08 b 200ab80 <_Protected_heap_Get_free_information+0x174> <== NOT EXECUTED 200ab64: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 200ab68: 82 00 60 01 inc %g1 <== NOT EXECUTED 200ab6c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200ab70: 7f ff e0 09 call 2002b94 <== NOT EXECUTED 200ab74: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200ab78: 10 80 00 18 b 200abd8 <_Protected_heap_Get_free_information+0x1cc> <== NOT EXECUTED 200ab7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200ab80: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200ab84: 30 bf ff fb b,a 200ab70 <_Protected_heap_Get_free_information+0x164> <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 200ab88: c6 04 23 e8 ld [ %l0 + 0x3e8 ], %g3 <== NOT EXECUTED 200ab8c: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200ab90: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200ab94: c8 00 63 f0 ld [ %g1 + 0x3f0 ], %g4 <== NOT EXECUTED 200ab98: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200ab9c: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200aba0: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200aba4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200aba8: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED 200abac: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200abb0: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200abb4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200abb8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200abbc: 7f ff df f6 call 2002b94 <== NOT EXECUTED 200abc0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200abc4: d0 04 23 e8 ld [ %l0 + 0x3e8 ], %o0 <== NOT EXECUTED 200abc8: 92 10 20 00 clr %o1 <== NOT EXECUTED 200abcc: 7f ff f9 05 call 2008fe0 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200abd0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200abd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200abd8: 40 00 35 5a call 2018140 <_Heap_Get_free_information> <== NOT EXECUTED 200abdc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200abe0: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 200abe4: c2 00 a3 10 ld [ %g2 + 0x310 ], %g1 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200abe8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200abec: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200abf0: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 200abf4: d0 00 63 e8 ld [ %g1 + 0x3e8 ], %o0 ! 2039be8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200abf8: 94 10 20 00 clr %o2 <== NOT EXECUTED 200abfc: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200ac00: 7f ff f9 1a call 2009068 <_CORE_mutex_Surrender> <== NOT EXECUTED 200ac04: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200ac08: 7f ff ff 74 call 200a9d8 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ac0c: 81 e8 00 00 restore <== NOT EXECUTED 200ac10: 01 00 00 00 nop 020084c4 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 20084c4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 20084c8: 7f ff e6 25 call 2001d5c <== NOT EXECUTED 20084cc: 01 00 00 00 nop <== NOT EXECUTED 20084d0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 20084d4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20084d8: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20084dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20084e0: 02 80 00 0b be 200850c <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 20084e4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20084e8: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 20084ec: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 20084f0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20084f4: 08 80 00 05 bleu 2008508 <_Protected_heap_Resize_block+0x44> <== NOT EXECUTED 20084f8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20084fc: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008500: 7f ff fb 41 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008504: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008508: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200850c: e0 00 63 c8 ld [ %g1 + 0x3c8 ], %l0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008510: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008514: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008518: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200851c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008520: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008524: 22 80 00 33 be,a 20085f0 <_Protected_heap_Resize_block+0x12c> <== NOT EXECUTED 2008528: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200852c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008530: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2008534: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 2008538: c2 24 20 70 st %g1, [ %l0 + 0x70 ] <== NOT EXECUTED 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; 200853c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 2008540: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008544: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008548: 02 80 00 05 be 200855c <_Protected_heap_Resize_block+0x98> <== NOT EXECUTED 200854c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED 2008550: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008554: 32 80 00 06 bne,a 200856c <_Protected_heap_Resize_block+0xa8> <== NOT EXECUTED 2008558: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200855c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008560: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008564: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008568: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED 200856c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2008570: 22 80 00 03 be,a 200857c <_Protected_heap_Resize_block+0xb8> <== NOT EXECUTED 2008574: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2008578: 30 80 00 2c b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200857c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008580: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008584: 12 80 00 03 bne 2008590 <_Protected_heap_Resize_block+0xcc> <== NOT EXECUTED 2008588: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200858c: 30 80 00 27 b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2008590: 08 80 00 10 bleu 20085d0 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 2008594: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008598: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 200859c: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20085a0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20085a4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20085a8: 7f ff e5 f1 call 2001d6c <== NOT EXECUTED 20085ac: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20085b0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20085b4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20085b8: 40 00 00 4c call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 20085bc: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20085c0: 7f ff ff b4 call 2008490 <_Thread_Enable_dispatch> <== NOT EXECUTED 20085c4: 01 00 00 00 nop <== NOT EXECUTED status = _Heap_Resize_block( 20085c8: 10 80 00 32 b 2008690 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 20085cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20085d0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20085d4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20085d8: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 20085dc: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20085e0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20085e4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20085e8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20085ec: 30 80 00 0f b,a 2008628 <_Protected_heap_Resize_block+0x164> <== 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 ) ) { 20085f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20085f4: 32 80 00 13 bne,a 2008640 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 20085f8: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20085fc: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2018850 <== NOT EXECUTED 2008600: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008604: 22 80 00 07 be,a 2008620 <_Protected_heap_Resize_block+0x15c> <== NOT EXECUTED 2008608: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200860c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008610: 12 80 00 0c bne 2008640 <_Protected_heap_Resize_block+0x17c> <== NOT EXECUTED 2008614: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 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; 2008618: 10 80 00 08 b 2008638 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 200861c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 2008620: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008624: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008628: 7f ff e5 d1 call 2001d6c <== NOT EXECUTED 200862c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008630: 10 80 00 18 b 2008690 <_Protected_heap_Resize_block+0x1cc> <== NOT EXECUTED 2008634: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2008638: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200863c: 30 bf ff fb b,a 2008628 <_Protected_heap_Resize_block+0x164> <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 2008640: c6 04 23 c8 ld [ %l0 + 0x3c8 ], %g3 <== NOT EXECUTED 2008644: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008648: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200864c: c8 00 63 d0 ld [ %g1 + 0x3d0 ], %g4 <== NOT EXECUTED 2008650: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2008654: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008658: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200865c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008660: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED 2008664: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2008668: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200866c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008670: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008674: 7f ff e5 be call 2001d6c <== NOT EXECUTED 2008678: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200867c: d0 04 23 c8 ld [ %l0 + 0x3c8 ], %o0 <== NOT EXECUTED 2008680: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008684: 7f ff f8 c6 call 200699c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008688: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 200868c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008690: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008694: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008698: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 200869c: 40 00 11 80 call 200cc9c <_Heap_Resize_block> <== NOT EXECUTED 20086a0: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED 20086a4: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 20086a8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20086ac: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20086b0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20086b4: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 20086b8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20086bc: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 2018bc8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20086c0: 94 10 20 00 clr %o2 <== NOT EXECUTED 20086c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20086c8: 7f ff f8 d7 call 2006a24 <_CORE_mutex_Surrender> <== NOT EXECUTED 20086cc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20086d0: 7f ff ff 70 call 2008490 <_Thread_Enable_dispatch> <== NOT EXECUTED 20086d4: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 20086d8: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 20086dc: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 20086e0: 81 c7 e0 08 ret <== NOT EXECUTED 20086e4: 81 e8 00 00 restore <== NOT EXECUTED 0200c97c <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 200c97c: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 200c980: e0 06 61 80 ld [ %i1 + 0x180 ], %l0 deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c984: 25 00 80 62 sethi %hi(0x2018800), %l2 /* * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; 200c988: 10 80 00 18 b 200c9e8 <_RTEMS_tasks_Delete_extension+0x6c> 200c98c: c0 26 61 80 clr [ %i1 + 0x180 ] 200c990: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED while (tvp) { next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200c994: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200c998: 12 80 00 0c bne 200c9c8 <_RTEMS_tasks_Delete_extension+0x4c> <== NOT EXECUTED 200c99c: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) 200c9a0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c9a4: 22 80 00 06 be,a 200c9bc <_RTEMS_tasks_Delete_extension+0x40> <== NOT EXECUTED 200c9a8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 200c9ac: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200c9b0: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c9b4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 200c9b8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200c9bc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200c9c0: 10 80 00 07 b 200c9dc <_RTEMS_tasks_Delete_extension+0x60> <== NOT EXECUTED 200c9c4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED } else { if (tvp->dtor) 200c9c8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200c9cc: 02 80 00 05 be 200c9e0 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 200c9d0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 200c9d4: 9f c0 80 00 call %g2 <== NOT EXECUTED 200c9d8: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED } _Workspace_Free( tvp ); 200c9dc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200c9e0: 7f ff ff e0 call 200c960 <_Workspace_Free> <== NOT EXECUTED 200c9e4: a0 10 00 11 mov %l1, %l0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200c9e8: 80 a4 20 00 cmp %l0, 0 200c9ec: 12 bf ff e9 bne 200c990 <_RTEMS_tasks_Delete_extension+0x14> 200c9f0: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 200c9f4: 7f ff ff db call 200c960 <_Workspace_Free> 200c9f8: d0 06 61 70 ld [ %i1 + 0x170 ], %o0 deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 200c9fc: c0 26 61 70 clr [ %i1 + 0x170 ] } 200ca00: 81 c7 e0 08 ret 200ca04: 81 e8 00 00 restore 02006084 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2006084: 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; 2006088: 03 00 80 62 sethi %hi(0x2018800), %g1 200608c: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 2018bb4 <_Configuration_Table> 2006090: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 2006094: d0 00 60 28 ld [ %g1 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 2006098: 80 a2 20 00 cmp %o0, 0 200609c: 02 80 00 25 be 2006130 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 20060a0: e4 00 60 24 ld [ %g1 + 0x24 ], %l2 20060a4: 80 a4 a0 00 cmp %l2, 0 20060a8: 02 80 00 22 be 2006130 <_RTEMS_tasks_Initialize_user_tasks_body+0xac> 20060ac: a0 10 00 08 mov %o0, %l0 return; 20060b0: a2 10 20 00 clr %l1 for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 20060b4: 10 80 00 1c b 2006124 <_RTEMS_tasks_Initialize_user_tasks_body+0xa0> 20060b8: a6 07 bf f4 add %fp, -12, %l3 20060bc: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 20060c0: d8 04 20 0c ld [ %l0 + 0xc ], %o4 20060c4: d2 04 20 08 ld [ %l0 + 8 ], %o1 20060c8: d4 04 20 04 ld [ %l0 + 4 ], %o2 20060cc: d0 04 00 00 ld [ %l0 ], %o0 20060d0: 7f ff ff 35 call 2005da4 20060d4: a2 04 60 01 inc %l1 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 20060d8: 80 a2 20 00 cmp %o0, 0 20060dc: 22 80 00 07 be,a 20060f8 <_RTEMS_tasks_Initialize_user_tasks_body+0x74> 20060e0: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 20060e4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20060e8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 20060ec: 40 00 04 46 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20060f0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 20060f4: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 20060f8: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 20060fc: d0 07 bf f4 ld [ %fp + -12 ], %o0 2006100: 40 00 00 1b call 200616c 2006104: a0 04 20 1c add %l0, 0x1c, %l0 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 2006108: 80 a2 20 00 cmp %o0, 0 200610c: 02 80 00 07 be 2006128 <_RTEMS_tasks_Initialize_user_tasks_body+0xa4> 2006110: 80 a4 40 12 cmp %l1, %l2 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 2006114: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2006118: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200611c: 40 00 04 3a call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2006120: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 2006124: 80 a4 40 12 cmp %l1, %l2 2006128: 12 bf ff e5 bne 20060bc <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 200612c: 9a 10 00 13 mov %l3, %o5 2006130: 81 c7 e0 08 ret 2006134: 81 e8 00 00 restore 02006c98 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2006c98: 9d e3 bf 90 save %sp, -112, %sp 2006c9c: 11 00 80 75 sethi %hi(0x201d400), %o0 2006ca0: 92 10 00 18 mov %i0, %o1 2006ca4: 90 12 23 44 or %o0, 0x344, %o0 2006ca8: 40 00 09 5e call 2009220 <_Objects_Get> 2006cac: 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 ) { 2006cb0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006cb4: 80 a0 60 00 cmp %g1, 0 2006cb8: 12 80 00 20 bne 2006d38 <_Rate_monotonic_Timeout+0xa0> 2006cbc: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 2006cc0: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2006cc4: 03 00 00 10 sethi %hi(0x4000), %g1 2006cc8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2006ccc: 80 88 80 01 btst %g2, %g1 2006cd0: 22 80 00 0c be,a 2006d00 <_Rate_monotonic_Timeout+0x68> 2006cd4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2006cd8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006cdc: c2 06 20 08 ld [ %i0 + 8 ], %g1 2006ce0: 80 a0 80 01 cmp %g2, %g1 2006ce4: 32 80 00 07 bne,a 2006d00 <_Rate_monotonic_Timeout+0x68> 2006ce8: 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 ); 2006cec: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2006cf0: 40 00 0d 86 call 200a308 <_Thread_Clear_state> 2006cf4: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006cf8: 10 80 00 08 b 2006d18 <_Rate_monotonic_Timeout+0x80> 2006cfc: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 2006d00: 80 a0 60 01 cmp %g1, 1 2006d04: 12 80 00 08 bne 2006d24 <_Rate_monotonic_Timeout+0x8c> 2006d08: 82 10 20 04 mov 4, %g1 the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006d0c: d2 06 20 4c ld [ %i0 + 0x4c ], %o1 <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _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; 2006d10: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2006d14: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 2006d18: 7f ff ff d8 call 2006c78 <_Watchdog_Insert_ticks> 2006d1c: 90 06 20 10 add %i0, 0x10, %o0 2006d20: 30 80 00 02 b,a 2006d28 <_Rate_monotonic_Timeout+0x90> } else the_period->state = RATE_MONOTONIC_EXPIRED; 2006d24: 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; 2006d28: 05 00 80 76 sethi %hi(0x201d800), %g2 2006d2c: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006d30: 82 00 7f ff add %g1, -1, %g1 2006d34: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] 2006d38: 81 c7 e0 08 ret 2006d3c: 81 e8 00 00 restore 02008608 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 2008608: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200860c: 03 00 80 95 sethi %hi(0x2025400), %g1 2008610: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 2008614: 84 00 a0 01 inc %g2 2008618: c4 20 63 00 st %g2, [ %g1 + 0x300 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 200861c: 03 00 80 95 sethi %hi(0x2025400), %g1 2008620: d2 06 00 00 ld [ %i0 ], %o1 2008624: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 2008628: 80 a2 40 01 cmp %o1, %g1 200862c: 36 80 00 05 bge,a 2008640 <_TOD_Set+0x38> 2008630: 92 22 40 01 sub %o1, %g1, %o1 _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, 2008634: 92 20 40 09 sub %g1, %o1, %o1 2008638: 10 80 00 03 b 2008644 <_TOD_Set+0x3c> 200863c: 90 10 20 01 mov 1, %o0 _TOD_Seconds_since_epoch - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, 2008640: 90 10 20 00 clr %o0 2008644: 7f ff ff e9 call 20085e8 <_Watchdog_Adjust_seconds> 2008648: 01 00 00 00 nop time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 200864c: c4 06 00 00 ld [ %i0 ], %g2 2008650: 03 00 80 95 sethi %hi(0x2025400), %g1 2008654: c4 20 63 bc st %g2, [ %g1 + 0x3bc ] ! 20257bc <_TOD_Now> 2008658: c4 06 20 04 ld [ %i0 + 4 ], %g2 200865c: 82 10 63 bc or %g1, 0x3bc, %g1 2008660: c4 20 60 04 st %g2, [ %g1 + 4 ] _TOD_Is_set = TRUE; 2008664: 84 10 20 01 mov 1, %g2 2008668: 03 00 80 95 sethi %hi(0x2025400), %g1 200866c: c4 20 63 3c st %g2, [ %g1 + 0x33c ] ! 202573c <_TOD_Is_set> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008670: 05 00 80 95 sethi %hi(0x2025400), %g2 2008674: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 ! 2025700 <_Thread_Dispatch_disable_level> 2008678: 82 00 7f ff add %g1, -1, %g1 200867c: c2 20 a3 00 st %g1, [ %g2 + 0x300 ] 2008680: c2 00 a3 00 ld [ %g2 + 0x300 ], %g1 2008684: 80 a0 60 00 cmp %g1, 0 2008688: 12 80 00 04 bne 2008698 <_TOD_Set+0x90> 200868c: 01 00 00 00 nop _Thread_Dispatch(); 2008690: 40 00 07 f2 call 200a658 <_Thread_Dispatch> <== NOT EXECUTED 2008694: 81 e8 00 00 restore <== NOT EXECUTED 2008698: 81 c7 e0 08 ret 200869c: 81 e8 00 00 restore 02008a6c <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 2008a6c: 9d e3 bf 80 save %sp, -128, %sp * This routine allocates an internal thread. */ RTEMS_INLINE_ROUTINE Thread_Control *_Thread_Internal_allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_Thread_Internal_information ); 2008a70: 11 00 80 63 sethi %hi(0x2018c00), %o0 2008a74: 7f ff fa 11 call 20072b8 <_Objects_Allocate> 2008a78: 90 12 20 80 or %o0, 0x80, %o0 ! 2018c80 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 2008a7c: 03 00 80 62 sethi %hi(0x2018800), %g1 2008a80: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2018b10 <_CPU_Table+0xc> * 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(); 2008a84: 03 00 80 63 sethi %hi(0x2018c00), %g1 2008a88: d0 20 60 d8 st %o0, [ %g1 + 0xd8 ] ! 2018cd8 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 2008a8c: 80 a0 a0 00 cmp %g2, 0 2008a90: 03 00 80 23 sethi %hi(0x2008c00), %g1 2008a94: 02 80 00 03 be 2008aa0 <_Thread_Create_idle+0x34> 2008a98: b4 10 61 54 or %g1, 0x154, %i2 ! 2008d54 <_Thread_Idle_body> idle = _CPU_Table.idle_task; 2008a9c: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 2008aa0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008aa4: d6 00 63 18 ld [ %g1 + 0x318 ], %o3 ! 2018b18 <_CPU_Table+0x14> if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 2008aa8: 80 a2 ef ff cmp %o3, 0xfff 2008aac: 28 80 00 02 bleu,a 2008ab4 <_Thread_Create_idle+0x48> 2008ab0: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 2008ab4: 03 00 80 5f sethi %hi(0x2017c00), %g1 2008ab8: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1 ! 2017cf0 <_Thread_Idle_name> 2008abc: 92 10 00 08 mov %o0, %o1 2008ac0: c2 23 a0 6c st %g1, [ %sp + 0x6c ] 2008ac4: 82 10 20 01 mov 1, %g1 2008ac8: c0 23 a0 60 clr [ %sp + 0x60 ] 2008acc: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2008ad0: c0 23 a0 64 clr [ %sp + 0x64 ] 2008ad4: c0 23 a0 68 clr [ %sp + 0x68 ] 2008ad8: 11 00 80 63 sethi %hi(0x2018c00), %o0 2008adc: 94 10 20 00 clr %o2 2008ae0: 90 12 20 80 or %o0, 0x80, %o0 2008ae4: 98 10 20 00 clr %o4 2008ae8: 40 00 00 aa call 2008d90 <_Thread_Initialize> 2008aec: 9a 10 20 ff mov 0xff, %o5 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2008af0: 03 00 80 63 sethi %hi(0x2018c00), %g1 2008af4: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 ! 2018cd8 <_Thread_Idle> 2008af8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008afc: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] ! 2018bd0 <_Thread_Executing> 2008b00: 03 00 80 62 sethi %hi(0x2018800), %g1 _Thread_Executing = _Thread_Idle; _Thread_Start( 2008b04: b0 10 00 02 mov %g2, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 2008b08: c4 20 63 a8 st %g2, [ %g1 + 0x3a8 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 2008b0c: b2 10 20 00 clr %i1 2008b10: b6 10 20 00 clr %i3 2008b14: 40 00 04 0c call 2009b44 <_Thread_Start> 2008b18: 99 e8 20 00 restore %g0, 0, %o4 2008b1c: 01 00 00 00 nop 02008b20 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 2008b20: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2008b24: 92 96 20 00 orcc %i0, 0, %o1 2008b28: 12 80 00 0a bne 2008b50 <_Thread_Delay_ended+0x30> 2008b2c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008b30: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008b34: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008b38: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008b3c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== NOT EXECUTED 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; 2008b40: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008b44: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 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; 2008b48: 10 80 00 19 b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008b4c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2008b50: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2008b54: 80 a0 a0 04 cmp %g2, 4 2008b58: 18 80 00 06 bgu 2008b70 <_Thread_Delay_ended+0x50> 2008b5c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2008b60: 83 32 60 1b srl %o1, 0x1b, %g1 2008b64: 80 a0 60 01 cmp %g1, 1 2008b68: 02 80 00 05 be 2008b7c <_Thread_Delay_ended+0x5c> 2008b6c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008b70: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008b74: 10 80 00 0e b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008b78: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008b7c: 83 28 a0 02 sll %g2, 2, %g1 2008b80: 05 00 80 62 sethi %hi(0x2018800), %g2 2008b84: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2008b88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2008b8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2008b90: 80 a2 20 00 cmp %o0, 0 2008b94: 12 80 00 04 bne 2008ba4 <_Thread_Delay_ended+0x84> 2008b98: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2008b9c: 10 80 00 04 b 2008bac <_Thread_Delay_ended+0x8c> <== NOT EXECUTED 2008ba0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008ba4: 7f ff fb 09 call 20077c8 <_Objects_Get> 2008ba8: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008bac: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008bb0: 80 a0 60 00 cmp %g1, 0 2008bb4: 12 80 00 08 bne 2008bd4 <_Thread_Delay_ended+0xb4> 2008bb8: 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 ); 2008bbc: 7f ff ff 3d call 20088b0 <_Thread_Clear_state> 2008bc0: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2008bc4: 05 00 80 62 sethi %hi(0x2018800), %g2 2008bc8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2008bcc: 82 00 7f ff add %g1, -1, %g1 2008bd0: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2008bd4: 81 c7 e0 08 ret 2008bd8: 81 e8 00 00 restore 0200e10c <_Thread_Evaluate_mode>: boolean _Thread_Evaluate_mode( void ) { Thread_Control *executing; executing = _Thread_Executing; 200e10c: 03 00 80 62 sethi %hi(0x2018800), %g1 200e110: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> if ( !_States_Is_ready( executing->current_state ) || 200e114: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200e118: 80 a0 60 00 cmp %g1, 0 200e11c: 32 80 00 0b bne,a 200e148 <_Thread_Evaluate_mode+0x3c> 200e120: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 200e124: 03 00 80 62 sethi %hi(0x2018800), %g1 200e128: c2 00 63 a8 ld [ %g1 + 0x3a8 ], %g1 ! 2018ba8 <_Thread_Heir> 200e12c: 80 a0 80 01 cmp %g2, %g1 200e130: 02 80 00 0b be 200e15c <_Thread_Evaluate_mode+0x50> 200e134: 01 00 00 00 nop 200e138: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 200e13c: 80 a0 60 00 cmp %g1, 0 200e140: 02 80 00 07 be 200e15c <_Thread_Evaluate_mode+0x50> 200e144: 84 10 20 01 mov 1, %g2 ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 200e148: 03 00 80 62 sethi %hi(0x2018800), %g1 200e14c: 90 10 20 01 mov 1, %o0 200e150: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 200e154: 81 c3 e0 08 retl 200e158: 01 00 00 00 nop return TRUE; } return FALSE; } 200e15c: 81 c3 e0 08 retl 200e160: 90 10 20 00 clr %o0 ! 0 0200e164 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200e164: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 200e168: 03 00 80 62 sethi %hi(0x2018800), %g1 200e16c: f4 00 63 d0 ld [ %g1 + 0x3d0 ], %i2 ! 2018bd0 <_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(); 200e170: 3f 00 80 38 sethi %hi(0x200e000), %i7 200e174: be 17 e1 64 or %i7, 0x164, %i7 ! 200e164 <_Thread_Handler> * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; _ISR_Set_level(level); 200e178: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 200e17c: 7f ff ce fc call 2001d6c 200e180: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; doneConstructors = 1; 200e184: 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; 200e188: 05 00 80 61 sethi %hi(0x2018400), %g2 200e18c: f0 08 a3 54 ldub [ %g2 + 0x354 ], %i0 ! 2018754 doneConstructors = 1; 200e190: c2 28 a3 54 stb %g1, [ %g2 + 0x354 ] #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 ) ) { 200e194: c2 06 a1 68 ld [ %i2 + 0x168 ], %g1 200e198: 80 a0 60 00 cmp %g1, 0 200e19c: 02 80 00 0b be 200e1c8 <_Thread_Handler+0x64> 200e1a0: 33 00 80 62 sethi %hi(0x2018800), %i1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE boolean _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 200e1a4: d0 06 63 a0 ld [ %i1 + 0x3a0 ], %o0 ! 2018ba0 <_Thread_Allocated_fp> 200e1a8: 80 a6 80 08 cmp %i2, %o0 200e1ac: 02 80 00 07 be 200e1c8 <_Thread_Handler+0x64> 200e1b0: 80 a2 20 00 cmp %o0, 0 if ( _Thread_Allocated_fp != NULL ) 200e1b4: 22 80 00 05 be,a 200e1c8 <_Thread_Handler+0x64> 200e1b8: f4 26 63 a0 st %i2, [ %i1 + 0x3a0 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200e1bc: 7f ff f0 75 call 200a390 <_CPU_Context_save_fp> 200e1c0: 90 02 21 68 add %o0, 0x168, %o0 _Thread_Allocated_fp = executing; 200e1c4: f4 26 63 a0 st %i2, [ %i1 + 0x3a0 ] * 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 ); 200e1c8: 7f ff ef 17 call 2009e24 <_User_extensions_Thread_begin> 200e1cc: 90 10 00 1a mov %i2, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e1d0: 03 00 80 62 sethi %hi(0x2018800), %g1 200e1d4: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 200e1d8: 84 00 bf ff add %g2, -1, %g2 200e1dc: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 200e1e0: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 200e1e4: 80 a0 60 00 cmp %g1, 0 200e1e8: 12 80 00 05 bne 200e1fc <_Thread_Handler+0x98> 200e1ec: 83 2e 20 18 sll %i0, 0x18, %g1 _Thread_Dispatch(); 200e1f0: 7f ff ea 7b call 2008bdc <_Thread_Dispatch> 200e1f4: 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) */ 200e1f8: 83 2e 20 18 sll %i0, 0x18, %g1 200e1fc: 80 a0 60 00 cmp %g1, 0 200e200: 32 80 00 05 bne,a 200e214 <_Thread_Handler+0xb0> 200e204: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 200e208: 40 00 25 54 call 2017758 <_init> 200e20c: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200e210: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 200e214: 80 a0 60 01 cmp %g1, 1 200e218: 22 80 00 0d be,a 200e24c <_Thread_Handler+0xe8> 200e21c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200e220: 2a 80 00 09 bcs,a 200e244 <_Thread_Handler+0xe0> 200e224: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200e228: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200e22c: 02 80 00 0d be 200e260 <_Thread_Handler+0xfc> <== NOT EXECUTED 200e230: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200e234: 12 80 00 14 bne 200e284 <_Thread_Handler+0x120> <== NOT EXECUTED 200e238: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200e23c: 10 80 00 0c b 200e26c <_Thread_Handler+0x108> <== NOT EXECUTED 200e240: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED __main (); #endif switch ( executing->Start.prototype ) { case THREAD_START_NUMERIC: executing->Wait.return_argument = 200e244: 10 80 00 03 b 200e250 <_Thread_Handler+0xec> 200e248: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 200e24c: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 200e250: 9f c0 40 00 call %g1 200e254: 01 00 00 00 nop executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200e258: 10 80 00 0a b 200e280 <_Thread_Handler+0x11c> 200e25c: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 200e260: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200e264: 10 80 00 04 b 200e274 <_Thread_Handler+0x110> <== NOT EXECUTED 200e268: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 200e26c: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 200e270: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 200e274: 9f c0 40 00 call %g1 <== NOT EXECUTED 200e278: 01 00 00 00 nop <== NOT EXECUTED 200e27c: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] <== NOT EXECUTED * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 200e280: 90 10 00 1a mov %i2, %o0 200e284: 7f ff ef 0b call 2009eb0 <_User_extensions_Thread_exitted> 200e288: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200e28c: b2 10 20 01 mov 1, %i1 200e290: 7f ff e3 dd call 2007204 <_Internal_error_Occurred> 200e294: 95 e8 20 06 restore %g0, 6, %o2 200e298: 01 00 00 00 nop 02008f90 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 2008f90: 9d e3 bf 90 save %sp, -112, %sp /* * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) 2008f94: 03 00 80 62 sethi %hi(0x2018800), %g1 2008f98: 82 10 63 04 or %g1, 0x304, %g1 ! 2018b04 <_CPU_Table> 2008f9c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 2008fa0: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 2008fa4: 80 a0 00 02 cmp %g0, %g2 2008fa8: 84 60 3f ff subx %g0, -1, %g2 2008fac: 80 a0 00 01 cmp %g0, %g1 2008fb0: 82 60 3f ff subx %g0, -1, %g1 2008fb4: 80 a0 80 01 cmp %g2, %g1 2008fb8: 02 80 00 07 be 2008fd4 <_Thread_Handler_initialization+0x44> 2008fbc: 03 00 80 62 sethi %hi(0x2018800), %g1 == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 2008fc0: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008fc4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2008fc8: 7f ff f8 8f call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 2008fcc: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 2008fd0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008fd4: c0 20 63 e0 clr [ %g1 + 0x3e0 ] ! 2018be0 <_Context_Switch_necessary> _Thread_Executing = NULL; 2008fd8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fdc: c0 20 63 d0 clr [ %g1 + 0x3d0 ] ! 2018bd0 <_Thread_Executing> _Thread_Heir = NULL; 2008fe0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fe4: c0 20 63 a8 clr [ %g1 + 0x3a8 ] ! 2018ba8 <_Thread_Heir> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 2008fe8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008fec: c0 20 63 a0 clr [ %g1 + 0x3a0 ] ! 2018ba0 <_Thread_Allocated_fp> #endif _Thread_Do_post_task_switch_extension = 0; 2008ff0: 03 00 80 62 sethi %hi(0x2018800), %g1 2008ff4: c0 20 63 c0 clr [ %g1 + 0x3c0 ] ! 2018bc0 <_Thread_Do_post_task_switch_extension> _Thread_Maximum_extensions = maximum_extensions; 2008ff8: 03 00 80 62 sethi %hi(0x2018800), %g1 2008ffc: f2 20 63 bc st %i1, [ %g1 + 0x3bc ] ! 2018bbc <_Thread_Maximum_extensions> _Thread_Ticks_per_timeslice = ticks_per_timeslice; 2009000: 03 00 80 62 sethi %hi(0x2018800), %g1 _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 2009004: 90 10 2c 00 mov 0xc00, %o0 2009008: 40 00 04 b1 call 200a2cc <_Workspace_Allocate_or_fatal_error> 200900c: f0 20 62 48 st %i0, [ %g1 + 0x248 ] 2009010: 03 00 80 62 sethi %hi(0x2018800), %g1 2009014: 84 10 00 08 mov %o0, %g2 2009018: d0 20 62 44 st %o0, [ %g1 + 0x244 ] (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 200901c: 86 02 2c 00 add %o0, 0xc00, %g3 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009020: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 2009024: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 2009028: 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); 200902c: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009030: 84 00 a0 0c add %g2, 0xc, %g2 2009034: 80 a0 80 03 cmp %g2, %g3 2009038: 12 bf ff fb bne 2009024 <_Thread_Handler_initialization+0x94> 200903c: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 2009040: 03 00 80 62 sethi %hi(0x2018800), %g1 2009044: c2 00 63 fc ld [ %g1 + 0x3fc ], %g1 ! 2018bfc <_System_state_Is_multiprocessing> 2009048: 96 10 20 02 mov 2, %o3 200904c: 80 a0 00 01 cmp %g0, %g1 2009050: 82 10 20 08 mov 8, %g1 2009054: 96 42 ff ff addx %o3, -1, %o3 2009058: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200905c: 11 00 80 63 sethi %hi(0x2018c00), %o0 2009060: 92 10 20 01 mov 1, %o1 2009064: 90 12 20 80 or %o0, 0x80, %o0 2009068: 94 10 20 01 mov 1, %o2 200906c: 98 10 21 88 mov 0x188, %o4 2009070: 7f ff f9 fb call 200785c <_Objects_Initialize_information> 2009074: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 2009078: 81 c7 e0 08 ret 200907c: 81 e8 00 00 restore 02008d90 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2008d90: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 2008d94: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2008d98: 80 a6 a0 00 cmp %i2, 0 2008d9c: 12 80 00 10 bne 2008ddc <_Thread_Initialize+0x4c> 2008da0: e0 07 a0 60 ld [ %fp + 0x60 ], %l0 if ( !_Stack_Is_enough( stack_size ) ) 2008da4: 80 a6 ef ff cmp %i3, 0xfff 2008da8: 08 80 00 03 bleu 2008db4 <_Thread_Initialize+0x24> 2008dac: 13 00 00 04 sethi %hi(0x1000), %o1 2008db0: 92 10 00 1b mov %i3, %o1 actual_stack_size = STACK_MINIMUM_SIZE; else actual_stack_size = stack_size; actual_stack_size = _Thread_Stack_Allocate( the_thread, actual_stack_size ); 2008db4: 40 00 03 26 call 2009a4c <_Thread_Stack_Allocate> 2008db8: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 2008dbc: 80 a2 20 00 cmp %o0, 0 2008dc0: 02 80 00 2c be 2008e70 <_Thread_Initialize+0xe0> 2008dc4: 80 a2 00 1b cmp %o0, %i3 2008dc8: 0a 80 00 2a bcs 2008e70 <_Thread_Initialize+0xe0> 2008dcc: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 2008dd0: f4 06 60 dc ld [ %i1 + 0xdc ], %i2 the_thread->Start.core_allocated_stack = TRUE; 2008dd4: 10 80 00 04 b 2008de4 <_Thread_Initialize+0x54> 2008dd8: c2 26 60 cc st %g1, [ %i1 + 0xcc ] } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2008ddc: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 2008de0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 2008de4: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 2008de8: d0 26 60 d0 st %o0, [ %i1 + 0xd0 ] /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 2008dec: 80 a7 20 00 cmp %i4, 0 2008df0: 02 80 00 07 be 2008e0c <_Thread_Initialize+0x7c> 2008df4: b8 10 20 00 clr %i4 fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 2008df8: 7f ff ff d8 call 2008d58 <_Workspace_Allocate> 2008dfc: 90 10 20 88 mov 0x88, %o0 if ( !fp_area ) { 2008e00: b8 92 20 00 orcc %o0, 0, %i4 2008e04: 02 80 00 19 be 2008e68 <_Thread_Initialize+0xd8> 2008e08: 01 00 00 00 nop /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008e0c: 03 00 80 62 sethi %hi(0x2018800), %g1 2008e10: d0 00 63 bc ld [ %g1 + 0x3bc ], %o0 ! 2018bbc <_Thread_Maximum_extensions> fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 2008e14: f8 26 61 68 st %i4, [ %i1 + 0x168 ] the_thread->Start.fp_context = fp_area; 2008e18: f8 26 60 d8 st %i4, [ %i1 + 0xd8 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2008e1c: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 2008e20: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 2008e24: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 2008e28: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 2008e2c: c0 26 61 6c clr [ %i1 + 0x16c ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2008e30: 80 a2 20 00 cmp %o0, 0 2008e34: 02 80 00 11 be 2008e78 <_Thread_Initialize+0xe8> 2008e38: b6 10 20 00 clr %i3 extensions_area = _Workspace_Allocate( 2008e3c: 90 02 20 01 inc %o0 2008e40: 7f ff ff c6 call 2008d58 <_Workspace_Allocate> 2008e44: 91 2a 20 02 sll %o0, 2, %o0 (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 2008e48: b6 92 20 00 orcc %o0, 0, %i3 2008e4c: 12 80 00 0c bne 2008e7c <_Thread_Initialize+0xec> 2008e50: 80 a6 e0 00 cmp %i3, 0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008e54: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008e58: 02 80 00 04 be 2008e68 <_Thread_Initialize+0xd8> <== NOT EXECUTED 2008e5c: 01 00 00 00 nop <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2008e60: 7f ff ff c5 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008e64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008e68: 40 00 03 10 call 2009aa8 <_Thread_Stack_Free> <== NOT EXECUTED 2008e6c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008e70: 81 c7 e0 08 ret 2008e74: 91 e8 20 00 restore %g0, 0, %o0 * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 2008e78: 80 a6 e0 00 cmp %i3, 0 2008e7c: 02 80 00 0d be 2008eb0 <_Thread_Initialize+0x120> 2008e80: f6 26 61 7c st %i3, [ %i1 + 0x17c ] int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008e84: 03 00 80 62 sethi %hi(0x2018800), %g1 2008e88: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 ! 2018bbc <_Thread_Maximum_extensions> 2008e8c: 86 10 20 00 clr %g3 2008e90: 10 80 00 05 b 2008ea4 <_Thread_Initialize+0x114> 2008e94: 88 00 60 01 add %g1, 1, %g4 the_thread->extensions[i] = NULL; 2008e98: 83 28 e0 02 sll %g3, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008e9c: 86 00 e0 01 inc %g3 the_thread->extensions[i] = NULL; 2008ea0: c0 20 80 01 clr [ %g2 + %g1 ] * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 2008ea4: 80 a0 c0 04 cmp %g3, %g4 2008ea8: 32 bf ff fc bne,a 2008e98 <_Thread_Initialize+0x108> 2008eac: c4 06 61 7c ld [ %i1 + 0x17c ], %g2 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008eb0: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 2008eb4: e0 26 60 bc st %l0, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2008eb8: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 2008ebc: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 2008ec0: 80 a4 20 02 cmp %l0, 2 2008ec4: 12 80 00 05 bne 2008ed8 <_Thread_Initialize+0x148> 2008ec8: c2 26 60 c0 st %g1, [ %i1 + 0xc0 ] 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; 2008ecc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2008ed0: c2 00 62 48 ld [ %g1 + 0x248 ], %g1 ! 2018a48 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 2008ed4: c2 26 60 84 st %g1, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2008ed8: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 2008edc: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 2008ee0: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 2008ee4: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 2008ee8: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 2008eec: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 2008ef0: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 2008ef4: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 2008ef8: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 2008efc: 92 10 00 1d mov %i5, %o1 2008f00: 40 00 02 32 call 20097c8 <_Thread_Set_priority> 2008f04: 90 10 00 19 mov %i1, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2008f08: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2008f0c: c6 16 20 10 lduh [ %i0 + 0x10 ], %g3 /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 2008f10: c0 26 60 90 clr [ %i1 + 0x90 ] 2008f14: 03 00 00 3f sethi %hi(0xfc00), %g1 2008f18: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2008f1c: 82 08 80 01 and %g2, %g1, %g1 2008f20: 80 a0 40 03 cmp %g1, %g3 2008f24: 18 80 00 05 bgu 2008f38 <_Thread_Initialize+0x1a8> 2008f28: c0 26 60 94 clr [ %i1 + 0x94 ] information->local_table[ index ] = the_object; 2008f2c: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2008f30: 83 28 60 02 sll %g1, 2, %g1 2008f34: f2 20 80 01 st %i1, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2008f38: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 2008f3c: 90 10 00 19 mov %i1, %o0 2008f40: c2 26 60 0c st %g1, [ %i1 + 0xc ] 2008f44: 40 00 03 ec call 2009ef4 <_User_extensions_Thread_create> 2008f48: b0 10 20 01 mov 1, %i0 2008f4c: 80 a2 20 00 cmp %o0, 0 2008f50: 12 80 00 0e bne 2008f88 <_Thread_Initialize+0x1f8> 2008f54: 80 a6 e0 00 cmp %i3, 0 if ( extensions_area ) 2008f58: 02 80 00 05 be 2008f6c <_Thread_Initialize+0x1dc> <== NOT EXECUTED 2008f5c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 2008f60: 7f ff ff 85 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008f64: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2008f68: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2008f6c: 02 80 00 05 be 2008f80 <_Thread_Initialize+0x1f0> <== NOT EXECUTED 2008f70: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 2008f74: 7f ff ff 80 call 2008d74 <_Workspace_Free> <== NOT EXECUTED 2008f78: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 2008f7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2008f80: 40 00 02 ca call 2009aa8 <_Thread_Stack_Free> <== NOT EXECUTED 2008f84: b0 10 20 00 clr %i0 <== NOT EXECUTED return FALSE; } return TRUE; } 2008f88: 81 c7 e0 08 ret 2008f8c: 81 e8 00 00 restore 0200e24c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 200e24c: 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; 200e250: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200e254: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 200e258: c6 06 20 c0 ld [ %i0 + 0xc0 ], %g3 uint32_t numeric_argument ) { the_thread->resource_count = 0; the_thread->suspend_count = 0; the_thread->is_preemptible = the_thread->Start.is_preemptible; 200e25c: c2 26 20 7c st %g1, [ %i0 + 0x7c ] the_thread->budget_algorithm = the_thread->Start.budget_algorithm; the_thread->budget_callout = the_thread->Start.budget_callout; 200e260: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 200e264: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 200e268: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 200e26c: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200e270: 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 ) ) { 200e274: 7f ff ef fc call 200a264 <_Thread_queue_Extract_with_proxy> 200e278: 90 10 00 18 mov %i0, %o0 200e27c: 80 a2 20 00 cmp %o0, 0 200e280: 32 80 00 09 bne,a 200e2a4 <_Thread_Reset+0x58> 200e284: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200e288: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200e28c: 80 a0 60 02 cmp %g1, 2 200e290: 32 80 00 05 bne,a 200e2a4 <_Thread_Reset+0x58> 200e294: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200e298: 7f ff f3 41 call 200af9c <_Watchdog_Remove> <== NOT EXECUTED 200e29c: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200e2a0: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 200e2a4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200e2a8: 80 a0 40 19 cmp %g1, %i1 200e2ac: 02 80 00 05 be 200e2c0 <_Thread_Reset+0x74> 200e2b0: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200e2b4: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200e2b8: 7f ff f0 b9 call 200a59c <_Thread_Set_priority> 200e2bc: 81 e8 00 00 restore 200e2c0: 81 c7 e0 08 ret 200e2c4: 81 e8 00 00 restore 0200d3dc <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200d3dc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200d3e0: 03 00 80 62 sethi %hi(0x2018800), %g1 200d3e4: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 ! 2018bd0 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200d3e8: 7f ff d2 5d call 2001d5c 200d3ec: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200d3f0: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200d3f4: c4 04 40 00 ld [ %l1 ], %g2 200d3f8: c2 04 60 08 ld [ %l1 + 8 ], %g1 200d3fc: 80 a0 80 01 cmp %g2, %g1 200d400: 32 80 00 03 bne,a 200d40c <_Thread_Reset_timeslice+0x30> 200d404: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 200d408: 30 80 00 18 b,a 200d468 <_Thread_Reset_timeslice+0x8c> { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200d40c: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d410: 82 04 60 04 add %l1, 4, %g1 Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; previous->next = next; 200d414: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d418: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200d41c: 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; 200d420: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200d424: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d428: 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; 200d42c: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200d430: 7f ff d2 4f call 2001d6c 200d434: 01 00 00 00 nop 200d438: 7f ff d2 49 call 2001d5c 200d43c: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200d440: 05 00 80 62 sethi %hi(0x2018800), %g2 200d444: c2 00 a3 a8 ld [ %g2 + 0x3a8 ], %g1 ! 2018ba8 <_Thread_Heir> 200d448: 80 a4 00 01 cmp %l0, %g1 200d44c: 32 80 00 05 bne,a 200d460 <_Thread_Reset_timeslice+0x84> 200d450: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200d454: c2 04 40 00 ld [ %l1 ], %g1 200d458: c2 20 a3 a8 st %g1, [ %g2 + 0x3a8 ] _Context_Switch_necessary = TRUE; 200d45c: 84 10 20 01 mov 1, %g2 200d460: 03 00 80 62 sethi %hi(0x2018800), %g1 200d464: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] ! 2018be0 <_Context_Switch_necessary> _ISR_Enable( level ); 200d468: 7f ff d2 41 call 2001d6c 200d46c: 81 e8 00 00 restore 200d470: 01 00 00 00 nop 0200b29c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 200b29c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 200b2a0: 7f ff dd f8 call 2002a80 200b2a4: 01 00 00 00 nop 200b2a8: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 200b2ac: 80 a6 60 01 cmp %i1, 1 200b2b0: 32 80 00 04 bne,a 200b2c0 <_Thread_Resume+0x24> 200b2b4: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED the_thread->suspend_count = 0; 200b2b8: 10 80 00 04 b 200b2c8 <_Thread_Resume+0x2c> 200b2bc: c0 26 20 70 clr [ %i0 + 0x70 ] else the_thread->suspend_count--; 200b2c0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b2c4: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 200b2c8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 200b2cc: 80 a0 60 00 cmp %g1, 0 200b2d0: 22 80 00 03 be,a 200b2dc <_Thread_Resume+0x40> 200b2d4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 _ISR_Enable( level ); 200b2d8: 30 80 00 2e b,a 200b390 <_Thread_Resume+0xf4> <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 200b2dc: 80 88 60 02 btst 2, %g1 200b2e0: 02 80 00 2c be 200b390 <_Thread_Resume+0xf4> 200b2e4: 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 ) ) { 200b2e8: 80 a0 60 00 cmp %g1, 0 200b2ec: 12 80 00 29 bne 200b390 <_Thread_Resume+0xf4> 200b2f0: c2 26 20 10 st %g1, [ %i0 + 0x10 ] RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200b2f4: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 200b2f8: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 200b2fc: c2 11 00 00 lduh [ %g4 ], %g1 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 200b300: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 200b304: 82 10 40 02 or %g1, %g2, %g1 200b308: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200b30c: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200b310: 09 00 80 95 sethi %hi(0x2025400), %g4 200b314: c2 26 00 00 st %g1, [ %i0 ] 200b318: da 16 20 a0 lduh [ %i0 + 0xa0 ], %o5 old_last_node = the_chain->last; 200b31c: c2 00 e0 08 ld [ %g3 + 8 ], %g1 200b320: c4 11 23 d4 lduh [ %g4 + 0x3d4 ], %g2 the_chain->last = the_node; 200b324: f0 20 e0 08 st %i0, [ %g3 + 8 ] 200b328: 84 10 80 0d or %g2, %o5, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200b32c: c2 26 20 04 st %g1, [ %i0 + 4 ] 200b330: c4 31 23 d4 sth %g2, [ %g4 + 0x3d4 ] 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; 200b334: f0 20 40 00 st %i0, [ %g1 ] _ISR_Flash( level ); 200b338: 7f ff dd d6 call 2002a90 200b33c: 90 10 00 10 mov %l0, %o0 200b340: 7f ff dd d0 call 2002a80 200b344: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200b348: 07 00 80 95 sethi %hi(0x2025400), %g3 200b34c: c2 00 e3 b8 ld [ %g3 + 0x3b8 ], %g1 ! 20257b8 <_Thread_Heir> 200b350: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 200b354: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 200b358: 80 a0 80 01 cmp %g2, %g1 200b35c: 1a 80 00 0d bcc 200b390 <_Thread_Resume+0xf4> 200b360: 03 00 80 95 sethi %hi(0x2025400), %g1 _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200b364: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 20257e0 <_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; 200b368: f0 20 e3 b8 st %i0, [ %g3 + 0x3b8 ] if ( _Thread_Executing->is_preemptible || 200b36c: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 200b370: 80 a0 60 00 cmp %g1, 0 200b374: 32 80 00 05 bne,a 200b388 <_Thread_Resume+0xec> 200b378: 84 10 20 01 mov 1, %g2 200b37c: 80 a0 a0 00 cmp %g2, 0 200b380: 12 80 00 04 bne 200b390 <_Thread_Resume+0xf4> 200b384: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200b388: 03 00 80 95 sethi %hi(0x2025400), %g1 200b38c: c4 20 63 f0 st %g2, [ %g1 + 0x3f0 ] ! 20257f0 <_Context_Switch_necessary> } } } _ISR_Enable( level ); 200b390: 7f ff dd c0 call 2002a90 200b394: 91 e8 00 10 restore %g0, %l0, %o0 200b398: 01 00 00 00 nop 02009a4c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 2009a4c: 9d e3 bf 98 save %sp, -104, %sp void *stack_addr = 0; size_t the_stack_size = stack_size; if ( !_Stack_Is_enough( the_stack_size ) ) 2009a50: 80 a6 6f ff cmp %i1, 0xfff 2009a54: 28 80 00 02 bleu,a 2009a5c <_Thread_Stack_Allocate+0x10> 2009a58: 33 00 00 04 sethi %hi(0x1000), %i1 <== NOT EXECUTED * 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 ( _CPU_Table.stack_allocate_hook ) { 2009a5c: 03 00 80 62 sethi %hi(0x2018800), %g1 2009a60: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 2018b24 <_CPU_Table+0x20> 2009a64: 80 a0 60 00 cmp %g1, 0 2009a68: 02 80 00 06 be 2009a80 <_Thread_Stack_Allocate+0x34> 2009a6c: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 2009a70: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009a74: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 2009a78: 10 80 00 07 b 2009a94 <_Thread_Stack_Allocate+0x48> <== NOT EXECUTED 2009a7c: d0 26 20 dc st %o0, [ %i0 + 0xdc ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2009a80: 11 00 80 62 sethi %hi(0x2018800), %o0 2009a84: b2 10 00 09 mov %o1, %i1 2009a88: 7f ff f4 b4 call 2006d58 <_Heap_Allocate> 2009a8c: 90 12 23 3c or %o0, 0x33c, %o0 2009a90: d0 26 20 dc st %o0, [ %i0 + 0xdc ] the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 2009a94: 80 a0 00 08 cmp %g0, %o0 2009a98: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 2009a9c: b0 0e 40 18 and %i1, %i0, %i0 2009aa0: 81 c7 e0 08 ret 2009aa4: 81 e8 00 00 restore 02009aa8 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 2009aa8: 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 ) 2009aac: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 2009ab0: 80 a0 60 00 cmp %g1, 0 2009ab4: 02 80 00 08 be 2009ad4 <_Thread_Stack_Free+0x2c> 2009ab8: 03 00 80 62 sethi %hi(0x2018800), %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 ( _CPU_Table.stack_free_hook ) 2009abc: c2 00 63 28 ld [ %g1 + 0x328 ], %g1 ! 2018b28 <_CPU_Table+0x24> 2009ac0: 80 a0 60 00 cmp %g1, 0 2009ac4: 02 80 00 06 be 2009adc <_Thread_Stack_Free+0x34> 2009ac8: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 2009acc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009ad0: 01 00 00 00 nop <== NOT EXECUTED 2009ad4: 81 c7 e0 08 ret <== NOT EXECUTED 2009ad8: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009adc: 31 00 80 62 sethi %hi(0x2018800), %i0 2009ae0: b2 10 00 08 mov %o0, %i1 2009ae4: 7f ff f4 c4 call 2006df4 <_Heap_Free> 2009ae8: 91 ee 23 3c restore %i0, 0x33c, %o0 2009aec: 01 00 00 00 nop 02009080 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2009080: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 2009084: 80 a0 60 00 cmp %g1, 0 2009088: 02 80 00 05 be 200909c <_Thread_queue_Dequeue+0x1c> 200908c: 80 a0 60 01 cmp %g1, 1 2009090: 12 80 00 09 bne 20090b4 <_Thread_queue_Dequeue+0x34> 2009094: 01 00 00 00 nop 2009098: 30 80 00 04 b,a 20090a8 <_Thread_queue_Dequeue+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 200909c: 82 13 c0 00 mov %o7, %g1 20090a0: 40 00 0f d9 call 200d004 <_Thread_queue_Dequeue_fifo> 20090a4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 20090a8: 82 13 c0 00 mov %o7, %g1 20090ac: 40 00 00 0a call 20090d4 <_Thread_queue_Dequeue_priority> 20090b0: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return( the_thread ); } 20090b4: 81 c3 e0 08 retl <== NOT EXECUTED 20090b8: 90 10 20 00 clr %o0 <== NOT EXECUTED 0200d004 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 200d004: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 200d008: 7f ff d3 55 call 2001d5c 200d00c: a0 10 00 18 mov %i0, %l0 200d010: 84 10 00 08 mov %o0, %g2 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200d014: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 200d018: 82 04 20 04 add %l0, 4, %g1 200d01c: 80 a6 00 01 cmp %i0, %g1 200d020: 22 80 00 16 be,a 200d078 <_Thread_queue_Dequeue_fifo+0x74> 200d024: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 200d028: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 200d02c: c2 24 00 00 st %g1, [ %l0 ] the_thread = (Thread_Control *) _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200d030: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 200d034: e0 20 60 04 st %l0, [ %g1 + 4 ] 200d038: 80 a0 a0 02 cmp %g2, 2 200d03c: 02 80 00 05 be 200d050 <_Thread_queue_Dequeue_fifo+0x4c> 200d040: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200d044: 7f ff d3 4a call 2001d6c 200d048: 01 00 00 00 nop 200d04c: 30 80 00 07 b,a 200d068 <_Thread_queue_Dequeue_fifo+0x64> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200d050: 82 10 20 03 mov 3, %g1 ! 3 200d054: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d058: 7f ff d3 45 call 2001d6c 200d05c: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200d060: 7f ff f4 48 call 200a180 <_Watchdog_Remove> 200d064: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 200d068: 7f ff ff e1 call 200cfec <_Thread_Unblock> 200d06c: 90 10 00 18 mov %i0, %o0 200d070: 81 c7 e0 08 ret 200d074: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200d078: 80 a0 60 02 cmp %g1, 2 200d07c: 18 80 00 06 bgu 200d094 <_Thread_queue_Dequeue_fifo+0x90> 200d080: 80 a0 60 03 cmp %g1, 3 200d084: 80 a0 60 01 cmp %g1, 1 200d088: 1a 80 00 0a bcc 200d0b0 <_Thread_queue_Dequeue_fifo+0xac> 200d08c: 82 10 20 03 mov 3, %g1 200d090: 30 80 00 03 b,a 200d09c <_Thread_queue_Dequeue_fifo+0x98> 200d094: 12 bf ff f7 bne 200d070 <_Thread_queue_Dequeue_fifo+0x6c> <== NOT EXECUTED 200d098: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 200d09c: b0 10 20 00 clr %i0 200d0a0: 7f ff d3 33 call 2001d6c 200d0a4: 90 10 00 02 mov %g2, %o0 200d0a8: 81 c7 e0 08 ret 200d0ac: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200d0b0: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 200d0b4: 7f ff d3 2e call 2001d6c <== NOT EXECUTED 200d0b8: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 200d0bc: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200d0c0: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 200d0c4: 81 c7 e0 08 ret <== NOT EXECUTED 200d0c8: 81 e8 00 00 restore <== NOT EXECUTED 020090d4 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 20090d4: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 20090d8: 7f ff e3 21 call 2001d5c 20090dc: 01 00 00 00 nop 20090e0: 98 10 00 08 mov %o0, %o4 20090e4: 86 10 20 00 clr %g3 20090e8: 88 10 20 00 clr %g4 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 20090ec: d0 01 00 18 ld [ %g4 + %i0 ], %o0 for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 20090f0: 85 28 e0 02 sll %g3, 2, %g2 20090f4: 83 28 e0 04 sll %g3, 4, %g1 20090f8: 82 20 40 02 sub %g1, %g2, %g1 20090fc: 82 06 00 01 add %i0, %g1, %g1 2009100: 82 00 60 04 add %g1, 4, %g1 2009104: 80 a2 00 01 cmp %o0, %g1 2009108: 02 80 00 04 be 2009118 <_Thread_queue_Dequeue_priority+0x44> 200910c: 88 01 20 0c add %g4, 0xc, %g4 the_thread = (Thread_Control *) 2009110: 10 80 00 1c b 2009180 <_Thread_queue_Dequeue_priority+0xac> 2009114: b0 10 00 08 mov %o0, %i0 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 2009118: 86 00 e0 01 inc %g3 Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 200911c: 80 a0 e0 04 cmp %g3, 4 2009120: 32 bf ff f4 bne,a 20090f0 <_Thread_queue_Dequeue_priority+0x1c> 2009124: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 2009128: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200912c: 80 a0 60 02 cmp %g1, 2 2009130: 18 80 00 06 bgu 2009148 <_Thread_queue_Dequeue_priority+0x74> 2009134: 80 a0 60 03 cmp %g1, 3 2009138: 80 a0 60 01 cmp %g1, 1 200913c: 1a 80 00 0a bcc 2009164 <_Thread_queue_Dequeue_priority+0x90> 2009140: 82 10 20 03 mov 3, %g1 2009144: 30 80 00 03 b,a 2009150 <_Thread_queue_Dequeue_priority+0x7c> 2009148: 12 80 00 0e bne 2009180 <_Thread_queue_Dequeue_priority+0xac> <== NOT EXECUTED 200914c: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 2009150: b0 10 20 00 clr %i0 2009154: 7f ff e3 06 call 2001d6c 2009158: 90 10 00 0c mov %o4, %o0 200915c: 81 c7 e0 08 ret 2009160: 81 e8 00 00 restore return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 2009164: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 2009168: 7f ff e3 01 call 2001d6c <== NOT EXECUTED 200916c: 90 10 00 0c mov %o4, %o0 <== NOT EXECUTED return _Thread_Executing; 2009170: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009174: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2009178: 81 c7 e0 08 ret <== NOT EXECUTED 200917c: 81 e8 00 00 restore <== NOT EXECUTED } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 2009180: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 2009184: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 2009188: c0 26 20 44 clr [ %i0 + 0x44 ] new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200918c: 80 a0 c0 01 cmp %g3, %g1 dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 2009190: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 2009194: 02 80 00 14 be 20091e4 <_Thread_queue_Dequeue_priority+0x110> 2009198: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 200919c: da 06 20 40 ld [ %i0 + 0x40 ], %o5 new_second_node = new_first_node->next; 20091a0: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 20091a4: c6 20 a0 04 st %g3, [ %g2 + 4 ] if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { last_node = the_thread->Wait.Block2n.last; new_second_node = new_first_node->next; previous_node->next = new_first_node; 20091a8: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 20091ac: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 20091b0: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 20091b4: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 20091b8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 20091bc: 80 a0 80 01 cmp %g2, %g1 20091c0: 22 80 00 0c be,a 20091f0 <_Thread_queue_Dequeue_priority+0x11c> 20091c4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 /* > two threads on 2-n */ new_second_node->previous = 20091c8: 82 00 e0 38 add %g3, 0x38, %g1 20091cc: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 20091d0: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 20091d4: da 20 e0 40 st %o5, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 20091d8: 82 00 e0 3c add %g3, 0x3c, %g1 20091dc: 10 80 00 04 b 20091ec <_Thread_queue_Dequeue_priority+0x118> 20091e0: c2 23 40 00 st %g1, [ %o5 ] } } else { previous_node->next = next_node; next_node->previous = previous_node; 20091e4: 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; 20091e8: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20091ec: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20091f0: 80 a0 60 02 cmp %g1, 2 20091f4: 02 80 00 08 be 2009214 <_Thread_queue_Dequeue_priority+0x140> 20091f8: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20091fc: 7f ff e2 dc call 2001d6c 2009200: 90 10 00 0c mov %o4, %o0 _Thread_Unblock( the_thread ); 2009204: 7f ff ff ae call 20090bc <_Thread_Unblock> 2009208: 90 10 00 18 mov %i0, %o0 200920c: 81 c7 e0 08 ret 2009210: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009214: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2009218: 7f ff e2 d5 call 2001d6c 200921c: 90 10 00 0c mov %o4, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 2009220: 40 00 03 d8 call 200a180 <_Watchdog_Remove> 2009224: 90 06 20 48 add %i0, 0x48, %o0 _Thread_Unblock( the_thread ); 2009228: 7f ff ff a5 call 20090bc <_Thread_Unblock> 200922c: 90 10 00 18 mov %i0, %o0 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 2009230: 81 c7 e0 08 ret 2009234: 81 e8 00 00 restore 0200d0cc <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d0cc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 200d0d0: 7f ff d3 23 call 2001d5c 200d0d4: a0 10 00 18 mov %i0, %l0 void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200d0d8: b0 10 00 19 mov %i1, %i0 ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); sync_state = the_thread_queue->sync_state; 200d0dc: c4 04 20 30 ld [ %l0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200d0e0: 80 a0 a0 02 cmp %g2, 2 200d0e4: 02 80 00 10 be 200d124 <_Thread_queue_Enqueue_fifo+0x58> 200d0e8: c0 24 20 30 clr [ %l0 + 0x30 ] 200d0ec: 80 a0 a0 03 cmp %g2, 3 200d0f0: 02 80 00 12 be 200d138 <_Thread_queue_Enqueue_fifo+0x6c> 200d0f4: 80 a0 a0 01 cmp %g2, 1 200d0f8: 32 80 00 1e bne,a 200d170 <_Thread_queue_Enqueue_fifo+0xa4> 200d0fc: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200d100: 82 04 20 04 add %l0, 4, %g1 200d104: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 200d108: c2 04 20 08 ld [ %l0 + 8 ], %g1 the_chain->last = the_node; 200d10c: f2 24 20 08 st %i1, [ %l0 + 8 ] case THREAD_QUEUE_NOTHING_HAPPENED: _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 200d110: e0 26 60 44 st %l0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200d114: c2 26 60 04 st %g1, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200d118: f2 20 40 00 st %i1, [ %g1 ] _ISR_Enable( level ); 200d11c: 7f ff d3 14 call 2001d6c 200d120: 91 e8 00 08 restore %g0, %o0, %o0 return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200d124: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 200d128: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 200d12c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 200d130: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 200d134: 30 80 00 0d b,a 200d168 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 200d138: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 200d13c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d140: 12 80 00 0a bne 200d168 <_Thread_queue_Enqueue_fifo+0x9c> <== NOT EXECUTED 200d144: 01 00 00 00 nop <== NOT EXECUTED 200d148: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 200d14c: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200d150: 7f ff d3 07 call 2001d6c <== NOT EXECUTED 200d154: 01 00 00 00 nop <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200d158: 7f ff f4 0a call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 200d15c: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200d160: 10 80 00 04 b 200d170 <_Thread_queue_Enqueue_fifo+0xa4> <== NOT EXECUTED 200d164: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED } else _ISR_Enable( level ); 200d168: 7f ff d3 01 call 2001d6c <== NOT EXECUTED 200d16c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200d170: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200d174: 7f ff ed cf call 20088b0 <_Thread_Clear_state> <== NOT EXECUTED 200d178: 81 e8 00 00 restore <== NOT EXECUTED 200d17c: 01 00 00 00 nop 020092bc <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20092bc: 9d e3 bf 98 save %sp, -104, %sp States_Control block_state; Thread_queue_States sync_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 20092c0: 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); 20092c4: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; 20092c8: c0 26 60 3c clr [ %i1 + 0x3c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20092cc: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20092d0: 82 06 60 38 add %i1, 0x38, %g1 20092d4: c2 26 60 40 st %g1, [ %i1 + 0x40 ] header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 20092d8: 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); 20092dc: 85 34 a0 06 srl %l2, 6, %g2 20092e0: 12 80 00 34 bne 20093b0 <_Thread_queue_Enqueue_priority+0xf4> 20092e4: ec 06 20 38 ld [ %i0 + 0x38 ], %l6 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 20092e8: 83 28 a0 04 sll %g2, 4, %g1 20092ec: 85 28 a0 02 sll %g2, 2, %g2 20092f0: aa 20 40 02 sub %g1, %g2, %l5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20092f4: 82 06 00 15 add %i0, %l5, %g1 20092f8: a8 00 60 04 add %g1, 4, %l4 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 20092fc: 7f ff e2 98 call 2001d5c 2009300: 01 00 00 00 nop 2009304: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->first; 2009308: e0 06 00 15 ld [ %i0 + %l5 ], %l0 200930c: 10 80 00 18 b 200936c <_Thread_queue_Enqueue_priority+0xb0> 2009310: a6 10 3f ff mov -1, %l3 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority <= search_priority ) 2009314: 80 a4 80 13 cmp %l2, %l3 2009318: 28 80 00 19 bleu,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200931c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009320: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 2009324: 80 a4 00 14 cmp %l0, %l4 2009328: 22 80 00 15 be,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200932c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 2009330: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 if ( priority <= search_priority ) 2009334: 80 a4 80 13 cmp %l2, %l3 2009338: 28 80 00 11 bleu,a 200937c <_Thread_queue_Enqueue_priority+0xc0> 200933c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #endif _ISR_Flash( level ); 2009340: 7f ff e2 8b call 2001d6c 2009344: 90 10 00 11 mov %l1, %o0 2009348: 7f ff e2 85 call 2001d5c 200934c: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009350: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009354: 80 8d 80 01 btst %l6, %g1 2009358: 32 80 00 05 bne,a 200936c <_Thread_queue_Enqueue_priority+0xb0> 200935c: e0 04 00 00 ld [ %l0 ], %l0 _ISR_Enable( level ); 2009360: 7f ff e2 83 call 2001d6c <== NOT EXECUTED 2009364: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009368: 30 bf ff e5 b,a 20092fc <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 200936c: 80 a4 00 14 cmp %l0, %l4 2009370: 32 bf ff e9 bne,a 2009314 <_Thread_queue_Enqueue_priority+0x58> 2009374: e6 04 20 14 ld [ %l0 + 0x14 ], %l3 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009378: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200937c: 80 a0 60 01 cmp %g1, 1 2009380: 32 80 00 47 bne,a 200949c <_Thread_queue_Enqueue_priority+0x1e0> 2009384: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009388: 80 a4 80 13 cmp %l2, %l3 200938c: 02 80 00 3c be 200947c <_Thread_queue_Enqueue_priority+0x1c0> 2009390: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2009394: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009398: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 200939c: 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; 20093a0: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 20093a4: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 20093a8: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 20093ac: 30 80 00 32 b,a 2009474 <_Thread_queue_Enqueue_priority+0x1b8> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 20093b0: 83 28 a0 04 sll %g2, 4, %g1 20093b4: 85 28 a0 02 sll %g2, 2, %g2 20093b8: 82 20 40 02 sub %g1, %g2, %g1 20093bc: a6 00 40 18 add %g1, %i0, %l3 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 20093c0: aa 10 00 13 mov %l3, %l5 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 20093c4: 7f ff e2 66 call 2001d5c 20093c8: 01 00 00 00 nop 20093cc: a2 10 00 08 mov %o0, %l1 search_thread = (Thread_Control *) header->last; 20093d0: e0 05 60 08 ld [ %l5 + 8 ], %l0 20093d4: 10 80 00 18 b 2009434 <_Thread_queue_Enqueue_priority+0x178> 20093d8: a8 10 21 00 mov 0x100, %l4 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; if ( priority >= search_priority ) 20093dc: 80 a4 80 14 cmp %l2, %l4 20093e0: 3a 80 00 19 bcc,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 20093e4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 20093e8: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 20093ec: 80 a4 00 13 cmp %l0, %l3 20093f0: 22 80 00 15 be,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 20093f4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 20093f8: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 if ( priority >= search_priority ) 20093fc: 80 a4 80 14 cmp %l2, %l4 2009400: 3a 80 00 11 bcc,a 2009444 <_Thread_queue_Enqueue_priority+0x188> 2009404: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED break; #endif _ISR_Flash( level ); 2009408: 7f ff e2 59 call 2001d6c 200940c: 90 10 00 11 mov %l1, %o0 2009410: 7f ff e2 53 call 2001d5c 2009414: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009418: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200941c: 80 8d 80 01 btst %l6, %g1 2009420: 32 80 00 05 bne,a 2009434 <_Thread_queue_Enqueue_priority+0x178> 2009424: e0 04 20 04 ld [ %l0 + 4 ], %l0 _ISR_Enable( level ); 2009428: 7f ff e2 51 call 2001d6c <== NOT EXECUTED 200942c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009430: 30 bf ff e5 b,a 20093c4 <_Thread_queue_Enqueue_priority+0x108> <== NOT EXECUTED 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 ) ) { 2009434: 80 a4 00 13 cmp %l0, %l3 2009438: 32 bf ff e9 bne,a 20093dc <_Thread_queue_Enqueue_priority+0x120> 200943c: e8 04 20 14 ld [ %l0 + 0x14 ], %l4 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009440: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2009444: 80 a0 60 01 cmp %g1, 1 2009448: 32 80 00 15 bne,a 200949c <_Thread_queue_Enqueue_priority+0x1e0> 200944c: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 <== NOT EXECUTED goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009450: 80 a4 80 14 cmp %l2, %l4 2009454: 02 80 00 0a be 200947c <_Thread_queue_Enqueue_priority+0x1c0> 2009458: c0 26 20 30 clr [ %i0 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 200945c: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 2009460: 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; 2009464: 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; 2009468: f0 26 60 44 st %i0, [ %i1 + 0x44 ] 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; 200946c: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 2009470: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009474: 7f ff e2 3e call 2001d6c 2009478: 91 e8 00 11 restore %g0, %l1, %o0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200947c: 82 04 20 3c add %l0, 0x3c, %g1 return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 2009480: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009484: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 2009488: 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; 200948c: f0 26 60 44 st %i0, [ %i1 + 0x44 ] previous_node = search_node->previous; the_node = (Chain_Node *) the_thread; the_node->next = search_node; the_node->previous = previous_node; previous_node->next = the_node; 2009490: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 2009494: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009498: 30 bf ff f7 b,a 2009474 <_Thread_queue_Enqueue_priority+0x1b8> synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200949c: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 20094a0: 02 80 00 07 be 20094bc <_Thread_queue_Enqueue_priority+0x200> <== NOT EXECUTED 20094a4: c0 26 20 30 clr [ %i0 + 0x30 ] <== NOT EXECUTED 20094a8: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20094ac: 12 80 00 17 bne 2009508 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 20094b0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 20094b4: 10 80 00 07 b 20094d0 <_Thread_queue_Enqueue_priority+0x214> <== NOT EXECUTED 20094b8: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20094bc: c2 06 60 44 ld [ %i1 + 0x44 ], %g1 <== NOT EXECUTED the_thread->Wait.queue = NULL; 20094c0: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED * This should never happen. All of this was dealt with above. */ break; case THREAD_QUEUE_TIMEOUT: the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20094c4: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED 20094c8: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 20094cc: 30 80 00 0c b,a 20094fc <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 20094d0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20094d4: 12 80 00 0a bne 20094fc <_Thread_queue_Enqueue_priority+0x240> <== NOT EXECUTED 20094d8: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20094dc: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 20094e0: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 20094e4: 7f ff e2 22 call 2001d6c <== NOT EXECUTED 20094e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 20094ec: 40 00 03 25 call 200a180 <_Watchdog_Remove> <== NOT EXECUTED 20094f0: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 20094f4: 10 80 00 05 b 2009508 <_Thread_queue_Enqueue_priority+0x24c> <== NOT EXECUTED 20094f8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED } else _ISR_Enable( level ); 20094fc: 7f ff e2 1c call 2001d6c <== NOT EXECUTED 2009500: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2009504: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009508: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200950c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009510: 7f ff fc e8 call 20088b0 <_Thread_Clear_state> <== NOT EXECUTED 2009514: 81 e8 00 00 restore <== NOT EXECUTED 2009518: 01 00 00 00 nop 02009238 <_Thread_queue_Enqueue_with_handler>: void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 2009238: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 200923c: 03 00 80 62 sethi %hi(0x2018800), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 2009240: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 2009244: e0 00 63 d0 ld [ %g1 + 0x3d0 ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 2009248: a2 10 00 18 mov %i0, %l1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 200924c: 40 00 01 79 call 2009830 <_Thread_Set_state> 2009250: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 2009254: 80 a6 60 00 cmp %i1, 0 2009258: 22 80 00 0d be,a 200928c <_Thread_queue_Enqueue_with_handler+0x54> 200925c: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 _Watchdog_Initialize( 2009260: c2 04 20 08 ld [ %l0 + 8 ], %g1 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2009264: 11 00 80 62 sethi %hi(0x2018800), %o0 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2009268: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 200926c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2009270: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2009274: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2009278: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200927c: 90 12 23 f0 or %o0, 0x3f0, %o0 2009280: 40 00 03 68 call 200a020 <_Watchdog_Insert> 2009284: 92 04 20 48 add %l0, 0x48, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 2009288: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 200928c: 80 a0 60 00 cmp %g1, 0 2009290: 02 80 00 05 be 20092a4 <_Thread_queue_Enqueue_with_handler+0x6c> 2009294: 80 a0 60 01 cmp %g1, 1 2009298: 12 80 00 07 bne 20092b4 <_Thread_queue_Enqueue_with_handler+0x7c> 200929c: 01 00 00 00 nop 20092a0: 30 80 00 03 b,a 20092ac <_Thread_queue_Enqueue_with_handler+0x74> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 20092a4: 40 00 0f 8a call 200d0cc <_Thread_queue_Enqueue_fifo> 20092a8: 93 e8 00 10 restore %g0, %l0, %o1 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 20092ac: 40 00 00 04 call 20092bc <_Thread_queue_Enqueue_priority> 20092b0: 93 e8 00 10 restore %g0, %l0, %o1 20092b4: 81 c7 e0 08 ret <== NOT EXECUTED 20092b8: 81 e8 00 00 restore <== NOT EXECUTED 0200d180 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200d180: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200d184: 80 a0 60 00 cmp %g1, 0 200d188: 02 80 00 05 be 200d19c <_Thread_queue_Extract+0x1c> 200d18c: 80 a0 60 01 cmp %g1, 1 200d190: 12 80 00 09 bne 200d1b4 <_Thread_queue_Extract+0x34> 200d194: 94 10 20 00 clr %o2 200d198: 30 80 00 04 b,a 200d1a8 <_Thread_queue_Extract+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 200d19c: 82 13 c0 00 mov %o7, %g1 200d1a0: 40 00 04 3f call 200e29c <_Thread_queue_Extract_fifo> 200d1a4: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 200d1a8: 82 13 c0 00 mov %o7, %g1 200d1ac: 40 00 00 04 call 200d1bc <_Thread_queue_Extract_priority_helper> 200d1b0: 9e 10 40 00 mov %g1, %o7 200d1b4: 81 c3 e0 08 retl <== NOT EXECUTED 200d1b8: 01 00 00 00 nop 0200e29c <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200e29c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200e2a0: 7f ff ce af call 2001d5c 200e2a4: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200e2a8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200e2ac: 03 00 00 ef sethi %hi(0x3bc00), %g1 200e2b0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200e2b4: 80 88 80 01 btst %g2, %g1 200e2b8: 32 80 00 04 bne,a 200e2c8 <_Thread_queue_Extract_fifo+0x2c> 200e2bc: c2 06 40 00 ld [ %i1 ], %g1 _ISR_Enable( level ); 200e2c0: 7f ff ce ab call 2001d6c <== NOT EXECUTED 200e2c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200e2c8: 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 ) ) { 200e2cc: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200e2d0: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200e2d4: c4 20 60 04 st %g2, [ %g1 + 4 ] 200e2d8: 80 a0 e0 02 cmp %g3, 2 200e2dc: 02 80 00 06 be 200e2f4 <_Thread_queue_Extract_fifo+0x58> 200e2e0: c0 26 60 44 clr [ %i1 + 0x44 ] _ISR_Enable( level ); 200e2e4: 7f ff ce a2 call 2001d6c 200e2e8: 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 ); 200e2ec: 10 80 00 0a b 200e314 <_Thread_queue_Extract_fifo+0x78> 200e2f0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e2f4: 82 10 20 03 mov 3, %g1 200e2f8: c2 26 60 50 st %g1, [ %i1 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200e2fc: 7f ff ce 9c call 2001d6c 200e300: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200e304: 7f ff ef 9f call 200a180 <_Watchdog_Remove> 200e308: 90 06 60 48 add %i1, 0x48, %o0 200e30c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200e310: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200e314: 7f ff e9 67 call 20088b0 <_Thread_Clear_state> 200e318: 81 e8 00 00 restore 200e31c: 01 00 00 00 nop 0200d1bc <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 200d1bc: 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 ); 200d1c0: 7f ff d2 e7 call 2001d5c 200d1c4: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200d1c8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200d1cc: 03 00 00 ef sethi %hi(0x3bc00), %g1 200d1d0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200d1d4: 80 88 80 01 btst %g2, %g1 200d1d8: 32 80 00 03 bne,a 200d1e4 <_Thread_queue_Extract_priority_helper+0x28> 200d1dc: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 _ISR_Enable( level ); 200d1e0: 30 80 00 1d b,a 200d254 <_Thread_queue_Extract_priority_helper+0x98> <== NOT EXECUTED */ next_node = the_node->next; previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200d1e4: 82 06 60 3c add %i1, 0x3c, %g1 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 200d1e8: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200d1ec: 80 a0 c0 01 cmp %g3, %g1 200d1f0: 02 80 00 14 be 200d240 <_Thread_queue_Extract_priority_helper+0x84> 200d1f4: 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; 200d1f8: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200d1fc: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200d200: 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; 200d204: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200d208: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200d20c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200d210: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200d214: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200d218: 80 a0 80 01 cmp %g2, %g1 200d21c: 02 80 00 0c be 200d24c <_Thread_queue_Extract_priority_helper+0x90> 200d220: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 200d224: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 200d228: c2 21 20 04 st %g1, [ %g4 + 4 ] <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 200d22c: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 200d230: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200d234: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED 200d238: 10 80 00 05 b 200d24c <_Thread_queue_Extract_priority_helper+0x90> <== NOT EXECUTED 200d23c: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED } } else { previous_node->next = next_node; next_node->previous = previous_node; 200d240: 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; 200d244: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200d248: 80 a6 a0 00 cmp %i2, 0 200d24c: 22 80 00 04 be,a 200d25c <_Thread_queue_Extract_priority_helper+0xa0> 200d250: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 _ISR_Enable( level ); 200d254: 7f ff d2 c6 call 2001d6c 200d258: 91 e8 00 08 restore %g0, %o0, %o0 return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200d25c: 80 a0 60 02 cmp %g1, 2 200d260: 02 80 00 06 be 200d278 <_Thread_queue_Extract_priority_helper+0xbc> 200d264: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200d268: 7f ff d2 c1 call 2001d6c 200d26c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200d270: 10 80 00 08 b 200d290 <_Thread_queue_Extract_priority_helper+0xd4> 200d274: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200d278: c2 26 20 50 st %g1, [ %i0 + 0x50 ] } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200d27c: 7f ff d2 bc call 2001d6c 200d280: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200d284: 7f ff f3 bf call 200a180 <_Watchdog_Remove> 200d288: 90 06 20 48 add %i0, 0x48, %o0 200d28c: b2 16 63 f8 or %i1, 0x3f8, %i1 200d290: 7f ff ed 88 call 20088b0 <_Thread_Clear_state> 200d294: 81 e8 00 00 restore 200d298: 01 00 00 00 nop 0200951c <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 200951c: 9d e3 bf 98 save %sp, -104, %sp States_Control state; Objects_Information *the_information; Objects_Thread_queue_Extract_callout proxy_extract_callout; state = the_thread->current_state; 2009520: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009524: a0 10 00 18 mov %i0, %l0 Objects_Information *the_information; Objects_Thread_queue_Extract_callout proxy_extract_callout; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 2009528: 03 00 00 ef sethi %hi(0x3bc00), %g1 200952c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009530: 80 88 80 01 btst %g2, %g1 2009534: 02 80 00 1e be 20095ac <_Thread_queue_Extract_with_proxy+0x90> 2009538: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 200953c: 03 00 00 08 sethi %hi(0x2000), %g1 2009540: 80 88 80 01 btst %g2, %g1 2009544: 22 80 00 17 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> 2009548: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 200954c: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 2009550: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 2009554: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2009558: 22 80 00 12 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 200955c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 2009560: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 2009564: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2009568: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 200956c: 82 10 62 50 or %g1, 0x250, %g1 <== NOT EXECUTED 2009570: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 2009574: c2 00 40 02 ld [ %g1 + %g2 ], %g1 <== NOT EXECUTED 2009578: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 200957c: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 2009580: c2 00 40 03 ld [ %g1 + %g3 ], %g1 <== NOT EXECUTED 2009584: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 2009588: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200958c: 22 80 00 05 be,a 20095a0 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009590: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 2009594: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009598: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 200959c: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 20095a0: 92 10 00 10 mov %l0, %o1 20095a4: 40 00 0e f7 call 200d180 <_Thread_queue_Extract> 20095a8: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 20095ac: 81 c7 e0 08 ret 20095b0: 81 e8 00 00 restore 0200bbdc <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 200bbdc: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200bbe0: 80 a0 60 00 cmp %g1, 0 200bbe4: 02 80 00 05 be 200bbf8 <_Thread_queue_First+0x1c> 200bbe8: 80 a0 60 01 cmp %g1, 1 200bbec: 12 80 00 09 bne 200bc10 <_Thread_queue_First+0x34> 200bbf0: 01 00 00 00 nop 200bbf4: 30 80 00 04 b,a 200bc04 <_Thread_queue_First+0x28> case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 200bbf8: 82 13 c0 00 mov %o7, %g1 200bbfc: 40 00 0f a2 call 200fa84 <_Thread_queue_First_fifo> 200bc00: 9e 10 40 00 mov %g1, %o7 break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 200bc04: 82 13 c0 00 mov %o7, %g1 200bc08: 40 00 00 04 call 200bc18 <_Thread_queue_First_priority> 200bc0c: 9e 10 40 00 mov %g1, %o7 the_thread = NULL; break; } return the_thread; } 200bc10: 81 c3 e0 08 retl <== NOT EXECUTED 200bc14: 90 10 20 00 clr %o0 <== NOT EXECUTED 02009660 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009660: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 2009664: 80 a6 20 00 cmp %i0, 0 2009668: 02 80 00 18 be 20096c8 <_Thread_queue_Requeue+0x68> 200966c: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 2009670: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2009674: 80 a4 20 01 cmp %l0, 1 2009678: 12 80 00 14 bne 20096c8 <_Thread_queue_Requeue+0x68> 200967c: 01 00 00 00 nop break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 2009680: 7f ff e1 b7 call 2001d5c 2009684: 01 00 00 00 nop 2009688: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200968c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 2009690: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009694: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009698: 80 88 80 01 btst %g2, %g1 200969c: 02 80 00 09 be 20096c0 <_Thread_queue_Requeue+0x60> 20096a0: 90 10 00 18 mov %i0, %o0 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 20096a4: 92 10 00 19 mov %i1, %o1 20096a8: 94 10 20 01 mov 1, %o2 20096ac: 40 00 0e c4 call 200d1bc <_Thread_queue_Extract_priority_helper> 20096b0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 20096b4: 90 10 00 18 mov %i0, %o0 20096b8: 7f ff ff 01 call 20092bc <_Thread_queue_Enqueue_priority> 20096bc: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 20096c0: 7f ff e1 ab call 2001d6c 20096c4: 91 e8 00 11 restore %g0, %l1, %o0 20096c8: 81 c7 e0 08 ret <== NOT EXECUTED 20096cc: 81 e8 00 00 restore <== NOT EXECUTED 020096d0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 20096d0: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 20096d4: 92 96 20 00 orcc %i0, 0, %o1 20096d8: 12 80 00 0a bne 2009700 <_Thread_queue_Timeout+0x30> 20096dc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20096e0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20096e4: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20096e8: 84 00 a0 01 inc %g2 <== NOT EXECUTED 20096ec: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== NOT EXECUTED 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; 20096f0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20096f4: d2 00 63 d0 ld [ %g1 + 0x3d0 ], %o1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 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; 20096f8: 10 80 00 18 b 2009758 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 20096fc: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009700: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2009704: 80 a0 a0 04 cmp %g2, 4 2009708: 18 80 00 0e bgu 2009740 <_Thread_queue_Timeout+0x70> 200970c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2009710: 83 32 60 1b srl %o1, 0x1b, %g1 2009714: 80 a0 60 01 cmp %g1, 1 2009718: 12 80 00 0a bne 2009740 <_Thread_queue_Timeout+0x70> 200971c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009720: 83 28 a0 02 sll %g2, 2, %g1 2009724: 05 00 80 62 sethi %hi(0x2018800), %g2 2009728: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 200972c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2009730: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2009734: 80 a2 20 00 cmp %o0, 0 2009738: 12 80 00 05 bne 200974c <_Thread_queue_Timeout+0x7c> 200973c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2009740: 92 10 20 00 clr %o1 <== NOT EXECUTED 2009744: 10 80 00 05 b 2009758 <_Thread_queue_Timeout+0x88> <== NOT EXECUTED 2009748: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200974c: 7f ff f8 1f call 20077c8 <_Objects_Get> 2009750: 94 07 bf f4 add %fp, -12, %o2 2009754: 92 10 00 08 mov %o0, %o1 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009758: c2 07 bf f4 ld [ %fp + -12 ], %g1 200975c: 80 a0 60 00 cmp %g1, 0 2009760: 12 80 00 18 bne 20097c0 <_Thread_queue_Timeout+0xf0> 2009764: 01 00 00 00 nop */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 2009768: c4 02 60 44 ld [ %o1 + 0x44 ], %g2 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 200976c: c6 00 a0 30 ld [ %g2 + 0x30 ], %g3 2009770: 80 a0 e0 00 cmp %g3, 0 2009774: 02 80 00 0b be 20097a0 <_Thread_queue_Timeout+0xd0> 2009778: 03 00 80 62 sethi %hi(0x2018800), %g1 200977c: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> <== NOT EXECUTED 2009780: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 2009784: 32 80 00 08 bne,a 20097a4 <_Thread_queue_Timeout+0xd4> <== NOT EXECUTED 2009788: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 200978c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2009790: 02 80 00 08 be 20097b0 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 2009794: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2009798: 10 80 00 06 b 20097b0 <_Thread_queue_Timeout+0xe0> <== NOT EXECUTED 200979c: c2 20 a0 30 st %g1, [ %g2 + 0x30 ] <== NOT EXECUTED } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20097a0: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 20097a4: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 20097a8: 40 00 0e 76 call 200d180 <_Thread_queue_Extract> 20097ac: c2 22 60 34 st %g1, [ %o1 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 20097b0: 05 00 80 62 sethi %hi(0x2018800), %g2 20097b4: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20097b8: 82 00 7f ff add %g1, -1, %g1 20097bc: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 20097c0: 81 c7 e0 08 ret 20097c4: 81 e8 00 00 restore 02012a34 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 2012a34: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2012a38: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a3c: c8 00 63 74 ld [ %g1 + 0x374 ], %g4 ! 2032774 <_Watchdog_Ticks_since_boot> _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a40: 03 00 80 c9 sethi %hi(0x2032400), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2012a44: 07 00 80 c9 sethi %hi(0x2032400), %g3 2012a48: da 00 62 ac ld [ %g1 + 0x2ac ], %o5 2012a4c: c2 00 e1 f0 ld [ %g3 + 0x1f0 ], %g1 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2012a50: 05 00 80 c9 sethi %hi(0x2032400), %g2 2012a54: 82 00 60 01 inc %g1 2012a58: c8 20 a1 00 st %g4, [ %g2 + 0x100 ] 2012a5c: c2 20 e1 f0 st %g1, [ %g3 + 0x1f0 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2012a60: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a64: da 20 60 fc st %o5, [ %g1 + 0xfc ] ! 20324fc <_Timer_Server_seconds_last_time> ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012a68: 03 00 80 c9 sethi %hi(0x2032400), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a6c: 27 00 80 c9 sethi %hi(0x2032400), %l3 2012a70: ba 10 62 f0 or %g1, 0x2f0, %i5 2012a74: 82 14 e0 f0 or %l3, 0xf0, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012a78: ae 00 60 04 add %g1, 4, %l7 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012a7c: 03 00 80 c9 sethi %hi(0x2032400), %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012a80: 25 00 80 c9 sethi %hi(0x2032400), %l2 2012a84: a2 10 61 10 or %g1, 0x110, %l1 2012a88: 82 14 a1 04 or %l2, 0x104, %g1 2012a8c: a8 10 00 03 mov %g3, %l4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012a90: ac 00 60 04 add %g1, 4, %l6 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012a94: 21 00 80 cc sethi %hi(0x2033000), %l0 _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012a98: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012a9c: aa 10 62 e4 or %g1, 0x2e4, %l5 ! 20326e4 <_Watchdog_Seconds_chain> 2012aa0: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 2012aa4: 40 00 10 80 call 2016ca4 <_Thread_Set_state> 2012aa8: 92 10 20 08 mov 8, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2012aac: c2 04 e0 f0 ld [ %l3 + 0xf0 ], %g1 _Timer_Server_reset_ticks_timer(); 2012ab0: 80 a0 40 17 cmp %g1, %l7 2012ab4: 22 80 00 09 be,a 2012ad8 <_Timer_Server_body+0xa4> 2012ab8: c2 04 a1 04 ld [ %l2 + 0x104 ], %g1 2012abc: d2 04 20 78 ld [ %l0 + 0x78 ], %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ac0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012ac4: 90 10 00 1d mov %i5, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ac8: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012acc: 40 00 13 34 call 201779c <_Watchdog_Insert> 2012ad0: 92 02 60 48 add %o1, 0x48, %o1 2012ad4: c2 04 a1 04 ld [ %l2 + 0x104 ], %g1 _Timer_Server_reset_seconds_timer(); 2012ad8: 80 a0 40 16 cmp %g1, %l6 2012adc: 02 80 00 06 be 2012af4 <_Timer_Server_body+0xc0> 2012ae0: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012ae4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 2012ae8: c2 24 60 0c st %g1, [ %l1 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2012aec: 40 00 13 2c call 201779c <_Watchdog_Insert> <== NOT EXECUTED 2012af0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012af4: 7f ff ff c3 call 2012a00 <_Thread_Enable_dispatch> 2012af8: 01 00 00 00 nop * 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(); 2012afc: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 2012b00: 40 00 13 7f call 20178fc <_Watchdog_Remove> 2012b04: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 2012b08: 40 00 13 7d call 20178fc <_Watchdog_Remove> 2012b0c: 90 10 00 11 mov %l1, %o0 2012b10: c2 05 21 f0 ld [ %l4 + 0x1f0 ], %g1 2012b14: 82 00 60 01 inc %g1 2012b18: c2 25 21 f0 st %g1, [ %l4 + 0x1f0 ] * This ensures that the primary difference is that _ISR_Nest_level * is 0 for task-based timers and non-zero for the others. */ _Thread_Disable_dispatch(); _Timer_Server_process_ticks_chain(); 2012b1c: 7f ff ff a7 call 20129b8 <_Timer_Server_process_ticks_chain> 2012b20: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 2012b24: 7f ff ff 8d call 2012958 <_Timer_Server_process_seconds_chain> 2012b28: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2012b2c: 10 bf ff de b 2012aa4 <_Timer_Server_body+0x70> 2012b30: d0 04 20 78 ld [ %l0 + 0x78 ], %o0 020129b8 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20129b8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20129bc: c4 00 63 74 ld [ %g1 + 0x374 ], %g2 ! 2032774 <_Watchdog_Ticks_since_boot> if ( snapshot >= _Timer_Server_ticks_last_time ) 20129c0: 03 00 80 c9 sethi %hi(0x2032400), %g1 20129c4: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 ! 2032500 <_Timer_Server_ticks_last_time> 20129c8: 80 a0 80 01 cmp %g2, %g1 20129cc: 1a 80 00 04 bcc 20129dc <_Timer_Server_process_ticks_chain+0x24> 20129d0: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 20129d4: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 20129d8: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 20129dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129e0: 11 00 80 c9 sethi %hi(0x2032400), %o0 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; 20129e4: c4 20 61 00 st %g2, [ %g1 + 0x100 ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 20129e8: 90 12 20 f0 or %o0, 0xf0, %o0 20129ec: 92 10 20 00 clr %o1 20129f0: 82 13 c0 00 mov %o7, %g1 20129f4: 40 00 13 42 call 20176fc <_Watchdog_Adjust> 20129f8: 9e 10 40 00 mov %g1, %o7 20129fc: 01 00 00 00 nop 0200baa4 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200baa4: 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; 200baa8: c2 06 40 00 ld [ %i1 ], %g1 /* * 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; 200baac: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200bab0: 96 10 00 01 mov %g1, %o3 200bab4: 95 38 60 1f sra %g1, 0x1f, %o2 200bab8: 83 30 60 1d srl %g1, 0x1d, %g1 200babc: 9b 2a e0 03 sll %o3, 3, %o5 200bac0: 99 2a a0 03 sll %o2, 3, %o4 200bac4: 98 10 40 0c or %g1, %o4, %o4 200bac8: 83 33 60 1b srl %o5, 0x1b, %g1 200bacc: 85 2b 20 05 sll %o4, 5, %g2 200bad0: 87 2b 60 05 sll %o5, 5, %g3 200bad4: 84 10 40 02 or %g1, %g2, %g2 200bad8: 86 a0 c0 0d subcc %g3, %o5, %g3 200badc: 83 30 e0 1a srl %g3, 0x1a, %g1 200bae0: 84 60 80 0c subx %g2, %o4, %g2 200bae4: 9b 28 e0 06 sll %g3, 6, %o5 200bae8: 99 28 a0 06 sll %g2, 6, %o4 200baec: 9a a3 40 03 subcc %o5, %g3, %o5 200baf0: 98 10 40 0c or %g1, %o4, %o4 200baf4: 98 63 00 02 subx %o4, %g2, %o4 200baf8: 9a 83 40 0b addcc %o5, %o3, %o5 200bafc: 83 33 60 1e srl %o5, 0x1e, %g1 200bb00: 98 43 00 0a addx %o4, %o2, %o4 200bb04: 87 2b 60 02 sll %o5, 2, %g3 200bb08: 85 2b 20 02 sll %o4, 2, %g2 200bb0c: 9a 83 40 03 addcc %o5, %g3, %o5 200bb10: 84 10 40 02 or %g1, %g2, %g2 200bb14: 83 33 60 1e srl %o5, 0x1e, %g1 200bb18: 98 43 00 02 addx %o4, %g2, %o4 200bb1c: 87 2b 60 02 sll %o5, 2, %g3 200bb20: 85 2b 20 02 sll %o4, 2, %g2 200bb24: 9a 83 40 03 addcc %o5, %g3, %o5 200bb28: 84 10 40 02 or %g1, %g2, %g2 200bb2c: 83 33 60 1e srl %o5, 0x1e, %g1 200bb30: 98 43 00 02 addx %o4, %g2, %o4 200bb34: 85 2b 20 02 sll %o4, 2, %g2 200bb38: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 200bb3c: c2 06 60 04 ld [ %i1 + 4 ], %g1 * 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; 200bb40: 87 2b 60 02 sll %o5, 2, %g3 200bb44: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 200bb48: 95 38 60 1f sra %g1, 0x1f, %o2 * 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; 200bb4c: 98 43 00 02 addx %o4, %g2, %o4 200bb50: 89 33 60 17 srl %o5, 0x17, %g4 200bb54: 85 2b 20 09 sll %o4, 9, %g2 200bb58: 87 2b 60 09 sll %o5, 9, %g3 200bb5c: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 200bb60: 96 80 c0 01 addcc %g3, %g1, %o3 200bb64: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 200bb68: 80 92 80 0b orcc %o2, %o3, %g0 200bb6c: 12 80 00 06 bne 200bb84 <_Timespec_Divide+0xe0> 200bb70: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 200bb74: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200bb78: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200bb7c: 81 c7 e0 08 ret <== NOT EXECUTED 200bb80: 81 e8 00 00 restore <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200bb84: 83 36 20 1d srl %i0, 0x1d, %g1 200bb88: 9b 2e 20 03 sll %i0, 3, %o5 200bb8c: 91 3e 20 1f sra %i0, 0x1f, %o0 200bb90: 99 2a 20 03 sll %o0, 3, %o4 200bb94: 98 10 40 0c or %g1, %o4, %o4 200bb98: 83 33 60 1b srl %o5, 0x1b, %g1 200bb9c: 85 2b 20 05 sll %o4, 5, %g2 200bba0: 87 2b 60 05 sll %o5, 5, %g3 200bba4: 84 10 40 02 or %g1, %g2, %g2 200bba8: 86 a0 c0 0d subcc %g3, %o5, %g3 200bbac: 83 30 e0 1a srl %g3, 0x1a, %g1 200bbb0: 84 60 80 0c subx %g2, %o4, %g2 200bbb4: 9b 28 e0 06 sll %g3, 6, %o5 200bbb8: 99 28 a0 06 sll %g2, 6, %o4 200bbbc: 9a a3 40 03 subcc %o5, %g3, %o5 200bbc0: 98 10 40 0c or %g1, %o4, %o4 200bbc4: 98 63 00 02 subx %o4, %g2, %o4 200bbc8: 9a 83 40 18 addcc %o5, %i0, %o5 200bbcc: 83 33 60 1e srl %o5, 0x1e, %g1 200bbd0: 98 43 00 08 addx %o4, %o0, %o4 200bbd4: 87 2b 60 02 sll %o5, 2, %g3 200bbd8: 85 2b 20 02 sll %o4, 2, %g2 200bbdc: 9a 83 40 03 addcc %o5, %g3, %o5 200bbe0: 84 10 40 02 or %g1, %g2, %g2 200bbe4: 83 33 60 1e srl %o5, 0x1e, %g1 200bbe8: 98 43 00 02 addx %o4, %g2, %o4 200bbec: 87 2b 60 02 sll %o5, 2, %g3 200bbf0: 85 2b 20 02 sll %o4, 2, %g2 200bbf4: 9a 83 40 03 addcc %o5, %g3, %o5 200bbf8: 84 10 40 02 or %g1, %g2, %g2 200bbfc: 83 33 60 1e srl %o5, 0x1e, %g1 200bc00: 98 43 00 02 addx %o4, %g2, %o4 200bc04: 87 2b 60 02 sll %o5, 2, %g3 200bc08: 85 2b 20 02 sll %o4, 2, %g2 200bc0c: 9a 83 40 03 addcc %o5, %g3, %o5 200bc10: 84 10 40 02 or %g1, %g2, %g2 200bc14: 83 33 60 17 srl %o5, 0x17, %g1 200bc18: 98 43 00 02 addx %o4, %g2, %o4 200bc1c: 93 2b 60 09 sll %o5, 9, %o1 200bc20: 91 2b 20 09 sll %o4, 9, %o0 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 200bc24: 92 82 40 0f addcc %o1, %o7, %o1 /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200bc28: 90 10 40 08 or %g1, %o0, %o0 * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 200bc2c: 83 32 60 1e srl %o1, 0x1e, %g1 200bc30: a1 3b e0 1f sra %o7, 0x1f, %l0 200bc34: 87 2a 60 02 sll %o1, 2, %g3 200bc38: 90 42 00 10 addx %o0, %l0, %o0 200bc3c: 85 2a 20 02 sll %o0, 2, %g2 200bc40: 84 10 40 02 or %g1, %g2, %g2 200bc44: 83 30 e0 1b srl %g3, 0x1b, %g1 200bc48: 99 28 a0 05 sll %g2, 5, %o4 200bc4c: 9b 28 e0 05 sll %g3, 5, %o5 200bc50: 98 10 40 0c or %g1, %o4, %o4 200bc54: 9a a3 40 03 subcc %o5, %g3, %o5 200bc58: 98 63 00 02 subx %o4, %g2, %o4 200bc5c: 9a 83 40 09 addcc %o5, %o1, %o5 200bc60: 83 33 60 1e srl %o5, 0x1e, %g1 200bc64: 98 43 00 08 addx %o4, %o0, %o4 200bc68: 87 2b 60 02 sll %o5, 2, %g3 200bc6c: 85 2b 20 02 sll %o4, 2, %g2 200bc70: 9a 83 40 03 addcc %o5, %g3, %o5 200bc74: 84 10 40 02 or %g1, %g2, %g2 200bc78: 83 33 60 1e srl %o5, 0x1e, %g1 200bc7c: 87 2b 60 02 sll %o5, 2, %g3 200bc80: 98 43 00 02 addx %o4, %g2, %o4 200bc84: 9a 83 40 03 addcc %o5, %g3, %o5 200bc88: 85 2b 20 02 sll %o4, 2, %g2 200bc8c: 84 10 40 02 or %g1, %g2, %g2 200bc90: 83 33 60 1b srl %o5, 0x1b, %g1 200bc94: 98 43 00 02 addx %o4, %g2, %o4 200bc98: 93 2b 60 05 sll %o5, 5, %o1 200bc9c: 91 2b 20 05 sll %o4, 5, %o0 200bca0: 40 00 34 dd call 2019014 <__udivdi3> 200bca4: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 200bca8: 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; 200bcac: a0 10 00 08 mov %o0, %l0 200bcb0: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200bcb4: 96 10 23 e8 mov 0x3e8, %o3 200bcb8: 40 00 34 d7 call 2019014 <__udivdi3> 200bcbc: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200bcc0: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200bcc4: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200bcc8: 94 10 20 00 clr %o2 200bccc: 92 10 00 11 mov %l1, %o1 200bcd0: 40 00 35 b0 call 2019390 <__umoddi3> 200bcd4: 96 10 23 e8 mov 0x3e8, %o3 200bcd8: d2 26 c0 00 st %o1, [ %i3 ] 200bcdc: 81 c7 e0 08 ret 200bce0: 81 e8 00 00 restore 02009e68 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 2009e68: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 2009e6c: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009e70: 82 10 61 74 or %g1, 0x174, %g1 ! 2018d74 <_User_extensions_List> 2009e74: e0 00 60 08 ld [ %g1 + 8 ], %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head( Chain_Control *the_chain ) { return (Chain_Node *) the_chain; 2009e78: 10 80 00 09 b 2009e9c <_User_extensions_Fatal+0x34> 2009e7c: a2 10 00 01 mov %g1, %l1 !_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 ) 2009e80: 80 a0 60 00 cmp %g1, 0 2009e84: 02 80 00 05 be 2009e98 <_User_extensions_Fatal+0x30> 2009e88: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 2009e8c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2009e90: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009e94: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 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 ) { 2009e98: 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 ) ; 2009e9c: 80 a4 00 11 cmp %l0, %l1 2009ea0: 32 bf ff f8 bne,a 2009e80 <_User_extensions_Fatal+0x18> 2009ea4: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 2009ea8: 81 c7 e0 08 ret 2009eac: 81 e8 00 00 restore 0200e724 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 200e724: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 200e728: 40 00 13 61 call 20134ac <_Chain_Extract> <== NOT EXECUTED 200e72c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 200e730: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 200e734: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e738: 02 80 00 04 be 200e748 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 200e73c: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 200e740: 40 00 13 5b call 20134ac <_Chain_Extract> <== NOT EXECUTED 200e744: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 200e748: 81 c7 e0 08 ret <== NOT EXECUTED 200e74c: 81 e8 00 00 restore <== NOT EXECUTED 02009ef4 <_User_extensions_Thread_create>: */ boolean _User_extensions_Thread_create ( Thread_Control *the_thread ) { 2009ef4: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; 2009ef8: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009efc: e0 00 61 74 ld [ %g1 + 0x174 ], %l0 ! 2018d74 <_User_extensions_List> 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)( 2009f00: 23 00 80 62 sethi %hi(0x2018800), %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2009f04: 03 00 80 63 sethi %hi(0x2018c00), %g1 2009f08: 10 80 00 0d b 2009f3c <_User_extensions_Thread_create+0x48> 2009f0c: a4 10 61 78 or %g1, 0x178, %l2 ! 2018d78 <_User_extensions_List+0x4> !_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 ) { 2009f10: 80 a0 60 00 cmp %g1, 0 2009f14: 02 80 00 09 be 2009f38 <_User_extensions_Thread_create+0x44> 2009f18: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 2009f1c: 9f c0 40 00 call %g1 2009f20: d0 04 63 d0 ld [ %l1 + 0x3d0 ], %o0 _Thread_Executing, the_thread ); if ( !status ) 2009f24: 80 a2 20 00 cmp %o0, 0 2009f28: 32 80 00 05 bne,a 2009f3c <_User_extensions_Thread_create+0x48> 2009f2c: e0 04 00 00 ld [ %l0 ], %l0 2009f30: 81 c7 e0 08 ret <== NOT EXECUTED 2009f34: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 2009f38: e0 04 00 00 ld [ %l0 ], %l0 Chain_Node *the_node; User_extensions_Control *the_extension; boolean status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 2009f3c: 80 a4 00 12 cmp %l0, %l2 2009f40: 32 bf ff f4 bne,a 2009f10 <_User_extensions_Thread_create+0x1c> 2009f44: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 2009f48: 81 c7 e0 08 ret 2009f4c: 91 e8 20 01 restore %g0, 1, %o0 0200a020 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a020: 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; 200a024: 03 00 80 62 sethi %hi(0x2018800), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a028: aa 10 00 18 mov %i0, %l5 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 200a02c: e6 00 63 b8 ld [ %g1 + 0x3b8 ], %l3 _ISR_Disable( level ); 200a030: 7f ff df 4b call 2001d5c 200a034: 01 00 00 00 nop 200a038: 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 ) { 200a03c: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a040: 80 a0 60 00 cmp %g1, 0 200a044: 02 80 00 03 be 200a050 <_Watchdog_Insert+0x30> 200a048: 03 00 80 63 sethi %hi(0x2018c00), %g1 _ISR_Enable( level ); 200a04c: 30 80 00 37 b,a 200a128 <_Watchdog_Insert+0x108> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 200a050: c4 00 60 70 ld [ %g1 + 0x70 ], %g2 ! 2018c70 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a054: 86 10 20 01 mov 1, %g3 _Watchdog_Sync_count++; 200a058: 84 00 a0 01 inc %g2 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a05c: c6 26 60 08 st %g3, [ %i1 + 8 ] _Watchdog_Sync_count++; 200a060: c4 20 60 70 st %g2, [ %g1 + 0x70 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a064: 29 00 80 62 sethi %hi(0x2018800), %l4 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a068: 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 ; 200a06c: e2 05 40 00 ld [ %l5 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a070: 80 a4 a0 00 cmp %l2, 0 200a074: 22 80 00 1c be,a 200a0e4 <_Watchdog_Insert+0xc4> 200a078: c4 04 60 04 ld [ %l1 + 4 ], %g2 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200a07c: c2 04 40 00 ld [ %l1 ], %g1 200a080: 80 a0 60 00 cmp %g1, 0 200a084: 22 80 00 18 be,a 200a0e4 <_Watchdog_Insert+0xc4> 200a088: c4 04 60 04 ld [ %l1 + 4 ], %g2 break; if ( delta_interval < after->delta_interval ) { 200a08c: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a090: 80 a4 80 10 cmp %l2, %l0 200a094: 1a 80 00 04 bcc 200a0a4 <_Watchdog_Insert+0x84> 200a098: 82 24 00 12 sub %l0, %l2, %g1 after->delta_interval -= delta_interval; 200a09c: 10 80 00 11 b 200a0e0 <_Watchdog_Insert+0xc0> 200a0a0: c2 24 60 10 st %g1, [ %l1 + 0x10 ] * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 200a0a4: 7f ff df 32 call 2001d6c 200a0a8: 90 10 00 18 mov %i0, %o0 200a0ac: 7f ff df 2c call 2001d5c 200a0b0: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 200a0b4: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a0b8: 80 a0 60 01 cmp %g1, 1 200a0bc: 12 80 00 15 bne 200a110 <_Watchdog_Insert+0xf0> 200a0c0: a4 24 80 10 sub %l2, %l0, %l2 goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a0c4: c2 05 23 cc ld [ %l4 + 0x3cc ], %g1 200a0c8: 80 a0 40 13 cmp %g1, %l3 200a0cc: 28 bf ff e9 bleu,a 200a070 <_Watchdog_Insert+0x50> 200a0d0: e2 04 40 00 ld [ %l1 ], %l1 _Watchdog_Sync_level = insert_isr_nest_level; 200a0d4: e6 25 23 cc st %l3, [ %l4 + 0x3cc ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a0d8: 10 bf ff e5 b 200a06c <_Watchdog_Insert+0x4c> 200a0dc: e4 06 60 0c ld [ %i1 + 0xc ], %l2 _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 200a0e0: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a0e4: 03 00 80 63 sethi %hi(0x2018c00), %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200a0e8: c6 00 80 00 ld [ %g2 ], %g3 200a0ec: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 after_node->next = the_node; 200a0f0: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200a0f4: c4 26 60 04 st %g2, [ %i1 + 4 ] 200a0f8: c2 26 60 14 st %g1, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 200a0fc: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 200a100: 82 10 20 02 mov 2, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 200a104: f2 20 e0 04 st %i1, [ %g3 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 200a108: c6 26 40 00 st %g3, [ %i1 ] 200a10c: c2 26 60 08 st %g1, [ %i1 + 8 ] _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a110: 03 00 80 62 sethi %hi(0x2018800), %g1 _Watchdog_Sync_count--; 200a114: 05 00 80 63 sethi %hi(0x2018c00), %g2 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a118: e6 20 63 cc st %l3, [ %g1 + 0x3cc ] _Watchdog_Sync_count--; 200a11c: c2 00 a0 70 ld [ %g2 + 0x70 ], %g1 200a120: 82 00 7f ff add %g1, -1, %g1 200a124: c2 20 a0 70 st %g1, [ %g2 + 0x70 ] _ISR_Enable( level ); 200a128: 7f ff df 11 call 2001d6c 200a12c: 81 e8 00 00 restore 200a130: 01 00 00 00 nop 0200af50 <_Watchdog_Insert_ticks_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 200af50: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 200af54: 40 00 17 37 call 2010c30 <_Watchdog_Remove> 200af58: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200af5c: 7f ff ed ca call 2006684 200af60: 01 00 00 00 nop 200af64: a0 10 00 08 mov %o0, %l0 /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 200af68: c2 06 20 08 ld [ %i0 + 8 ], %g1 200af6c: 80 a0 60 00 cmp %g1, 0 200af70: 22 80 00 06 be,a 200af88 <_Watchdog_Insert_ticks_helper+0x38> 200af74: f6 26 20 1c st %i3, [ %i0 + 0x1c ] _ISR_Enable( level ); 200af78: 7f ff ed c7 call 2006694 <== NOT EXECUTED 200af7c: b0 10 20 00 clr %i0 <== NOT EXECUTED 200af80: 81 c7 e0 08 ret <== NOT EXECUTED 200af84: 81 e8 00 00 restore <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200af88: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 200af8c: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200af90: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200af94: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200af98: 92 10 00 18 mov %i0, %o1 200af9c: 11 00 80 8e sethi %hi(0x2023800), %o0 200afa0: 40 00 16 cc call 2010ad0 <_Watchdog_Insert> 200afa4: 90 12 22 50 or %o0, 0x250, %o0 ! 2023a50 <_Watchdog_Ticks_chain> * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 200afa8: b0 10 20 01 mov 1, %i0 200afac: 7f ff ed ba call 2006694 200afb0: 90 10 00 10 mov %l0, %o0 return TRUE; } 200afb4: 81 c7 e0 08 ret 200afb8: 81 e8 00 00 restore 0200a180 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200a180: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200a184: 7f ff de f6 call 2001d5c 200a188: 01 00 00 00 nop previous_state = the_watchdog->state; 200a18c: e0 06 20 08 ld [ %i0 + 8 ], %l0 switch ( previous_state ) { 200a190: 80 a4 20 01 cmp %l0, 1 200a194: 22 80 00 1e be,a 200a20c <_Watchdog_Remove+0x8c> 200a198: c0 26 20 08 clr [ %i0 + 8 ] <== NOT EXECUTED 200a19c: 0a 80 00 1d bcs 200a210 <_Watchdog_Remove+0x90> 200a1a0: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a1a4: 80 a4 20 03 cmp %l0, 3 200a1a8: 18 80 00 1a bgu 200a210 <_Watchdog_Remove+0x90> 200a1ac: 01 00 00 00 nop 200a1b0: c6 06 00 00 ld [ %i0 ], %g3 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200a1b4: c0 26 20 08 clr [ %i0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200a1b8: c2 00 c0 00 ld [ %g3 ], %g1 200a1bc: 80 a0 60 00 cmp %g1, 0 200a1c0: 02 80 00 07 be 200a1dc <_Watchdog_Remove+0x5c> 200a1c4: 03 00 80 63 sethi %hi(0x2018c00), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 200a1c8: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1 200a1cc: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 200a1d0: 82 00 40 02 add %g1, %g2, %g1 200a1d4: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] if ( _Watchdog_Sync_count ) 200a1d8: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a1dc: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 ! 2018c70 <_Watchdog_Sync_count> 200a1e0: 80 a0 60 00 cmp %g1, 0 200a1e4: 22 80 00 07 be,a 200a200 <_Watchdog_Remove+0x80> 200a1e8: c4 06 00 00 ld [ %i0 ], %g2 _Watchdog_Sync_level = _ISR_Nest_level; 200a1ec: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a1f0: c4 00 63 b8 ld [ %g1 + 0x3b8 ], %g2 ! 2018bb8 <_ISR_Nest_level> <== NOT EXECUTED 200a1f4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a1f8: c4 20 63 cc st %g2, [ %g1 + 0x3cc ] ! 2018bcc <_Watchdog_Sync_level> <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200a1fc: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 200a200: c2 06 20 04 ld [ %i0 + 4 ], %g1 next->previous = previous; previous->next = next; 200a204: c4 20 40 00 st %g2, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a208: c2 20 a0 04 st %g1, [ %g2 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a20c: 03 00 80 63 sethi %hi(0x2018c00), %g1 200a210: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2018c74 <_Watchdog_Ticks_since_boot> 200a214: c2 26 20 18 st %g1, [ %i0 + 0x18 ] _ISR_Enable( level ); 200a218: 7f ff de d5 call 2001d6c 200a21c: b0 10 00 10 mov %l0, %i0 return( previous_state ); } 200a220: 81 c7 e0 08 ret 200a224: 81 e8 00 00 restore 0200a2cc <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 200a2cc: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200a2d0: 11 00 80 62 sethi %hi(0x2018800), %o0 200a2d4: 92 10 00 18 mov %i0, %o1 200a2d8: 7f ff f2 a0 call 2006d58 <_Heap_Allocate> 200a2dc: 90 12 23 3c or %o0, 0x33c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 200a2e0: b0 92 20 00 orcc %o0, 0, %i0 200a2e4: 12 80 00 04 bne 200a2f4 <_Workspace_Allocate_or_fatal_error+0x28> 200a2e8: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 200a2ec: 7f ff f3 c6 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a2f0: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 200a2f4: 81 c7 e0 08 ret 200a2f8: 81 e8 00 00 restore 0200a2fc <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 200a2fc: 9d e3 bf 98 save %sp, -104, %sp uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 200a300: 80 a6 20 00 cmp %i0, 0 200a304: 02 80 00 04 be 200a314 <_Workspace_Handler_initialization+0x18> 200a308: 80 8e 20 07 btst 7, %i0 200a30c: 02 80 00 07 be 200a328 <_Workspace_Handler_initialization+0x2c> 200a310: 03 00 80 62 sethi %hi(0x2018800), %g1 _Internal_error_Occurred( 200a314: 90 10 20 00 clr %o0 <== NOT EXECUTED 200a318: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200a31c: 7f ff f3 ba call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a320: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 200a324: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 200a328: c2 00 63 14 ld [ %g1 + 0x314 ], %g1 ! 2018b14 <_CPU_Table+0x10> 200a32c: 84 10 20 00 clr %g2 200a330: 80 a0 60 00 cmp %g1, 0 200a334: 12 80 00 06 bne 200a34c <_Workspace_Handler_initialization+0x50> 200a338: 87 36 60 02 srl %i1, 2, %g3 index < size / sizeof( uint32_t ) ; index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a33c: 10 80 00 08 b 200a35c <_Workspace_Handler_initialization+0x60> 200a340: 92 10 00 18 mov %i0, %o1 ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 200a344: 84 00 a0 01 inc %g2 <== NOT EXECUTED zero_out_array[ index ] = 0; 200a348: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 200a34c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200a350: 0a bf ff fd bcs 200a344 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED 200a354: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200a358: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200a35c: 94 10 00 19 mov %i1, %o2 200a360: 11 00 80 62 sethi %hi(0x2018800), %o0 200a364: 96 10 20 08 mov 8, %o3 200a368: 7f ff f3 5d call 20070dc <_Heap_Initialize> 200a36c: 90 12 23 3c or %o0, 0x33c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 200a370: 80 a2 20 00 cmp %o0, 0 200a374: 12 80 00 05 bne 200a388 <_Workspace_Handler_initialization+0x8c> 200a378: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200a37c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 200a380: 7f ff f3 a1 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200a384: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 200a388: 81 c7 e0 08 ret 200a38c: 81 e8 00 00 restore 0201620c <_exit>: #include #if !defined(RTEMS_UNIX) void _exit(int status) { 201620c: 9d e3 bf 98 save %sp, -104, %sp * 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(); 2016210: 7f ff ff e4 call 20161a0 2016214: 01 00 00 00 nop rtems_shutdown_executive(status); 2016218: 40 00 00 47 call 2016334 201621c: 90 10 00 18 mov %i0, %o0 2016220: 30 80 00 00 b,a 2016220 <_exit+0x14> <== NOT EXECUTED 0201f8f0 <_fcntl_r>: int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 201f8f0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 201f8f4: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 201f8f8: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED 201f8fc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 201f900: 7f ff ff 78 call 201f6e0 <== NOT EXECUTED 201f904: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 201f908: 01 00 00 00 nop 02020bc0 <_getpid_r>: pid_t _getpid_r( struct _reent *ptr ) { return getpid(); } 2020bc0: 81 c3 e0 08 retl <== NOT EXECUTED 2020bc4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 0200ba24 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 200ba24: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200ba28: 7f ff ff e6 call 200b9c0 <== NOT EXECUTED 200ba2c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 200ba30: 01 00 00 00 nop 02020e3c <_kill_r>: struct _reent *ptr, pid_t pid, int sig ) { return kill( pid, sig ); 2020e3c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2020e40: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2020e44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2020e48: 7f ff ff f8 call 2020e28 <== NOT EXECUTED 2020e4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2020e50: 01 00 00 00 nop 02003a70 <_link_r>: struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 2003a70: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2003a74: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2003a78: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2003a7c: 7f ff ff 65 call 2003810 <== NOT EXECUTED 2003a80: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2003a84: 01 00 00 00 nop 020024dc <_realloc_r>: struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 20024dc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 20024e0: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 20024e4: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20024e8: 7f ff ff b8 call 20023c8 <== NOT EXECUTED 20024ec: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20024f0: 01 00 00 00 nop 020054c4 <_stat_r>: struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 20054c4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 20054c8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 20054cc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20054d0: 7f ff ff c4 call 20053e0 <== NOT EXECUTED 20054d4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20054d8: 01 00 00 00 nop 02016df4 <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) { return unlink( path ); 2016df4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2016df8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2016dfc: 7f ff ff a2 call 2016c84 <== NOT EXECUTED 2016e00: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2016e04: 01 00 00 00 nop 02005184 : int alphasort(d1, d2) const void *d1; const void *d2; { return(strcmp((*(struct dirent **)d1)->d_name, 2005184: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 2005188: d2 02 40 00 ld [ %o1 ], %o1 <== NOT EXECUTED 200518c: 90 02 20 0c add %o0, 0xc, %o0 <== NOT EXECUTED 2005190: 92 02 60 0c add %o1, 0xc, %o1 <== NOT EXECUTED 2005194: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005198: 40 00 36 77 call 2012b74 <== NOT EXECUTED 200519c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20051a0: 01 00 00 00 nop 02014fc8 : #include int chdir( const char *pathname ) { 2014fc8: 9d e3 bf 88 save %sp, -120, %sp /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 2014fcc: 92 10 20 01 mov 1, %o1 2014fd0: 90 10 00 18 mov %i0, %o0 2014fd4: a0 07 bf e8 add %fp, -24, %l0 2014fd8: 96 10 20 01 mov 1, %o3 2014fdc: 94 10 00 10 mov %l0, %o2 2014fe0: 7f ff bb 2d call 2003c94 2014fe4: b0 10 3f ff mov -1, %i0 pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, TRUE ); if ( result != 0 ) 2014fe8: 80 a2 20 00 cmp %o0, 0 2014fec: 12 80 00 37 bne 20150c8 2014ff0: c4 07 bf f0 ld [ %fp + -16 ], %g2 /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 2014ff4: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2014ff8: 80 a0 60 00 cmp %g1, 0 2014ffc: 12 80 00 0c bne 201502c 2015000: 01 00 00 00 nop rtems_filesystem_freenode( &loc ); 2015004: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2015008: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201500c: 02 80 00 04 be 201501c <== NOT EXECUTED 2015010: 01 00 00 00 nop <== NOT EXECUTED 2015014: 9f c0 40 00 call %g1 <== NOT EXECUTED 2015018: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 201501c: 40 00 33 58 call 2021d7c <__errno> <== NOT EXECUTED 2015020: 01 00 00 00 nop <== NOT EXECUTED 2015024: 10 80 00 14 b 2015074 <== NOT EXECUTED 2015028: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 201502c: 9f c0 40 00 call %g1 2015030: 90 10 00 10 mov %l0, %o0 2015034: 80 a2 20 01 cmp %o0, 1 2015038: 02 80 00 12 be 2015080 201503c: 03 00 80 dd sethi %hi(0x2037400), %g1 rtems_filesystem_freenode( &loc ); 2015040: c2 07 bf f0 ld [ %fp + -16 ], %g1 2015044: 80 a0 60 00 cmp %g1, 0 2015048: 02 80 00 08 be 2015068 201504c: 01 00 00 00 nop 2015050: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2015054: 80 a0 60 00 cmp %g1, 0 2015058: 02 80 00 04 be 2015068 201505c: 01 00 00 00 nop 2015060: 9f c0 40 00 call %g1 2015064: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 2015068: 40 00 33 45 call 2021d7c <__errno> 201506c: 01 00 00 00 nop 2015070: 82 10 20 14 mov 0x14, %g1 ! 14 2015074: c2 22 00 00 st %g1, [ %o0 ] 2015078: 81 c7 e0 08 ret 201507c: 91 e8 3f ff restore %g0, -1, %o0 } rtems_filesystem_freenode( &rtems_filesystem_current ); 2015080: d0 00 63 10 ld [ %g1 + 0x310 ], %o0 2015084: c2 02 20 0c ld [ %o0 + 0xc ], %g1 2015088: 80 a0 60 00 cmp %g1, 0 201508c: 22 80 00 09 be,a 20150b0 2015090: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2015094: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 ! 203741c 2015098: 80 a0 60 00 cmp %g1, 0 201509c: 22 80 00 05 be,a 20150b0 20150a0: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 20150a4: 9f c0 40 00 call %g1 20150a8: 90 02 20 04 add %o0, 4, %o0 rtems_filesystem_current = loc; 20150ac: 03 00 80 dd sethi %hi(0x2037400), %g1 20150b0: d0 00 63 10 ld [ %g1 + 0x310 ], %o0 ! 2037710 20150b4: 92 07 bf e8 add %fp, -24, %o1 20150b8: 90 02 20 04 add %o0, 4, %o0 20150bc: 94 10 20 10 mov 0x10, %o2 20150c0: 40 00 39 e3 call 202384c 20150c4: b0 10 20 00 clr %i0 return 0; } 20150c8: 81 c7 e0 08 ret 20150cc: 81 e8 00 00 restore 020150d0 : int chmod( const char *path, mode_t mode ) { 20150d0: 9d e3 bf 88 save %sp, -120, %sp int status; rtems_filesystem_location_info_t loc; int result; status = rtems_filesystem_evaluate_path( path, 0, &loc, TRUE ); 20150d4: 92 10 20 00 clr %o1 20150d8: 90 10 00 18 mov %i0, %o0 20150dc: a0 07 bf e8 add %fp, -24, %l0 20150e0: 96 10 20 01 mov 1, %o3 20150e4: 94 10 00 10 mov %l0, %o2 20150e8: 7f ff ba eb call 2003c94 20150ec: b0 10 3f ff mov -1, %i0 if ( status != 0 ) 20150f0: 80 a2 20 00 cmp %o0, 0 20150f4: 12 80 00 24 bne 2015184 20150f8: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !loc.handlers ){ 20150fc: 80 a0 60 00 cmp %g1, 0 2015100: 32 80 00 10 bne,a 2015140 2015104: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 rtems_filesystem_freenode( &loc ); 2015108: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 201510c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015110: 02 80 00 08 be 2015130 <== NOT EXECUTED 2015114: 01 00 00 00 nop <== NOT EXECUTED 2015118: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 201511c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015120: 02 80 00 04 be 2015130 <== NOT EXECUTED 2015124: 01 00 00 00 nop <== NOT EXECUTED 2015128: 9f c0 40 00 call %g1 <== NOT EXECUTED 201512c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 2015130: 40 00 33 13 call 2021d7c <__errno> <== NOT EXECUTED 2015134: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2015138: 10 80 00 12 b 2015180 <== NOT EXECUTED 201513c: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED } if ( !loc.handlers->fchmod_h ){ 2015140: 80 a0 60 00 cmp %g1, 0 2015144: 12 80 00 12 bne 201518c 2015148: 93 2e 60 10 sll %i1, 0x10, %o1 rtems_filesystem_freenode( &loc ); 201514c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2015150: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015154: 02 80 00 08 be 2015174 <== NOT EXECUTED 2015158: 01 00 00 00 nop <== NOT EXECUTED 201515c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2015160: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015164: 02 80 00 04 be 2015174 <== NOT EXECUTED 2015168: 01 00 00 00 nop <== NOT EXECUTED 201516c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2015170: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2015174: 40 00 33 02 call 2021d7c <__errno> <== NOT EXECUTED 2015178: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201517c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2015180: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2015184: 81 c7 e0 08 ret 2015188: 81 e8 00 00 restore } result = (*loc.handlers->fchmod_h)( &loc, mode ); 201518c: 90 10 00 10 mov %l0, %o0 2015190: 9f c0 40 00 call %g1 2015194: 93 32 60 10 srl %o1, 0x10, %o1 rtems_filesystem_freenode( &loc ); 2015198: c2 07 bf f0 ld [ %fp + -16 ], %g1 201519c: 80 a0 60 00 cmp %g1, 0 20151a0: 02 bf ff f9 be 2015184 20151a4: b0 10 00 08 mov %o0, %i0 20151a8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20151ac: 80 a0 60 00 cmp %g1, 0 20151b0: 02 80 00 04 be 20151c0 20151b4: 01 00 00 00 nop 20151b8: 9f c0 40 00 call %g1 20151bc: 90 10 00 10 mov %l0, %o0 return result; } 20151c0: 81 c7 e0 08 ret 20151c4: 81 e8 00 00 restore 020151c8 : int chown( const char *path, uid_t owner, gid_t group ) { 20151c8: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, TRUE ) ) 20151cc: 92 10 20 00 clr %o1 20151d0: 90 10 00 18 mov %i0, %o0 20151d4: a0 07 bf e8 add %fp, -24, %l0 20151d8: 96 10 20 01 mov 1, %o3 20151dc: 94 10 00 10 mov %l0, %o2 20151e0: 7f ff ba ad call 2003c94 20151e4: b0 10 3f ff mov -1, %i0 20151e8: 80 a2 20 00 cmp %o0, 0 20151ec: 12 80 00 10 bne 201522c 20151f0: c2 07 bf f0 ld [ %fp + -16 ], %g1 return -1; if ( !loc.ops->chown_h ) { 20151f4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 20151f8: 80 a0 a0 00 cmp %g2, 0 20151fc: 12 80 00 0e bne 2015234 2015200: 93 2e 60 10 sll %i1, 0x10, %o1 rtems_filesystem_freenode( &loc ); 2015204: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2015208: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201520c: 02 80 00 04 be 201521c <== NOT EXECUTED 2015210: 01 00 00 00 nop <== NOT EXECUTED 2015214: 9f c0 40 00 call %g1 <== NOT EXECUTED 2015218: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 201521c: 40 00 32 d8 call 2021d7c <__errno> <== NOT EXECUTED 2015220: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2015224: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2015228: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201522c: 81 c7 e0 08 ret 2015230: 81 e8 00 00 restore } result = (*loc.ops->chown_h)( &loc, owner, group ); 2015234: 95 2e a0 10 sll %i2, 0x10, %o2 2015238: 93 32 60 10 srl %o1, 0x10, %o1 201523c: 95 32 a0 10 srl %o2, 0x10, %o2 2015240: 9f c0 80 00 call %g2 2015244: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2015248: c2 07 bf f0 ld [ %fp + -16 ], %g1 201524c: 80 a0 60 00 cmp %g1, 0 2015250: 02 bf ff f7 be 201522c 2015254: b0 10 00 08 mov %o0, %i0 2015258: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 201525c: 80 a0 60 00 cmp %g1, 0 2015260: 02 80 00 04 be 2015270 2015264: 01 00 00 00 nop 2015268: 9f c0 40 00 call %g1 201526c: 90 10 00 10 mov %l0, %o0 return result; } 2015270: 81 c7 e0 08 ret 2015274: 81 e8 00 00 restore 02015278 : #include int chroot( const char *pathname ) { 2015278: 9d e3 bf 88 save %sp, -120, %sp int result; rtems_filesystem_location_info_t loc; /* an automatic call to new private env the first time */ if (rtems_current_user_env == &rtems_global_user_env) { 201527c: 23 00 80 dd sethi %hi(0x2037400), %l1 2015280: e0 04 63 10 ld [ %l1 + 0x310 ], %l0 ! 2037710 2015284: 03 00 80 e8 sethi %hi(0x203a000), %g1 2015288: 82 10 61 94 or %g1, 0x194, %g1 ! 203a194 201528c: 80 a4 00 01 cmp %l0, %g1 2015290: 12 80 00 0e bne 20152c8 2015294: 01 00 00 00 nop rtems_libio_set_private_env(); /* try to set a new private env*/ 2015298: 40 00 05 39 call 201677c 201529c: 01 00 00 00 nop if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 20152a0: c2 04 63 10 ld [ %l1 + 0x310 ], %g1 20152a4: 80 a0 40 10 cmp %g1, %l0 20152a8: 12 80 00 08 bne 20152c8 20152ac: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 20152b0: 40 00 32 b3 call 2021d7c <__errno> <== NOT EXECUTED 20152b4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 20152b8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 20152bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20152c0: 81 c7 e0 08 ret <== NOT EXECUTED 20152c4: 81 e8 00 00 restore <== NOT EXECUTED }; result = chdir(pathname); 20152c8: 7f ff ff 40 call 2014fc8 20152cc: 90 10 00 18 mov %i0, %o0 if (result) { 20152d0: 80 a2 20 00 cmp %o0, 0 20152d4: 12 80 00 0a bne 20152fc 20152d8: 11 00 80 cf sethi %hi(0x2033c00), %o0 rtems_set_errno_and_return_minus_one( errno ); }; /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 20152dc: 92 10 20 00 clr %o1 20152e0: 90 12 22 30 or %o0, 0x230, %o0 20152e4: 94 07 bf e8 add %fp, -24, %o2 20152e8: 7f ff ba 6b call 2003c94 20152ec: 96 10 20 00 clr %o3 20152f0: 80 a2 20 00 cmp %o0, 0 20152f4: 02 80 00 0a be 201531c 20152f8: 03 00 80 dd sethi %hi(0x2037400), %g1 /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); 20152fc: 40 00 32 a0 call 2021d7c <__errno> <== NOT EXECUTED 2015300: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2015304: 40 00 32 9e call 2021d7c <__errno> <== NOT EXECUTED 2015308: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 201530c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2015310: c2 24 00 00 st %g1, [ %l0 ] <== NOT EXECUTED 2015314: 81 c7 e0 08 ret <== NOT EXECUTED 2015318: 81 e8 00 00 restore <== NOT EXECUTED } rtems_filesystem_freenode(&rtems_filesystem_root); 201531c: d0 00 63 10 ld [ %g1 + 0x310 ], %o0 2015320: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2015324: 80 a0 60 00 cmp %g1, 0 2015328: 22 80 00 09 be,a 201534c 201532c: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2015330: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 ! 203741c 2015334: 80 a0 60 00 cmp %g1, 0 2015338: 22 80 00 05 be,a 201534c 201533c: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2015340: 9f c0 40 00 call %g1 2015344: 90 02 20 14 add %o0, 0x14, %o0 rtems_filesystem_root = loc; 2015348: 03 00 80 dd sethi %hi(0x2037400), %g1 201534c: d0 00 63 10 ld [ %g1 + 0x310 ], %o0 ! 2037710 2015350: 92 07 bf e8 add %fp, -24, %o1 2015354: 94 10 20 10 mov 0x10, %o2 2015358: 90 02 20 14 add %o0, 0x14, %o0 201535c: 40 00 39 3c call 202384c 2015360: b0 10 20 00 clr %i0 return 0; } 2015364: 81 c7 e0 08 ret 2015368: 81 e8 00 00 restore 02005dc4 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 2005dc4: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2005dc8: 90 96 60 00 orcc %i1, 0, %o0 2005dcc: 12 80 00 08 bne 2005dec 2005dd0: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); 2005dd4: 40 00 27 fa call 200fdbc <__errno> <== NOT EXECUTED 2005dd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005ddc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005de0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2005de4: 81 c7 e0 08 ret <== NOT EXECUTED 2005de8: 81 e8 00 00 restore <== NOT EXECUTED switch ( clock_id ) { 2005dec: 02 80 00 10 be 2005e2c 2005df0: 80 a6 20 02 cmp %i0, 2 2005df4: 18 80 00 06 bgu 2005e0c 2005df8: 80 a6 20 03 cmp %i0, 3 2005dfc: 80 a6 20 01 cmp %i0, 1 2005e00: 12 80 00 11 bne 2005e44 2005e04: 01 00 00 00 nop 2005e08: 30 80 00 06 b,a 2005e20 2005e0c: 02 80 00 0c be 2005e3c <== NOT EXECUTED 2005e10: 80 a6 20 04 cmp %i0, 4 <== NOT EXECUTED 2005e14: 12 80 00 0c bne 2005e44 <== NOT EXECUTED 2005e18: 01 00 00 00 nop <== NOT EXECUTED 2005e1c: 30 80 00 04 b,a 2005e2c <== NOT EXECUTED case CLOCK_REALTIME: _TOD_Get(tp); 2005e20: 40 00 0a b7 call 20088fc <_TOD_Get> 2005e24: b0 10 20 00 clr %i0 2005e28: 30 80 00 0b b,a 2005e54 break; #endif #ifdef _POSIX_CPUTIME case CLOCK_PROCESS_CPUTIME: _TOD_Get_uptime(tp); 2005e2c: 40 00 0a cd call 2008960 <_TOD_Get_uptime> <== NOT EXECUTED 2005e30: b0 10 20 00 clr %i0 <== NOT EXECUTED 2005e34: 81 c7 e0 08 ret <== NOT EXECUTED 2005e38: 81 e8 00 00 restore <== NOT EXECUTED break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 2005e3c: 40 00 02 fb call 2006a28 <== NOT EXECUTED 2005e40: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 2005e44: 40 00 27 de call 200fdbc <__errno> <== NOT EXECUTED 2005e48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005e4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005e50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return 0; } 2005e54: 81 c7 e0 08 ret 2005e58: 81 e8 00 00 restore 02005e5c : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 2005e5c: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2005e60: 90 96 60 00 orcc %i1, 0, %o0 2005e64: 02 80 00 0d be 2005e98 2005e68: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 2005e6c: 02 80 00 22 be 2005ef4 2005e70: 80 a6 20 03 cmp %i0, 3 2005e74: 02 80 00 20 be 2005ef4 2005e78: 80 a6 20 01 cmp %i0, 1 2005e7c: 12 80 00 20 bne 2005efc 2005e80: 03 08 76 b9 sethi %hi(0x21dae400), %g1 case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 2005e84: c4 02 00 00 ld [ %o0 ], %g2 2005e88: 82 10 60 ff or %g1, 0xff, %g1 2005e8c: 80 a0 80 01 cmp %g2, %g1 2005e90: 18 80 00 08 bgu 2005eb0 2005e94: 21 00 80 72 sethi %hi(0x201c800), %l0 rtems_set_errno_and_return_minus_one( EINVAL ); 2005e98: 40 00 27 c9 call 200fdbc <__errno> <== NOT EXECUTED 2005e9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005ea0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2005ea4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2005ea8: 81 c7 e0 08 ret <== NOT EXECUTED 2005eac: 81 e8 00 00 restore <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005eb0: c2 04 20 00 ld [ %l0 ], %g1 2005eb4: 82 00 60 01 inc %g1 2005eb8: c2 24 20 00 st %g1, [ %l0 ] _Thread_Disable_dispatch(); _TOD_Set( tp ); 2005ebc: 40 00 0a d9 call 2008a20 <_TOD_Set> 2005ec0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005ec4: c2 04 20 00 ld [ %l0 ], %g1 2005ec8: b0 10 20 00 clr %i0 2005ecc: 82 00 7f ff add %g1, -1, %g1 2005ed0: c2 24 20 00 st %g1, [ %l0 ] 2005ed4: c2 04 20 00 ld [ %l0 ], %g1 2005ed8: 80 a0 60 00 cmp %g1, 0 2005edc: 12 80 00 0c bne 2005f0c 2005ee0: 01 00 00 00 nop _Thread_Dispatch(); 2005ee4: 40 00 12 79 call 200a8c8 <_Thread_Dispatch> 2005ee8: 01 00 00 00 nop 2005eec: 81 c7 e0 08 ret 2005ef0: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 2005ef4: 40 00 02 cd call 2006a28 <== NOT EXECUTED 2005ef8: 81 e8 00 00 restore <== NOT EXECUTED break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 2005efc: 40 00 27 b0 call 200fdbc <__errno> 2005f00: b0 10 3f ff mov -1, %i0 2005f04: 82 10 20 16 mov 0x16, %g1 2005f08: c2 22 00 00 st %g1, [ %o0 ] } return 0; } 2005f0c: 81 c7 e0 08 ret 2005f10: 81 e8 00 00 restore 0201536c : * close a directory. */ int closedir(dirp) register DIR *dirp; { 201536c: 9d e3 bf 98 save %sp, -104, %sp int fd; if ( !dirp ) 2015370: a0 96 20 00 orcc %i0, 0, %l0 2015374: 02 80 00 0b be 20153a0 2015378: 82 10 3f ff mov -1, %g1 rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); 201537c: d0 04 20 0c ld [ %l0 + 0xc ], %o0 int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 2015380: f0 04 00 00 ld [ %l0 ], %i0 dirp->dd_fd = -1; dirp->dd_loc = 0; 2015384: c0 24 20 04 clr [ %l0 + 4 ] (void)free((void *)dirp->dd_buf); 2015388: 7f ff bb a2 call 2004210 201538c: c2 24 00 00 st %g1, [ %l0 ] (void)free((void *)dirp); 2015390: 7f ff bb a0 call 2004210 2015394: 90 10 00 10 mov %l0, %o0 return(close(fd)); 2015398: 7f ff b9 e0 call 2003b18 201539c: 81 e8 00 00 restore register DIR *dirp; { int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 20153a0: 40 00 32 77 call 2021d7c <__errno> <== NOT EXECUTED 20153a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20153a8: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 20153ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); } 20153b0: 81 c7 e0 08 ret <== NOT EXECUTED 20153b4: 81 e8 00 00 restore <== NOT EXECUTED 0200d6bc : */ int device_close( rtems_libio_t *iop ) { 200d6bc: 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; 200d6c0: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 args.iop = iop; 200d6c4: f0 27 bf ec st %i0, [ %fp + -20 ] args.flags = 0; 200d6c8: c0 27 bf f0 clr [ %fp + -16 ] args.mode = 0; 200d6cc: c0 27 bf f4 clr [ %fp + -12 ] status = rtems_io_close( 200d6d0: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 200d6d4: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 200d6d8: 94 07 bf ec add %fp, -20, %o2 200d6dc: 40 00 02 1e call 200df54 200d6e0: b0 10 20 00 clr %i0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 200d6e4: 80 a2 20 00 cmp %o0, 0 200d6e8: 02 80 00 05 be 200d6fc 200d6ec: 01 00 00 00 nop return rtems_deviceio_errno(status); 200d6f0: 7f ff ff a3 call 200d57c <== NOT EXECUTED 200d6f4: 01 00 00 00 nop <== NOT EXECUTED 200d6f8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } return 0; } 200d6fc: 81 c7 e0 08 ret 200d700: 81 e8 00 00 restore 0200d5b0 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 200d5b0: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED args.iop = iop; args.command = command; args.buffer = buffer; the_jnode = iop->file_info; 200d5b4: 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; 200d5b8: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED args.buffer = buffer; 200d5bc: 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; 200d5c0: 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( 200d5c4: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 <== NOT EXECUTED 200d5c8: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 <== NOT EXECUTED 200d5cc: 40 00 02 78 call 200dfac <== NOT EXECUTED 200d5d0: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200d5d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200d5d8: 22 80 00 06 be,a 200d5f0 <== NOT EXECUTED 200d5dc: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED return rtems_deviceio_errno(status); 200d5e0: 7f ff ff e7 call 200d57c <== NOT EXECUTED 200d5e4: 01 00 00 00 nop <== NOT EXECUTED return args.ioctl_return; } 200d5e8: 81 c7 e0 08 ret <== NOT EXECUTED 200d5ec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200d5f0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200d5f4: 81 c7 e0 08 ret <== NOT EXECUTED 200d5f8: 81 e8 00 00 restore <== NOT EXECUTED 0200d704 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 200d704: 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; 200d708: 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; 200d70c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2 args.iop = iop; 200d710: f0 27 bf ec st %i0, [ %fp + -20 ] args.flags = iop->flags; 200d714: c2 27 bf f0 st %g1, [ %fp + -16 ] args.mode = mode; 200d718: f6 27 bf f4 st %i3, [ %fp + -12 ] status = rtems_io_open( 200d71c: d2 00 a0 50 ld [ %g2 + 0x50 ], %o1 200d720: d0 00 a0 4c ld [ %g2 + 0x4c ], %o0 200d724: 94 07 bf ec add %fp, -20, %o2 200d728: 40 00 02 37 call 200e004 200d72c: b0 10 20 00 clr %i0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200d730: 80 a2 20 00 cmp %o0, 0 200d734: 02 80 00 05 be 200d748 200d738: 01 00 00 00 nop return rtems_deviceio_errno(status); 200d73c: 7f ff ff 90 call 200d57c <== NOT EXECUTED 200d740: 01 00 00 00 nop <== NOT EXECUTED 200d744: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return 0; } 200d748: 81 c7 e0 08 ret 200d74c: 81 e8 00 00 restore 0200d65c : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 200d65c: 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; 200d660: 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; 200d664: 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; 200d668: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 <== NOT EXECUTED args.iop = iop; args.offset = iop->offset; args.buffer = buffer; 200d66c: 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; 200d670: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED args.buffer = buffer; args.count = count; 200d674: f4 27 bf ec st %i2, [ %fp + -20 ] <== NOT EXECUTED args.flags = iop->flags; 200d678: 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; 200d67c: 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; 200d680: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED status = rtems_io_read( 200d684: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 <== NOT EXECUTED 200d688: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 <== NOT EXECUTED 200d68c: 40 00 02 74 call 200e05c <== NOT EXECUTED 200d690: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200d694: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200d698: 22 80 00 06 be,a 200d6b0 <== NOT EXECUTED 200d69c: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED return rtems_deviceio_errno(status); 200d6a0: 7f ff ff b7 call 200d57c <== NOT EXECUTED 200d6a4: 01 00 00 00 nop <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 200d6a8: 81 c7 e0 08 ret <== NOT EXECUTED 200d6ac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200d6b0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200d6b4: 81 c7 e0 08 ret <== NOT EXECUTED 200d6b8: 81 e8 00 00 restore <== NOT EXECUTED 0200d5fc : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 200d5fc: 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; 200d600: 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; 200d604: 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; 200d608: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; 200d60c: 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; 200d610: c2 27 bf e4 st %g1, [ %fp + -28 ] args.buffer = (void *) buffer; args.count = count; 200d614: f4 27 bf ec st %i2, [ %fp + -20 ] args.flags = iop->flags; 200d618: 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; 200d61c: 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; 200d620: c0 27 bf f4 clr [ %fp + -12 ] status = rtems_io_write( 200d624: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 200d628: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 200d62c: 40 00 02 a2 call 200e0b4 200d630: 94 07 bf e0 add %fp, -32, %o2 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200d634: 80 a2 20 00 cmp %o0, 0 200d638: 22 80 00 06 be,a 200d650 200d63c: d0 07 bf f4 ld [ %fp + -12 ], %o0 return rtems_deviceio_errno(status); 200d640: 7f ff ff cf call 200d57c <== NOT EXECUTED 200d644: 01 00 00 00 nop <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 200d648: 81 c7 e0 08 ret <== NOT EXECUTED 200d64c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200d650: b0 10 00 08 mov %o0, %i0 200d654: 81 c7 e0 08 ret 200d658: 81 e8 00 00 restore 02003e78 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 2003e78: 9d e3 bf 98 save %sp, -104, %sp rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 2003e7c: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1 2003e80: 80 a0 60 00 cmp %g1, 0 2003e84: 02 80 00 1a be 2003eec 2003e88: 01 00 00 00 nop rtems_interrupt_disable (level); 2003e8c: 7f ff f7 b4 call 2001d5c <== NOT EXECUTED 2003e90: 01 00 00 00 nop <== NOT EXECUTED 2003e94: 30 80 00 0f b,a 2003ed0 <== NOT EXECUTED while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { tty->rawOutBufState = rob_wait; 2003e98: c2 26 20 94 st %g1, [ %i0 + 0x94 ] <== NOT EXECUTED rtems_interrupt_enable (level); 2003e9c: 7f ff f7 b4 call 2001d6c <== NOT EXECUTED 2003ea0: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 2003ea4: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED 2003ea8: 92 10 20 00 clr %o1 <== NOT EXECUTED 2003eac: 40 00 06 b1 call 2005970 <== NOT EXECUTED 2003eb0: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 2003eb4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2003eb8: 02 80 00 04 be 2003ec8 <== NOT EXECUTED 2003ebc: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2003ec0: 40 00 09 aa call 2006568 <== NOT EXECUTED 2003ec4: 01 00 00 00 nop <== NOT EXECUTED rtems_interrupt_disable (level); 2003ec8: 7f ff f7 a5 call 2001d5c <== NOT EXECUTED 2003ecc: 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) { 2003ed0: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED 2003ed4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2003ed8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2003edc: 12 bf ff ef bne 2003e98 <== NOT EXECUTED 2003ee0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 2003ee4: 7f ff f7 a2 call 2001d6c <== NOT EXECUTED 2003ee8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 2003eec: 81 c7 e0 08 ret 2003ef0: 81 e8 00 00 restore 02002d4c : int dup2( int fildes, int fildes2 ) { 2002d4c: 9d e3 bf 48 save %sp, -184, %sp /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 2002d50: a0 07 bf a8 add %fp, -88, %l0 2002d54: 90 10 00 18 mov %i0, %o0 2002d58: 40 00 01 b1 call 200341c 2002d5c: 92 10 00 10 mov %l0, %o1 if ( status == -1 ) 2002d60: 80 a2 3f ff cmp %o0, -1 2002d64: 02 80 00 0e be 2002d9c 2002d68: 90 10 3f ff mov -1, %o0 /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 2002d6c: 92 10 00 10 mov %l0, %o1 2002d70: 40 00 01 ab call 200341c 2002d74: 90 10 00 19 mov %i1, %o0 if ( status == -1 ) 2002d78: 80 a2 3f ff cmp %o0, -1 2002d7c: 02 80 00 07 be 2002d98 2002d80: 90 10 00 18 mov %i0, %o0 /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 2002d84: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 2002d88: 40 00 00 96 call 2002fe0 <== NOT EXECUTED 2002d8c: 92 10 20 00 clr %o1 <== NOT EXECUTED } 2002d90: 81 c7 e0 08 ret <== NOT EXECUTED 2002d94: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 2002d98: 90 10 3f ff mov -1, %o0 } 2002d9c: b0 10 00 08 mov %o0, %i0 2002da0: 81 c7 e0 08 ret 2002da4: 81 e8 00 00 restore 020038ec : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 20038ec: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 20038f0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 20038f4: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 20038f8: 02 80 00 1a be 2003960 <== NOT EXECUTED 20038fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2003900: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 2003904: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 20180e0 <__ctype_ptr> <== NOT EXECUTED 2003908: 84 0e 20 ff and %i0, 0xff, %g2 <== NOT EXECUTED 200390c: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 <== NOT EXECUTED 2003910: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003914: 22 80 00 14 be,a 2003964 <== NOT EXECUTED 2003918: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED 200391c: 80 a0 a0 09 cmp %g2, 9 <== NOT EXECUTED 2003920: 02 80 00 10 be 2003960 <== NOT EXECUTED 2003924: 80 a0 a0 0a cmp %g2, 0xa <== NOT EXECUTED 2003928: 02 80 00 0e be 2003960 <== NOT EXECUTED 200392c: 82 1e 20 40 xor %i0, 0x40, %g1 <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; echobuf[1] = c ^ 0x40; 2003930: c2 2f bf f7 stb %g1, [ %fp + -9 ] <== 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] = '^'; 2003934: 82 10 20 5e mov 0x5e, %g1 <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); 2003938: 90 07 bf f6 add %fp, -10, %o0 <== NOT EXECUTED echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { char echobuf[2]; echobuf[0] = '^'; 200393c: c2 2f bf f6 stb %g1, [ %fp + -10 ] <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); 2003940: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2003944: 7f ff ff 3c call 2003634 <== NOT EXECUTED 2003948: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED tty->column += 2; 200394c: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED 2003950: 82 00 60 02 add %g1, 2, %g1 <== NOT EXECUTED 2003954: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED 2003958: 81 c7 e0 08 ret <== NOT EXECUTED 200395c: 81 e8 00 00 restore <== NOT EXECUTED } else { oproc (c, tty); 2003960: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED 2003964: 7f ff ff 80 call 2003764 <== NOT EXECUTED 2003968: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200396c: 81 c7 e0 08 ret <== NOT EXECUTED 2003970: 81 e8 00 00 restore <== NOT EXECUTED 02015b14 : group_fp = fopen("/etc/group", "r"); } void endgrent(void) { if (group_fp != NULL) 2015b14: 03 00 80 e3 sethi %hi(0x2038c00), %g1 <== NOT EXECUTED 2015b18: d0 00 63 bc ld [ %g1 + 0x3bc ], %o0 ! 2038fbc <== NOT EXECUTED 2015b1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015b20: 02 80 00 05 be 2015b34 <== NOT EXECUTED 2015b24: 01 00 00 00 nop <== NOT EXECUTED fclose(group_fp); 2015b28: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2015b2c: 40 00 30 ea call 2021ed4 <== NOT EXECUTED 2015b30: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2015b34: 81 c3 e0 08 retl <== NOT EXECUTED 2015b38: 01 00 00 00 nop 02015b3c : passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { if (passwd_fp != NULL) 2015b3c: 03 00 80 e3 sethi %hi(0x2038c00), %g1 <== NOT EXECUTED 2015b40: d0 00 62 d4 ld [ %g1 + 0x2d4 ], %o0 ! 2038ed4 <== NOT EXECUTED 2015b44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015b48: 02 80 00 05 be 2015b5c <== NOT EXECUTED 2015b4c: 01 00 00 00 nop <== NOT EXECUTED fclose(passwd_fp); 2015b50: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2015b54: 40 00 30 e0 call 2021ed4 <== NOT EXECUTED 2015b58: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2015b5c: 81 c3 e0 08 retl <== NOT EXECUTED 2015b60: 01 00 00 00 nop 02003974 : * 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) { 2003974: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (tty->ccount == 0) 2003978: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED 200397c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003980: 02 80 00 0a be 20039a8 <== NOT EXECUTED 2003984: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED return; if (lineFlag) { 2003988: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 200398c: 02 80 00 7d be 2003b80 <== NOT EXECUTED 2003990: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { 2003994: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2003998: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED 200399c: 32 80 00 05 bne,a 20039b0 <== NOT EXECUTED 20039a0: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED tty->ccount = 0; 20039a4: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED 20039a8: 81 c7 e0 08 ret <== NOT EXECUTED 20039ac: 81 e8 00 00 restore <== NOT EXECUTED return; } if (!(tty->termios.c_lflag & ECHOE)) { 20039b0: 12 80 00 74 bne 2003b80 <== NOT EXECUTED 20039b4: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED tty->ccount = 0; echo (tty->termios.c_cc[VKILL], tty); 20039b8: 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; 20039bc: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 20039c0: 7f ff ff cb call 20038ec <== NOT EXECUTED 20039c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 20039c8: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED echo ('\n', tty); 20039cc: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED return; } if (!(tty->termios.c_lflag & ECHOE)) { tty->ccount = 0; echo (tty->termios.c_cc[VKILL], tty); if (tty->termios.c_lflag & ECHOK) 20039d0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 20039d4: 12 80 00 11 bne 2003a18 <== NOT EXECUTED 20039d8: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED 20039dc: 30 80 00 71 b,a 2003ba0 <== NOT EXECUTED } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { 20039e0: c6 04 20 3c ld [ %l0 + 0x3c ], %g3 <== NOT EXECUTED echo ('\n', tty); return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 20039e4: 82 01 3f ff add %g4, -1, %g1 <== NOT EXECUTED 20039e8: c2 24 20 20 st %g1, [ %l0 + 0x20 ] <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 20039ec: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED 20039f0: 02 80 00 5f be 2003b6c <== NOT EXECUTED 20039f4: c4 08 80 01 ldub [ %g2 + %g1 ], %g2 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 20039f8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 20039fc: 12 80 00 09 bne 2003a20 <== NOT EXECUTED 2003a00: 83 28 a0 18 sll %g2, 0x18, %g1 <== NOT EXECUTED 2003a04: 80 88 e0 10 btst 0x10, %g3 <== NOT EXECUTED 2003a08: 12 80 00 07 bne 2003a24 <== NOT EXECUTED 2003a0c: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 2003a10: f0 0c 20 43 ldub [ %l0 + 0x43 ], %i0 <== NOT EXECUTED 2003a14: b2 10 00 10 mov %l0, %i1 <== NOT EXECUTED 2003a18: 7f ff ff b5 call 20038ec <== NOT EXECUTED 2003a1c: 81 e8 00 00 restore <== NOT EXECUTED } else if (c == '\t') { 2003a20: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED 2003a24: 80 a0 60 09 cmp %g1, 9 <== NOT EXECUTED 2003a28: 32 80 00 2c bne,a 2003ad8 <== NOT EXECUTED 2003a2c: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED int col = tty->read_start_column; 2003a30: f0 04 20 2c ld [ %l0 + 0x2c ], %i0 <== NOT EXECUTED while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 2003a34: d8 04 60 e0 ld [ %l1 + 0xe0 ], %o4 <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 2003a38: 9a 01 3f ff add %g4, -1, %o5 <== NOT EXECUTED c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { if (tty->termios.c_lflag & ECHOCTL) 2003a3c: 88 08 e2 00 and %g3, 0x200, %g4 <== NOT EXECUTED while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 2003a40: 10 80 00 14 b 2003a90 <== NOT EXECUTED 2003a44: 86 10 20 00 clr %g3 <== NOT EXECUTED /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { 2003a48: c4 48 40 03 ldsb [ %g1 + %g3 ], %g2 <== NOT EXECUTED 2003a4c: c2 08 40 03 ldub [ %g1 + %g3 ], %g1 <== NOT EXECUTED 2003a50: 80 a0 a0 09 cmp %g2, 9 <== NOT EXECUTED 2003a54: 12 80 00 05 bne 2003a68 <== NOT EXECUTED 2003a58: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED col = (col | 7) + 1; 2003a5c: 82 16 20 07 or %i0, 7, %g1 <== NOT EXECUTED 2003a60: 10 80 00 0b b 2003a8c <== NOT EXECUTED 2003a64: b0 00 60 01 add %g1, 1, %i0 <== NOT EXECUTED } else if (iscntrl (c)) { 2003a68: c2 0b 00 01 ldub [ %o4 + %g1 ], %g1 <== NOT EXECUTED 2003a6c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003a70: 22 80 00 07 be,a 2003a8c <== NOT EXECUTED 2003a74: b0 06 20 01 inc %i0 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 2003a78: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 2003a7c: 32 80 00 04 bne,a 2003a8c <== NOT EXECUTED 2003a80: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; 2003a84: 10 80 00 03 b 2003a90 <== NOT EXECUTED 2003a88: 86 00 e0 01 inc %g3 <== NOT EXECUTED 2003a8c: 86 00 e0 01 inc %g3 <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 2003a90: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED 2003a94: 32 bf ff ed bne,a 2003a48 <== NOT EXECUTED 2003a98: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 2003a9c: 10 80 00 08 b 2003abc <== NOT EXECUTED 2003aa0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); 2003aa4: 7f ff fe e4 call 2003634 <== NOT EXECUTED 2003aa8: 01 00 00 00 nop <== NOT EXECUTED tty->column--; 2003aac: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003ab0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003ab4: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 2003ab8: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); 2003abc: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 2003ac0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 2003ac4: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 2003ac8: 14 bf ff f7 bg 2003aa4 <== NOT EXECUTED 2003acc: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 2003ad0: 10 80 00 28 b 2003b70 <== NOT EXECUTED 2003ad4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 2003ad8: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 2003adc: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED 2003ae0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003ae4: 02 80 00 10 be 2003b24 <== NOT EXECUTED 2003ae8: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 2003aec: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED 2003af0: 22 80 00 0e be,a 2003b28 <== NOT EXECUTED 2003af4: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 2003af8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2003afc: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2003b00: 7f ff fe cd call 2003634 <== NOT EXECUTED 2003b04: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED if (tty->column) 2003b08: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003b0c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003b10: 22 80 00 05 be,a 2003b24 <== NOT EXECUTED 2003b14: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED tty->column--; 2003b18: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003b1c: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 2003b20: c2 04 60 e0 ld [ %l1 + 0xe0 ], %g1 <== NOT EXECUTED 2003b24: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED 2003b28: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003b2c: 02 80 00 07 be 2003b48 <== NOT EXECUTED 2003b30: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2003b34: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED 2003b38: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 2003b3c: 02 80 00 0d be 2003b70 <== NOT EXECUTED 2003b40: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 2003b44: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2003b48: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2003b4c: 7f ff fe ba call 2003634 <== NOT EXECUTED 2003b50: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED if (tty->column) 2003b54: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003b58: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003b5c: 02 80 00 05 be 2003b70 <== NOT EXECUTED 2003b60: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED tty->column--; 2003b64: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003b68: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED } } } if (!lineFlag) 2003b6c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2003b70: 02 80 00 0c be 2003ba0 <== NOT EXECUTED 2003b74: 01 00 00 00 nop <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 2003b78: 10 80 00 07 b 2003b94 <== NOT EXECUTED 2003b7c: c8 04 20 20 ld [ %l0 + 0x20 ], %g4 <== NOT EXECUTED 2003b80: 23 00 80 60 sethi %hi(0x2018000), %l1 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); if (tty->column) tty->column--; } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 2003b84: a4 10 60 38 or %g1, 0x38, %l2 <== NOT EXECUTED /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 2003b88: 03 00 80 5b sethi %hi(0x2016c00), %g1 <== NOT EXECUTED 2003b8c: a6 10 60 30 or %g1, 0x30, %l3 ! 2016c30 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 2003b90: c8 04 20 20 ld [ %l0 + 0x20 ], %g4 <== NOT EXECUTED 2003b94: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 2003b98: 32 bf ff 92 bne,a 20039e0 <== NOT EXECUTED 2003b9c: c4 04 20 1c ld [ %l0 + 0x1c ], %g2 <== NOT EXECUTED 2003ba0: 81 c7 e0 08 ret <== NOT EXECUTED 2003ba4: 81 e8 00 00 restore <== NOT EXECUTED 0201f6e0 : int fcntl( int fd, int cmd, ... ) { 201f6e0: 9d e3 bf 90 save %sp, -112, %sp int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 201f6e4: 03 00 80 db sethi %hi(0x2036c00), %g1 201f6e8: da 00 62 fc ld [ %g1 + 0x2fc ], %o5 ! 2036efc ... ) { int ret; va_list ap; va_start( ap, cmd ); 201f6ec: 86 07 a0 4c add %fp, 0x4c, %g3 int fcntl( int fd, int cmd, ... ) { 201f6f0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 201f6f4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 201f6f8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 201f6fc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 201f700: 80 a6 00 0d cmp %i0, %o5 201f704: 1a 80 00 0e bcc 201f73c 201f708: c6 27 bf f4 st %g3, [ %fp + -12 ] iop = rtems_libio_iop( fd ); 201f70c: 03 00 80 e6 sethi %hi(0x2039800), %g1 201f710: c8 00 61 30 ld [ %g1 + 0x130 ], %g4 ! 2039930 201f714: 85 2e 20 02 sll %i0, 2, %g2 201f718: 83 2e 20 04 sll %i0, 4, %g1 201f71c: 82 20 40 02 sub %g1, %g2, %g1 201f720: 82 00 40 18 add %g1, %i0, %g1 201f724: 83 28 60 02 sll %g1, 2, %g1 201f728: b0 01 00 01 add %g4, %g1, %i0 rtems_libio_check_is_open(iop); 201f72c: d0 06 20 0c ld [ %i0 + 0xc ], %o0 201f730: 80 8a 21 00 btst 0x100, %o0 201f734: 12 80 00 07 bne 201f750 201f738: 80 a6 60 09 cmp %i1, 9 201f73c: 40 00 09 90 call 2021d7c <__errno> <== NOT EXECUTED 201f740: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED 201f744: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 201f748: 10 80 00 68 b 201f8e8 <== NOT EXECUTED 201f74c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 201f750: 18 80 00 50 bgu 201f890 201f754: 83 2e 60 02 sll %i1, 2, %g1 201f758: 05 00 80 7d sethi %hi(0x201f400), %g2 201f75c: 84 10 a2 b8 or %g2, 0x2b8, %g2 ! 201f6b8 201f760: c2 00 80 01 ld [ %g2 + %g1 ], %g1 201f764: 81 c0 40 00 jmp %g1 201f768: 01 00 00 00 nop case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 201f76c: d0 00 c0 00 ld [ %g3 ], %o0 if ( fd2 ) 201f770: 80 a2 20 00 cmp %o0, 0 201f774: 02 80 00 0b be 201f7a0 201f778: 80 a2 00 0d cmp %o0, %o5 diop = rtems_libio_iop( fd2 ); 201f77c: 1a 80 00 0e bcc 201f7b4 <== NOT EXECUTED 201f780: ba 10 20 00 clr %i5 <== NOT EXECUTED 201f784: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 201f788: 83 2a 20 04 sll %o0, 4, %g1 <== NOT EXECUTED 201f78c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 201f790: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 201f794: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 201f798: 10 80 00 07 b 201f7b4 <== NOT EXECUTED 201f79c: ba 01 00 01 add %g4, %g1, %i5 <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 201f7a0: 7f ff 92 4d call 20040d4 201f7a4: 01 00 00 00 nop if ( diop == 0 ) { 201f7a8: ba 92 20 00 orcc %o0, 0, %i5 201f7ac: 22 80 00 4f be,a 201f8e8 201f7b0: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED ret = -1; break; } } diop->handlers = iop->handlers; 201f7b4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 diop->file_info = iop->file_info; 201f7b8: c4 06 20 2c ld [ %i0 + 0x2c ], %g2 diop->flags = iop->flags; 201f7bc: c6 06 20 0c ld [ %i0 + 0xc ], %g3 ret = -1; break; } } diop->handlers = iop->handlers; 201f7c0: c2 27 60 30 st %g1, [ %i5 + 0x30 ] diop->file_info = iop->file_info; 201f7c4: c4 27 60 2c st %g2, [ %i5 + 0x2c ] diop->flags = iop->flags; 201f7c8: c6 27 60 0c st %g3, [ %i5 + 0xc ] diop->pathinfo = iop->pathinfo; 201f7cc: 90 07 60 10 add %i5, 0x10, %o0 201f7d0: 92 06 20 10 add %i0, 0x10, %o1 201f7d4: 40 00 10 1e call 202384c 201f7d8: 94 10 20 10 mov 0x10, %o2 ret = (int) (diop - rtems_libio_iops); 201f7dc: 03 00 80 e6 sethi %hi(0x2039800), %g1 201f7e0: c6 00 61 30 ld [ %g1 + 0x130 ], %g3 ! 2039930 201f7e4: 86 27 40 03 sub %i5, %g3, %g3 201f7e8: 87 38 e0 02 sra %g3, 2, %g3 201f7ec: 83 28 e0 02 sll %g3, 2, %g1 201f7f0: 85 28 e0 06 sll %g3, 6, %g2 201f7f4: 84 20 80 01 sub %g2, %g1, %g2 201f7f8: 83 28 a0 06 sll %g2, 6, %g1 201f7fc: 82 20 40 02 sub %g1, %g2, %g1 201f800: 85 28 60 0c sll %g1, 0xc, %g2 201f804: 82 00 40 02 add %g1, %g2, %g1 201f808: 82 00 40 03 add %g1, %g3, %g1 201f80c: 83 28 60 04 sll %g1, 4, %g1 201f810: 82 20 40 03 sub %g1, %g3, %g1 201f814: 83 28 60 02 sll %g1, 2, %g1 201f818: 10 80 00 23 b 201f8a4 201f81c: b8 20 c0 01 sub %g3, %g1, %i4 break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 201f820: 83 32 20 0b srl %o0, 0xb, %g1 201f824: 10 80 00 23 b 201f8b0 201f828: b8 08 60 01 and %g1, 1, %i4 * if a new process is exec()'ed. Since RTEMS does not support * processes, then we can ignore this one except to make * F_GETFD work. */ if ( va_arg( ap, int ) ) 201f82c: c2 00 c0 00 ld [ %g3 ], %g1 201f830: 80 a0 60 00 cmp %g1, 0 201f834: 22 80 00 03 be,a 201f840 201f838: 82 0a 37 ff and %o0, -2049, %g1 <== NOT EXECUTED 201f83c: 82 12 28 00 or %o0, 0x800, %g1 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 201f840: c2 26 20 0c st %g1, [ %i0 + 0xc ] 201f844: 10 80 00 1b b 201f8b0 201f848: b8 10 20 00 clr %i4 break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 201f84c: 7f ff 91 b7 call 2003f28 201f850: 01 00 00 00 nop 201f854: 10 80 00 14 b 201f8a4 201f858: b8 10 00 08 mov %o0, %i4 break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 201f85c: d0 00 c0 00 ld [ %g3 ], %o0 201f860: 7f ff 92 53 call 20041ac 201f864: b8 10 20 00 clr %i4 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 201f868: c2 06 20 0c ld [ %i0 + 0xc ], %g1 201f86c: 90 0a 22 01 and %o0, 0x201, %o0 201f870: 82 08 7d fe and %g1, -514, %g1 201f874: 90 12 00 01 or %o0, %g1, %o0 201f878: 10 80 00 0e b 201f8b0 201f87c: d0 26 20 0c st %o0, [ %i0 + 0xc ] errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 201f880: 40 00 09 3f call 2021d7c <__errno> 201f884: 01 00 00 00 nop 201f888: 10 80 00 05 b 201f89c 201f88c: 82 10 20 86 mov 0x86, %g1 ! 86 ret = -1; break; default: errno = EINVAL; 201f890: 40 00 09 3b call 2021d7c <__errno> 201f894: 01 00 00 00 nop 201f898: 82 10 20 16 mov 0x16, %g1 ! 16 201f89c: 10 80 00 12 b 201f8e4 201f8a0: c2 22 00 00 st %g1, [ %o0 ] /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 201f8a4: 80 a7 20 00 cmp %i4, 0 201f8a8: 06 80 00 10 bl 201f8e8 201f8ac: 01 00 00 00 nop if (iop->handlers->fcntl_h) { 201f8b0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 201f8b4: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 201f8b8: 80 a0 60 00 cmp %g1, 0 201f8bc: 02 80 00 0b be 201f8e8 201f8c0: 90 10 00 19 mov %i1, %o0 int err = (*iop->handlers->fcntl_h)( cmd, iop ); 201f8c4: 9f c0 40 00 call %g1 201f8c8: 92 10 00 18 mov %i0, %o1 if (err) { 201f8cc: ba 92 20 00 orcc %o0, 0, %i5 201f8d0: 02 80 00 06 be 201f8e8 201f8d4: 01 00 00 00 nop errno = err; 201f8d8: 40 00 09 29 call 2021d7c <__errno> <== NOT EXECUTED 201f8dc: 01 00 00 00 nop <== NOT EXECUTED 201f8e0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED { int ret; va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); 201f8e4: b8 10 3f ff mov -1, %i4 return ret; } 201f8e8: 81 c7 e0 08 ret 201f8ec: 91 e8 00 1c restore %g0, %i4, %o0 020032e0 : long fpathconf( int fd, int name ) { 20032e0: 9d e3 bf 98 save %sp, -104, %sp long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 20032e4: 03 00 80 5d sethi %hi(0x2017400), %g1 20032e8: c2 00 62 6c ld [ %g1 + 0x26c ], %g1 ! 201766c 20032ec: 80 a6 00 01 cmp %i0, %g1 20032f0: 1a 80 00 0d bcc 2003324 20032f4: 85 2e 20 02 sll %i0, 2, %g2 iop = rtems_libio_iop(fd); 20032f8: 03 00 80 62 sethi %hi(0x2018800), %g1 20032fc: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 ! 201882c 2003300: 83 2e 20 04 sll %i0, 4, %g1 2003304: 82 20 40 02 sub %g1, %g2, %g1 2003308: 82 00 40 18 add %g1, %i0, %g1 200330c: 83 28 60 02 sll %g1, 2, %g1 2003310: 82 00 40 03 add %g1, %g3, %g1 rtems_libio_check_is_open(iop); 2003314: c6 00 60 0c ld [ %g1 + 0xc ], %g3 2003318: 80 88 e1 00 btst 0x100, %g3 200331c: 12 80 00 06 bne 2003334 2003320: 80 88 e0 02 btst 2, %g3 2003324: 40 00 36 12 call 2010b6c <__errno> 2003328: 01 00 00 00 nop 200332c: 10 80 00 07 b 2003348 2003330: 82 10 20 09 mov 9, %g1 ! 9 rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 2003334: 12 80 00 08 bne 2003354 2003338: 80 a6 60 0b cmp %i1, 0xb 200333c: 40 00 36 0c call 2010b6c <__errno> <== NOT EXECUTED 2003340: 01 00 00 00 nop <== NOT EXECUTED 2003344: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2003348: c2 22 00 00 st %g1, [ %o0 ] 200334c: 81 c7 e0 08 ret 2003350: 91 e8 3f ff restore %g0, -1, %o0 * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 2003354: 18 80 00 2c bgu 2003404 2003358: f0 00 60 1c ld [ %g1 + 0x1c ], %i0 200335c: 83 2e 60 02 sll %i1, 2, %g1 2003360: 05 00 80 0c sethi %hi(0x2003000), %g2 2003364: 84 10 a2 b0 or %g2, 0x2b0, %g2 ! 20032b0 2003368: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200336c: 81 c0 40 00 jmp %g1 2003370: 01 00 00 00 nop case _PC_LINK_MAX: return_value = the_limits->link_max; 2003374: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 2003378: 81 c7 e0 08 ret 200337c: 81 e8 00 00 restore break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 2003380: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 2003384: 81 c7 e0 08 ret 2003388: 81 e8 00 00 restore break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 200338c: f0 06 20 38 ld [ %i0 + 0x38 ], %i0 2003390: 81 c7 e0 08 ret 2003394: 81 e8 00 00 restore break; case _PC_NAME_MAX: return_value = the_limits->name_max; 2003398: f0 06 20 3c ld [ %i0 + 0x3c ], %i0 200339c: 81 c7 e0 08 ret 20033a0: 81 e8 00 00 restore break; case _PC_PATH_MAX: return_value = the_limits->path_max; 20033a4: f0 06 20 40 ld [ %i0 + 0x40 ], %i0 20033a8: 81 c7 e0 08 ret 20033ac: 81 e8 00 00 restore break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 20033b0: f0 06 20 44 ld [ %i0 + 0x44 ], %i0 20033b4: 81 c7 e0 08 ret 20033b8: 81 e8 00 00 restore break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 20033bc: f0 06 20 4c ld [ %i0 + 0x4c ], %i0 20033c0: 81 c7 e0 08 ret 20033c4: 81 e8 00 00 restore break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 20033c8: f0 06 20 50 ld [ %i0 + 0x50 ], %i0 20033cc: 81 c7 e0 08 ret 20033d0: 81 e8 00 00 restore break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 20033d4: f0 06 20 5c ld [ %i0 + 0x5c ], %i0 20033d8: 81 c7 e0 08 ret 20033dc: 81 e8 00 00 restore break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 20033e0: f0 06 20 48 ld [ %i0 + 0x48 ], %i0 20033e4: 81 c7 e0 08 ret 20033e8: 81 e8 00 00 restore break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 20033ec: f0 06 20 54 ld [ %i0 + 0x54 ], %i0 20033f0: 81 c7 e0 08 ret 20033f4: 81 e8 00 00 restore break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 20033f8: f0 06 20 58 ld [ %i0 + 0x58 ], %i0 20033fc: 81 c7 e0 08 ret 2003400: 81 e8 00 00 restore break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2003404: 40 00 35 da call 2010b6c <__errno> 2003408: b0 10 3f ff mov -1, %i0 200340c: 82 10 20 16 mov 0x16, %g1 2003410: c2 22 00 00 st %g1, [ %o0 ] break; } return return_value; } 2003414: 81 c7 e0 08 ret 2003418: 81 e8 00 00 restore 020021fc : } void free( void *ptr ) { 20021fc: 9d e3 bf 98 save %sp, -104, %sp MSBUMP(free_calls, 1); if ( !ptr ) 2002200: 80 a6 20 00 cmp %i0, 0 2002204: 02 80 00 1f be 2002280 2002208: 03 00 80 63 sethi %hi(0x2018c00), %g1 /* * Do not attempt to free memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 200220c: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 2002210: 80 a0 60 03 cmp %g1, 3 2002214: 12 80 00 0e bne 200224c 2002218: 03 00 80 62 sethi %hi(0x2018800), %g1 if ((_Thread_Dispatch_disable_level > 0) || (_ISR_Nest_level > 0)) { 200221c: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2002220: 80 a0 60 00 cmp %g1, 0 2002224: 12 80 00 06 bne 200223c 2002228: 03 00 80 62 sethi %hi(0x2018800), %g1 200222c: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 2018bb8 <_ISR_Nest_level> 2002230: 80 a0 60 00 cmp %g1, 0 2002234: 02 80 00 07 be 2002250 2002238: 37 00 80 62 sethi %hi(0x2018800), %i3 Chain_Append(&RTEMS_Malloc_GC_list, (Chain_Node *)ptr); 200223c: b2 10 00 18 mov %i0, %i1 2002240: 31 00 80 62 sethi %hi(0x2018800), %i0 2002244: 40 00 11 88 call 2006864 <_Chain_Append> 2002248: 91 ee 21 88 restore %i0, 0x188, %o0 MSBUMP(lifetime_freed, size); } } #endif if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 200224c: 37 00 80 62 sethi %hi(0x2018800), %i3 <== NOT EXECUTED 2002250: 92 10 00 18 mov %i0, %o1 2002254: 40 00 17 79 call 2008038 <_Protected_heap_Free> 2002258: 90 16 e1 2c or %i3, 0x12c, %o0 200225c: 80 a2 20 00 cmp %o0, 0 2002260: 12 80 00 08 bne 2002280 2002264: 82 16 e1 2c or %i3, 0x12c, %g1 printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 2002268: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED 200226c: f4 00 60 18 ld [ %g1 + 0x18 ], %i2 <== NOT EXECUTED 2002270: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED 2002274: 31 00 80 5a sethi %hi(0x2016800), %i0 <== NOT EXECUTED 2002278: 40 00 03 60 call 2002ff8 <== NOT EXECUTED 200227c: 91 ee 23 c0 restore %i0, 0x3c0, %o0 <== NOT EXECUTED 2002280: 81 c7 e0 08 ret 2002284: 81 e8 00 00 restore 02016658 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 2016658: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 201665c: 03 00 80 e8 sethi %hi(0x203a000), %g1 <== NOT EXECUTED 2016660: 82 10 61 94 or %g1, 0x194, %g1 ! 203a194 <== NOT EXECUTED 2016664: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2016668: 02 80 00 18 be 20166c8 <== NOT EXECUTED 201666c: 01 00 00 00 nop <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 2016670: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 2016674: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016678: 22 80 00 09 be,a 201669c <== NOT EXECUTED 201667c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 2016680: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2016684: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016688: 22 80 00 05 be,a 201669c <== NOT EXECUTED 201668c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 2016690: 9f c0 40 00 call %g1 <== NOT EXECUTED 2016694: 90 06 20 04 add %i0, 4, %o0 <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 2016698: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 201669c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20166a0: 02 80 00 08 be 20166c0 <== NOT EXECUTED 20166a4: 01 00 00 00 nop <== NOT EXECUTED 20166a8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20166ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20166b0: 02 80 00 04 be 20166c0 <== NOT EXECUTED 20166b4: 01 00 00 00 nop <== NOT EXECUTED 20166b8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20166bc: 90 06 20 14 add %i0, 0x14, %o0 <== NOT EXECUTED free(env); 20166c0: 7f ff b6 d4 call 2004210 <== NOT EXECUTED 20166c4: 81 e8 00 00 restore <== NOT EXECUTED 20166c8: 81 c7 e0 08 ret <== NOT EXECUTED 20166cc: 81 e8 00 00 restore <== NOT EXECUTED 02015f64 : int fstat( int fd, struct stat *sbuf ) { 2015f64: 9d e3 bf 98 save %sp, -104, %sp /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 2015f68: 80 a6 60 00 cmp %i1, 0 2015f6c: 32 80 00 06 bne,a 2015f84 2015f70: 03 00 80 5d sethi %hi(0x2017400), %g1 rtems_set_errno_and_return_minus_one( EFAULT ); 2015f74: 7f ff e1 1b call 200e3e0 <__errno> 2015f78: 01 00 00 00 nop 2015f7c: 10 80 00 2a b 2016024 2015f80: 82 10 20 0e mov 0xe, %g1 ! e /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 2015f84: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 2015f88: 80 a6 00 01 cmp %i0, %g1 2015f8c: 1a 80 00 23 bcc 2016018 2015f90: 03 00 80 62 sethi %hi(0x2018800), %g1 2015f94: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 2015f98: 85 2e 20 02 sll %i0, 2, %g2 2015f9c: 83 2e 20 04 sll %i0, 4, %g1 2015fa0: 82 20 40 02 sub %g1, %g2, %g1 2015fa4: 82 00 40 18 add %g1, %i0, %g1 2015fa8: 83 28 60 02 sll %g1, 2, %g1 2015fac: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 2015fb0: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2015fb4: 80 88 61 00 btst 0x100, %g1 2015fb8: 02 80 00 18 be 2016018 2015fbc: 01 00 00 00 nop if ( !iop->handlers ) 2015fc0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2015fc4: 80 a0 60 00 cmp %g1, 0 2015fc8: 02 80 00 14 be 2016018 2015fcc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 2015fd0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 2015fd4: 80 a0 60 00 cmp %g1, 0 2015fd8: 12 80 00 06 bne 2015ff0 2015fdc: 92 10 20 00 clr %o1 rtems_set_errno_and_return_minus_one( ENOTSUP ); 2015fe0: 7f ff e1 00 call 200e3e0 <__errno> <== NOT EXECUTED 2015fe4: 01 00 00 00 nop <== NOT EXECUTED 2015fe8: 10 80 00 0f b 2016024 <== NOT EXECUTED 2015fec: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 2015ff0: 94 10 20 50 mov 0x50, %o2 2015ff4: 7f ff e2 fd call 200ebe8 2015ff8: 90 10 00 19 mov %i1, %o0 return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 2015ffc: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2016000: 90 06 20 10 add %i0, 0x10, %o0 2016004: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 2016008: 9f c0 40 00 call %g1 201600c: 92 10 00 19 mov %i1, %o1 } 2016010: 81 c7 e0 08 ret 2016014: 91 e8 00 08 restore %g0, %o0, %o0 /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); 2016018: 7f ff e0 f2 call 200e3e0 <__errno> 201601c: 01 00 00 00 nop 2016020: 82 10 20 09 mov 9, %g1 ! 9 2016024: c2 22 00 00 st %g1, [ %o0 ] 2016028: 90 10 3f ff mov -1, %o0 * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); } 201602c: b0 10 00 08 mov %o0, %i0 2016030: 81 c7 e0 08 ret 2016034: 81 e8 00 00 restore 02003508 : #include int fsync( int fd ) { 2003508: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; rtems_libio_check_fd( fd ); 200350c: 03 00 80 5d sethi %hi(0x2017400), %g1 2003510: c2 00 62 6c ld [ %g1 + 0x26c ], %g1 ! 201766c 2003514: 80 a6 00 01 cmp %i0, %g1 2003518: 1a 80 00 16 bcc 2003570 200351c: 85 2e 20 02 sll %i0, 2, %g2 iop = rtems_libio_iop( fd ); 2003520: 03 00 80 62 sethi %hi(0x2018800), %g1 2003524: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 ! 201882c 2003528: 83 2e 20 04 sll %i0, 4, %g1 200352c: 82 20 40 02 sub %g1, %g2, %g1 2003530: 82 00 40 18 add %g1, %i0, %g1 2003534: 83 28 60 02 sll %g1, 2, %g1 2003538: 90 00 40 03 add %g1, %g3, %o0 rtems_libio_check_is_open(iop); 200353c: c6 02 20 0c ld [ %o0 + 0xc ], %g3 2003540: 80 88 e1 00 btst 0x100, %g3 2003544: 02 80 00 0b be 2003570 2003548: 80 88 e0 04 btst 4, %g3 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 200354c: 32 80 00 06 bne,a 2003564 2003550: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 2003554: 40 00 35 86 call 2010b6c <__errno> 2003558: 01 00 00 00 nop 200355c: 10 80 00 0f b 2003598 2003560: 82 10 20 16 mov 0x16, %g1 ! 16 /* * Now process the fsync(). */ if ( !iop->handlers ) 2003564: 80 a0 e0 00 cmp %g3, 0 2003568: 32 80 00 06 bne,a 2003580 200356c: c2 00 e0 28 ld [ %g3 + 0x28 ], %g1 rtems_set_errno_and_return_minus_one( EBADF ); 2003570: 40 00 35 7f call 2010b6c <__errno> <== NOT EXECUTED 2003574: 01 00 00 00 nop <== NOT EXECUTED 2003578: 10 80 00 08 b 2003598 <== NOT EXECUTED 200357c: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 2003580: 80 a0 60 00 cmp %g1, 0 2003584: 12 80 00 08 bne 20035a4 2003588: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 200358c: 40 00 35 78 call 2010b6c <__errno> 2003590: 01 00 00 00 nop 2003594: 82 10 20 86 mov 0x86, %g1 ! 86 2003598: c2 22 00 00 st %g1, [ %o0 ] 200359c: 10 80 00 04 b 20035ac 20035a0: 90 10 3f ff mov -1, %o0 return (*iop->handlers->fsync_h)( iop ); 20035a4: 9f c0 40 00 call %g1 20035a8: 01 00 00 00 nop } 20035ac: 81 c7 e0 08 ret 20035b0: 91 e8 00 08 restore %g0, %o0, %o0 0200b8b0 : int ftruncate( int fd, off_t length ) { 200b8b0: 9d e3 bf 88 save %sp, -120, %sp rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 200b8b4: 03 00 80 5d sethi %hi(0x2017400), %g1 200b8b8: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 201779c 200b8bc: 80 a6 00 01 cmp %i0, %g1 200b8c0: 1a 80 00 0d bcc 200b8f4 200b8c4: 85 2e 20 02 sll %i0, 2, %g2 iop = rtems_libio_iop( fd ); 200b8c8: 03 00 80 62 sethi %hi(0x2018800), %g1 200b8cc: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 200b8d0: 83 2e 20 04 sll %i0, 4, %g1 200b8d4: 82 20 40 02 sub %g1, %g2, %g1 200b8d8: 82 00 40 18 add %g1, %i0, %g1 200b8dc: 83 28 60 02 sll %g1, 2, %g1 200b8e0: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 200b8e4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 200b8e8: 80 88 61 00 btst 0x100, %g1 200b8ec: 12 80 00 06 bne 200b904 200b8f0: a0 07 bf e8 add %fp, -24, %l0 200b8f4: 40 00 0a bb call 200e3e0 <__errno> <== NOT EXECUTED 200b8f8: 01 00 00 00 nop <== NOT EXECUTED 200b8fc: 10 80 00 22 b 200b984 <== NOT EXECUTED 200b900: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 200b904: 92 06 20 10 add %i0, 0x10, %o1 200b908: 90 10 00 10 mov %l0, %o0 200b90c: 40 00 0c 8a call 200eb34 200b910: 94 10 20 10 mov 0x10, %o2 if ( !loc.ops->node_type_h ) 200b914: c2 07 bf f0 ld [ %fp + -16 ], %g1 200b918: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 200b91c: 80 a0 60 00 cmp %g1, 0 200b920: 02 80 00 16 be 200b978 200b924: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 200b928: 9f c0 40 00 call %g1 200b92c: 90 10 00 10 mov %l0, %o0 200b930: 80 a2 20 01 cmp %o0, 1 200b934: 32 80 00 06 bne,a 200b94c 200b938: c2 06 20 0c ld [ %i0 + 0xc ], %g1 rtems_set_errno_and_return_minus_one( EISDIR ); 200b93c: 40 00 0a a9 call 200e3e0 <__errno> <== NOT EXECUTED 200b940: 01 00 00 00 nop <== NOT EXECUTED 200b944: 10 80 00 10 b 200b984 <== NOT EXECUTED 200b948: 82 10 20 15 mov 0x15, %g1 ! 15 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 200b94c: 80 88 60 04 btst 4, %g1 200b950: 32 80 00 06 bne,a 200b968 200b954: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200b958: 40 00 0a a2 call 200e3e0 <__errno> <== NOT EXECUTED 200b95c: 01 00 00 00 nop <== NOT EXECUTED 200b960: 10 80 00 09 b 200b984 <== NOT EXECUTED 200b964: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 200b968: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 200b96c: 80 a0 60 00 cmp %g1, 0 200b970: 32 80 00 08 bne,a 200b990 200b974: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); 200b978: 40 00 0a 9a call 200e3e0 <__errno> <== NOT EXECUTED 200b97c: 01 00 00 00 nop <== NOT EXECUTED 200b980: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 200b984: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b988: 10 80 00 04 b 200b998 <== NOT EXECUTED 200b98c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED return (*iop->handlers->ftruncate_h)( iop, length ); 200b990: 9f c0 40 00 call %g1 200b994: 92 10 00 19 mov %i1, %o1 } 200b998: 81 c7 e0 08 ret 200b99c: 91 e8 00 08 restore %g0, %o0, %o0 020156d8 : char * getcwd (pt, size) char *pt; size_t size; { 20156d8: 9d e3 bf 30 save %sp, -208, %sp <== NOT EXECUTED * If no buffer specified by the user, allocate one as necessary. * If a buffer is specified, the size has to be non-zero. The path * is built from the end of the buffer backwards. */ if (pt) 20156dc: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 20156e0: 02 80 00 0b be 201570c <== NOT EXECUTED 20156e4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED if (!size) { errno = EINVAL; return (char *) NULL; } ept = pt + size; 20156e8: b6 10 20 00 clr %i3 <== NOT EXECUTED */ if (pt) { ptsize = 0; if (!size) 20156ec: 12 80 00 0f bne 2015728 <== NOT EXECUTED 20156f0: b2 06 00 19 add %i0, %i1, %i1 <== NOT EXECUTED { errno = EINVAL; 20156f4: 40 00 31 a2 call 2021d7c <__errno> <== NOT EXECUTED 20156f8: b0 10 20 00 clr %i0 <== NOT EXECUTED 20156fc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2015700: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2015704: 81 c7 e0 08 ret <== NOT EXECUTED 2015708: 81 e8 00 00 restore <== NOT EXECUTED } ept = pt + size; } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 201570c: 7f ff ba e9 call 20042b0 <== NOT EXECUTED 2015710: 90 10 23 fc mov 0x3fc, %o0 <== NOT EXECUTED 2015714: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015718: 02 bf ff fb be 2015704 <== NOT EXECUTED 201571c: b6 10 23 fc mov 0x3fc, %i3 <== NOT EXECUTED 2015720: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 2015724: b2 02 23 fc add %o0, 0x3fc, %i1 <== NOT EXECUTED } bpt = ept - 1; *bpt = '\0'; 2015728: c0 2e 7f ff clrb [ %i1 + -1 ] <== NOT EXECUTED * Allocate bytes (1024 - malloc space) for the string of "../"'s. * Should always be enough (it's 340 levels). If it's not, allocate * as necessary. Special * case the first stat, it's ".", not "..". */ if (!(up = (char *) malloc (upsize = 1024 - 4))) 201572c: 90 10 23 fc mov 0x3fc, %o0 <== NOT EXECUTED 2015730: 7f ff ba e0 call 20042b0 <== NOT EXECUTED 2015734: ac 06 7f ff add %i1, -1, %l6 <== NOT EXECUTED 2015738: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 201573c: 02 80 00 d7 be 2015a98 <== NOT EXECUTED 2015740: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; up[1] = '\0'; 2015744: c0 2c a0 01 clrb [ %l2 + 1 ] <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 2015748: c2 2c 80 00 stb %g1, [ %l2 ] <== NOT EXECUTED up[1] = '\0'; /* Save root values, so know when to stop. */ if (stat ("/", &s)) 201574c: a0 07 bf a8 add %fp, -88, %l0 <== NOT EXECUTED 2015750: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED 2015754: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2015758: 7f ff bf 22 call 20053e0 <== NOT EXECUTED 201575c: 90 12 21 a8 or %o0, 0x1a8, %o0 <== NOT EXECUTED 2015760: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015764: 12 80 00 ce bne 2015a9c <== NOT EXECUTED 2015768: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED goto err; root_dev = s.st_dev; 201576c: c4 1f bf a8 ldd [ %fp + -88 ], %g2 <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 2015770: 82 04 a4 00 add %l2, 0x400, %g1 <== NOT EXECUTED up[1] = '\0'; /* Save root values, so know when to stop. */ if (stat ("/", &s)) goto err; root_dev = s.st_dev; 2015774: c4 3f bf 98 std %g2, [ %fp + -104 ] <== NOT EXECUTED root_ino = s.st_ino; 2015778: c6 07 bf b0 ld [ %fp + -80 ], %g3 <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 201577c: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED if (stat ("/", &s)) goto err; root_dev = s.st_dev; root_ino = s.st_ino; errno = 0; /* XXX readdir has no error return. */ 2015780: 40 00 31 7f call 2021d7c <__errno> <== NOT EXECUTED 2015784: c6 27 bf a0 st %g3, [ %fp + -96 ] <== NOT EXECUTED 2015788: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 201578c: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED 2015790: a6 10 00 12 mov %l2, %l3 <== NOT EXECUTED 2015794: c4 27 bf 94 st %g2, [ %fp + -108 ] <== NOT EXECUTED 2015798: b4 10 23 fc mov 0x3fc, %i2 <== NOT EXECUTED for (first = 1;; first = 0) { /* Stat the current level. */ if (_stat (up, &s)) 201579c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20157a0: 7f ff bf 10 call 20053e0 <== NOT EXECUTED 20157a4: 92 07 bf a8 add %fp, -88, %o1 <== NOT EXECUTED 20157a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20157ac: 12 80 00 bb bne 2015a98 <== NOT EXECUTED 20157b0: e8 1f bf a8 ldd [ %fp + -88 ], %l4 <== NOT EXECUTED /* Save current node values. */ ino = s.st_ino; dev = s.st_dev; /* Check for reaching root. */ if (root_dev == dev && root_ino == ino) 20157b4: c6 07 bf 98 ld [ %fp + -104 ], %g3 <== NOT EXECUTED 20157b8: 80 a0 c0 14 cmp %g3, %l4 <== NOT EXECUTED 20157bc: 12 80 00 14 bne 201580c <== NOT EXECUTED 20157c0: f8 07 bf b0 ld [ %fp + -80 ], %i4 <== NOT EXECUTED 20157c4: c2 07 bf 9c ld [ %fp + -100 ], %g1 <== NOT EXECUTED 20157c8: 80 a0 40 15 cmp %g1, %l5 <== NOT EXECUTED 20157cc: 12 80 00 11 bne 2015810 <== NOT EXECUTED 20157d0: c6 07 bf a4 ld [ %fp + -92 ], %g3 <== NOT EXECUTED 20157d4: c4 07 bf a0 ld [ %fp + -96 ], %g2 <== NOT EXECUTED 20157d8: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED 20157dc: 12 80 00 0e bne 2015814 <== NOT EXECUTED 20157e0: 82 04 e4 04 add %l3, 0x404, %g1 <== NOT EXECUTED { *--bpt = '/'; 20157e4: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED 20157e8: 92 05 bf ff add %l6, -1, %o1 <== NOT EXECUTED 20157ec: c2 2d bf ff stb %g1, [ %l6 + -1 ] <== NOT EXECUTED /* * It's unclear that it's a requirement to copy the * path to the beginning of the buffer, but it's always * been that way and stuff would probably break. */ (void) bcopy (bpt, pt, ept - bpt); 20157f0: 94 26 40 09 sub %i1, %o1, %o2 <== NOT EXECUTED 20157f4: 40 00 38 43 call 2023900 <== NOT EXECUTED 20157f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED free (up); 20157fc: 7f ff ba 85 call 2004210 <== NOT EXECUTED 2015800: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2015804: 81 c7 e0 08 ret <== NOT EXECUTED 2015808: 81 e8 00 00 restore <== NOT EXECUTED * Build pointer to the parent directory, allocating memory * as necessary. Max length is 3 for "../", the largest * possible component name, plus a trailing NULL. */ if (bup + 3 + MAXNAMLEN + 1 >= eup) 201580c: c6 07 bf a4 ld [ %fp + -92 ], %g3 <== NOT EXECUTED 2015810: 82 04 e4 04 add %l3, 0x404, %g1 <== NOT EXECUTED 2015814: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2015818: 0a 80 00 0c bcs 2015848 <== NOT EXECUTED 201581c: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED { if (!(up = (char *) realloc (up, upsize *= 2))) 2015820: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2015824: b5 2e a0 01 sll %i2, 1, %i2 <== NOT EXECUTED 2015828: 7f ff ba ed call 20043dc <== NOT EXECUTED 201582c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2015830: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 2015834: 02 80 00 99 be 2015a98 <== NOT EXECUTED 2015838: 82 04 80 1a add %l2, %i2, %g1 <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 201583c: a6 10 00 12 mov %l2, %l3 <== NOT EXECUTED 2015840: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED } *bup++ = '.'; 2015844: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED *bup++ = '.'; *bup = '\0'; 2015848: c0 2c e0 02 clrb [ %l3 + 2 ] <== NOT EXECUTED } bup = up; eup = up + upsize; } *bup++ = '.'; *bup++ = '.'; 201584c: c2 2c e0 01 stb %g1, [ %l3 + 1 ] <== NOT EXECUTED goto err; } bup = up; eup = up + upsize; } *bup++ = '.'; 2015850: c2 2c c0 00 stb %g1, [ %l3 ] <== NOT EXECUTED *bup++ = '.'; *bup = '\0'; /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 2015854: 40 00 03 5c call 20165c4 <== NOT EXECUTED 2015858: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 201585c: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 2015860: 02 80 00 8f be 2015a9c <== NOT EXECUTED 2015864: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 2015868: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED 201586c: 40 00 28 28 call 201f90c <== NOT EXECUTED 2015870: 92 07 bf a8 add %fp, -88, %o1 <== NOT EXECUTED 2015874: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015878: 12 80 00 92 bne 2015ac0 <== NOT EXECUTED 201587c: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 2015880: c2 2c e0 02 stb %g1, [ %l3 + 2 ] <== NOT EXECUTED * the inode number in the directory is for the entry in the * parent directory, not the inode number of the mounted file. */ save_errno = 0; if (s.st_dev == dev) 2015884: c2 07 bf a8 ld [ %fp + -88 ], %g1 <== NOT EXECUTED 2015888: 80 a0 40 14 cmp %g1, %l4 <== NOT EXECUTED 201588c: 12 80 00 06 bne 20158a4 <== NOT EXECUTED 2015890: a6 04 e0 03 add %l3, 3, %l3 <== NOT EXECUTED 2015894: c2 07 bf ac ld [ %fp + -84 ], %g1 <== NOT EXECUTED 2015898: 80 a0 40 15 cmp %g1, %l5 <== NOT EXECUTED 201589c: 02 80 00 04 be 20158ac <== NOT EXECUTED 20158a0: 01 00 00 00 nop <== NOT EXECUTED 20158a4: 10 80 00 0c b 20158d4 <== NOT EXECUTED 20158a8: ae 10 20 00 clr %l7 ! 0 <== NOT EXECUTED { for (;;) { if (!(dp = _readdir (dir))) 20158ac: 40 00 03 fc call 201689c <== NOT EXECUTED 20158b0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 20158b4: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 20158b8: 02 80 00 6b be 2015a64 <== NOT EXECUTED 20158bc: ae 10 20 00 clr %l7 <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 20158c0: c2 04 40 00 ld [ %l1 ], %g1 <== NOT EXECUTED 20158c4: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED 20158c8: 02 80 00 36 be 20159a0 <== NOT EXECUTED 20158cc: a0 04 60 0c add %l1, 0xc, %l0 <== NOT EXECUTED 20158d0: 30 bf ff f7 b,a 20158ac <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 20158d4: 40 00 03 f2 call 201689c <== NOT EXECUTED 20158d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 20158dc: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 20158e0: 02 80 00 61 be 2015a64 <== NOT EXECUTED 20158e4: 01 00 00 00 nop <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 20158e8: c2 4c 60 0c ldsb [ %l1 + 0xc ], %g1 <== NOT EXECUTED 20158ec: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED 20158f0: 12 80 00 0d bne 2015924 <== NOT EXECUTED 20158f4: a0 04 60 0c add %l1, 0xc, %l0 <== NOT EXECUTED 20158f8: c2 4c 60 0d ldsb [ %l1 + 0xd ], %g1 <== NOT EXECUTED 20158fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015900: 02 bf ff f5 be 20158d4 <== NOT EXECUTED 2015904: 05 00 3f ff sethi %hi(0xfffc00), %g2 <== NOT EXECUTED 2015908: c2 04 60 0c ld [ %l1 + 0xc ], %g1 <== NOT EXECUTED 201590c: 07 00 0b 80 sethi %hi(0x2e0000), %g3 <== NOT EXECUTED 2015910: 84 10 a3 00 or %g2, 0x300, %g2 <== NOT EXECUTED 2015914: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 2015918: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 201591c: 02 bf ff ee be 20158d4 <== NOT EXECUTED 2015920: 01 00 00 00 nop <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 2015924: 40 00 46 0d call 2027158 <== NOT EXECUTED 2015928: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 201592c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2015930: 94 02 20 01 add %o0, 1, %o2 <== NOT EXECUTED 2015934: 40 00 37 f3 call 2023900 <== NOT EXECUTED 2015938: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 201593c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2015940: 7f ff be a8 call 20053e0 <== NOT EXECUTED 2015944: 92 07 bf a8 add %fp, -88, %o1 <== NOT EXECUTED 2015948: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201594c: 02 80 00 0c be 201597c <== NOT EXECUTED 2015950: c2 07 bf a8 ld [ %fp + -88 ], %g1 <== NOT EXECUTED { if (!save_errno) 2015954: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED 2015958: 12 80 00 05 bne 201596c <== NOT EXECUTED 201595c: 01 00 00 00 nop <== NOT EXECUTED save_errno = errno; 2015960: 40 00 31 07 call 2021d7c <__errno> <== NOT EXECUTED 2015964: 01 00 00 00 nop <== NOT EXECUTED 2015968: ee 02 00 00 ld [ %o0 ], %l7 <== NOT EXECUTED errno = 0; 201596c: 40 00 31 04 call 2021d7c <__errno> <== NOT EXECUTED 2015970: 01 00 00 00 nop <== NOT EXECUTED 2015974: 10 bf ff d8 b 20158d4 <== NOT EXECUTED 2015978: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED continue; } if (s.st_dev == dev && s.st_ino == ino) 201597c: 80 a0 40 14 cmp %g1, %l4 <== NOT EXECUTED 2015980: 12 bf ff d5 bne 20158d4 <== NOT EXECUTED 2015984: c2 07 bf ac ld [ %fp + -84 ], %g1 <== NOT EXECUTED 2015988: 80 a0 40 15 cmp %g1, %l5 <== NOT EXECUTED 201598c: 12 bf ff d2 bne 20158d4 <== NOT EXECUTED 2015990: c2 07 bf b0 ld [ %fp + -80 ], %g1 <== NOT EXECUTED 2015994: 80 a0 40 1c cmp %g1, %i4 <== NOT EXECUTED 2015998: 12 bf ff cf bne 20158d4 <== NOT EXECUTED 201599c: a0 04 60 0c add %l1, 0xc, %l0 <== NOT EXECUTED /* * Check for length of the current name, preceding slash, * leading slash. */ if (bpt - pt <= strlen (dp->d_name) + (first ? 1 : 2)) 20159a0: 40 00 45 ee call 2027158 <== NOT EXECUTED 20159a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20159a8: c2 07 bf 94 ld [ %fp + -108 ], %g1 <== NOT EXECUTED 20159ac: a2 25 80 18 sub %l6, %i0, %l1 <== NOT EXECUTED 20159b0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20159b4: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED 20159b8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20159bc: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 20159c0: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 20159c4: 18 80 00 17 bgu 2015a20 <== NOT EXECUTED 20159c8: c4 07 bf 94 ld [ %fp + -108 ], %g2 <== NOT EXECUTED { size_t len, off; if (!ptsize) 20159cc: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 20159d0: 32 80 00 07 bne,a 20159ec <== NOT EXECUTED 20159d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED { errno = ERANGE; 20159d8: 40 00 30 e9 call 2021d7c <__errno> <== NOT EXECUTED 20159dc: 01 00 00 00 nop <== NOT EXECUTED 20159e0: 82 10 20 22 mov 0x22, %g1 ! 22 <== NOT EXECUTED 20159e4: 10 80 00 37 b 2015ac0 <== NOT EXECUTED 20159e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 20159ec: b7 2e e0 01 sll %i3, 1, %i3 <== NOT EXECUTED 20159f0: 7f ff ba 7b call 20043dc <== NOT EXECUTED 20159f4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 20159f8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 20159fc: 02 80 00 31 be 2015ac0 <== NOT EXECUTED 2015a00: 82 26 40 16 sub %i1, %l6, %g1 <== NOT EXECUTED { goto err; } bpt = pt + off; ept = pt + ptsize; (void) bcopy (bpt, ept - len, len); 2015a04: 92 06 00 11 add %i0, %l1, %o1 <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 2015a08: b2 06 00 1b add %i0, %i3, %i1 <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 2015a0c: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 2015a10: ac 26 40 01 sub %i1, %g1, %l6 <== NOT EXECUTED 2015a14: 40 00 37 bb call 2023900 <== NOT EXECUTED 2015a18: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED bpt = ept - len; } if (!first) 2015a1c: c4 07 bf 94 ld [ %fp + -108 ], %g2 <== NOT EXECUTED 2015a20: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2015a24: 12 80 00 04 bne 2015a34 <== NOT EXECUTED 2015a28: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED *--bpt = '/'; 2015a2c: ac 05 bf ff add %l6, -1, %l6 <== NOT EXECUTED 2015a30: c2 2d 80 00 stb %g1, [ %l6 ] <== NOT EXECUTED bpt -= strlen (dp->d_name); 2015a34: 40 00 45 c9 call 2027158 <== NOT EXECUTED 2015a38: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 2015a3c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2015a40: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); bpt = ept - len; } if (!first) *--bpt = '/'; bpt -= strlen (dp->d_name); 2015a44: ac 25 80 08 sub %l6, %o0, %l6 <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); (void) _closedir (dir); dir = 0; /* Truncate any file name. */ *bup = '\0'; 2015a48: c0 27 bf 94 clr [ %fp + -108 ] <== NOT EXECUTED bpt = ept - len; } if (!first) *--bpt = '/'; bpt -= strlen (dp->d_name); bcopy (dp->d_name, bpt, strlen (dp->d_name)); 2015a4c: 40 00 37 ad call 2023900 <== NOT EXECUTED 2015a50: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED (void) _closedir (dir); 2015a54: 7f ff fe 46 call 201536c <== NOT EXECUTED 2015a58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 2015a5c: 10 bf ff 50 b 201579c <== NOT EXECUTED 2015a60: c0 2c c0 00 clrb [ %l3 ] <== NOT EXECUTED * If readdir set errno, use it, not any saved error; otherwise, * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) 2015a64: 40 00 30 c6 call 2021d7c <__errno> <== NOT EXECUTED 2015a68: 01 00 00 00 nop <== NOT EXECUTED 2015a6c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2015a70: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015a74: 12 80 00 13 bne 2015ac0 <== NOT EXECUTED 2015a78: 01 00 00 00 nop <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; 2015a7c: 40 00 30 c0 call 2021d7c <__errno> <== NOT EXECUTED 2015a80: 01 00 00 00 nop <== NOT EXECUTED 2015a84: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED 2015a88: 22 80 00 02 be,a 2015a90 <== NOT EXECUTED 2015a8c: ae 10 20 02 mov 2, %l7 <== NOT EXECUTED 2015a90: 10 80 00 0c b 2015ac0 <== NOT EXECUTED 2015a94: ee 22 00 00 st %l7, [ %o0 ] <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 2015a98: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 2015a9c: 02 80 00 05 be 2015ab0 <== NOT EXECUTED 2015aa0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED free (pt); 2015aa4: 7f ff b9 db call 2004210 <== NOT EXECUTED 2015aa8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED free (up); 2015aac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2015ab0: 7f ff b9 d8 call 2004210 <== NOT EXECUTED 2015ab4: b0 10 20 00 clr %i0 <== NOT EXECUTED 2015ab8: 81 c7 e0 08 ret <== NOT EXECUTED 2015abc: 81 e8 00 00 restore <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 2015ac0: 7f ff fe 2b call 201536c <== NOT EXECUTED 2015ac4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED if (ptsize) 2015ac8: 10 bf ff f5 b 2015a9c <== NOT EXECUTED 2015acc: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 0201f9f8 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 201f9f8: 9d e3 bf 88 save %sp, -120, %sp /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 201f9fc: 03 00 80 db sethi %hi(0x2036c00), %g1 201fa00: c2 00 62 fc ld [ %g1 + 0x2fc ], %g1 ! 2036efc 201fa04: 80 a6 00 01 cmp %i0, %g1 201fa08: 1a 80 00 0a bcc 201fa30 201fa0c: a0 10 20 00 clr %l0 201fa10: 03 00 80 e6 sethi %hi(0x2039800), %g1 201fa14: c6 00 61 30 ld [ %g1 + 0x130 ], %g3 ! 2039930 201fa18: 85 2e 20 02 sll %i0, 2, %g2 201fa1c: 83 2e 20 04 sll %i0, 4, %g1 201fa20: 82 20 40 02 sub %g1, %g2, %g1 201fa24: 82 00 40 18 add %g1, %i0, %g1 201fa28: 83 28 60 02 sll %g1, 2, %g1 201fa2c: a0 00 40 03 add %g1, %g3, %l0 /* * Make sure we are working on a directory */ loc = iop->pathinfo; 201fa30: b0 07 bf e8 add %fp, -24, %i0 201fa34: 92 04 20 10 add %l0, 0x10, %o1 201fa38: 90 10 00 18 mov %i0, %o0 201fa3c: 40 00 0f 84 call 202384c 201fa40: 94 10 20 10 mov 0x10, %o2 if ( !loc.ops->node_type_h ) 201fa44: c2 07 bf f0 ld [ %fp + -16 ], %g1 201fa48: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 201fa4c: 80 a0 60 00 cmp %g1, 0 201fa50: 02 80 00 11 be 201fa94 201fa54: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 201fa58: 9f c0 40 00 call %g1 201fa5c: 90 10 00 18 mov %i0, %o0 201fa60: 80 a2 20 01 cmp %o0, 1 201fa64: 22 80 00 08 be,a 201fa84 201fa68: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 rtems_set_errno_and_return_minus_one( ENOTDIR ); 201fa6c: 40 00 08 c4 call 2021d7c <__errno> 201fa70: 01 00 00 00 nop 201fa74: 82 10 20 14 mov 0x14, %g1 ! 14 201fa78: c2 22 00 00 st %g1, [ %o0 ] 201fa7c: 10 80 00 0d b 201fab0 201fa80: 90 10 3f ff mov -1, %o0 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 201fa84: c2 00 60 08 ld [ %g1 + 8 ], %g1 201fa88: 80 a0 60 00 cmp %g1, 0 201fa8c: 32 80 00 06 bne,a 201faa4 201fa90: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); 201fa94: 40 00 08 ba call 2021d7c <__errno> <== NOT EXECUTED 201fa98: 01 00 00 00 nop <== NOT EXECUTED 201fa9c: 10 bf ff f7 b 201fa78 <== NOT EXECUTED 201faa0: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 201faa4: 92 10 00 19 mov %i1, %o1 201faa8: 9f c0 40 00 call %g1 201faac: 94 10 00 1a mov %i2, %o2 } 201fab0: 81 c7 e0 08 ret 201fab4: 91 e8 00 08 restore %g0, %o0, %o0 02015af0 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 2015af0: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2015af4: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2037710 <== NOT EXECUTED return _POSIX_types_Gid; } 2015af8: 81 c3 e0 08 retl <== NOT EXECUTED 2015afc: d0 10 60 2a lduh [ %g1 + 0x2a ], %o0 <== NOT EXECUTED 02016158 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 2016158: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 201615c: 7f ff ff b7 call 2016038 <== NOT EXECUTED 2016160: 01 00 00 00 nop <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 2016164: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2016168: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 201616c: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED 2016170: 40 00 31 57 call 20226cc <== NOT EXECUTED 2016174: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 2016178: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED 201617c: 12 80 00 08 bne 201619c <== NOT EXECUTED 2016180: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED errno = EINVAL; 2016184: 40 00 2e fe call 2021d7c <__errno> <== NOT EXECUTED 2016188: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201618c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2016190: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016194: 81 c7 e0 08 ret <== NOT EXECUTED 2016198: 81 e8 00 00 restore <== NOT EXECUTED return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 201619c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 20161a0: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 20161a4: 7f ff fe ea call 2015d4c <== NOT EXECUTED 20161a8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20161ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20161b0: 12 80 00 0a bne 20161d8 <== NOT EXECUTED 20161b4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED errno = EINVAL; 20161b8: 40 00 2e f1 call 2021d7c <__errno> <== NOT EXECUTED 20161bc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20161c0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20161c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED fclose(fp); 20161c8: 40 00 2f 43 call 2021ed4 <== NOT EXECUTED 20161cc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20161d0: 81 c7 e0 08 ret <== NOT EXECUTED 20161d4: 81 e8 00 00 restore <== NOT EXECUTED return -1; } if (name) { 20161d8: 22 80 00 07 be,a 20161f4 <== NOT EXECUTED 20161dc: c2 16 a0 08 lduh [ %i2 + 8 ], %g1 <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); 20161e0: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED 20161e4: 40 00 3d bc call 20258d4 <== NOT EXECUTED 20161e8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20161ec: 10 80 00 04 b 20161fc <== NOT EXECUTED 20161f0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED } else { match = (grp->gr_gid == gid); 20161f4: 82 18 40 19 xor %g1, %i1, %g1 <== NOT EXECUTED 20161f8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20161fc: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } if (match) { 2016200: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016204: 02 bf ff e6 be 201619c <== NOT EXECUTED 2016208: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED fclose(fp); 201620c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016210: 40 00 2f 31 call 2021ed4 <== NOT EXECUTED 2016214: b0 10 20 00 clr %i0 <== NOT EXECUTED *result = grp; 2016218: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 201621c: 81 c7 e0 08 ret <== NOT EXECUTED 2016220: 81 e8 00 00 restore <== NOT EXECUTED 02015e8c : return NULL; return p; } struct group *getgrent() { 2015e8c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (group_fp == NULL) 2015e90: 03 00 80 e3 sethi %hi(0x2038c00), %g1 <== NOT EXECUTED 2015e94: d0 00 63 bc ld [ %g1 + 0x3bc ], %o0 ! 2038fbc <== NOT EXECUTED 2015e98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015e9c: 02 80 00 0b be 2015ec8 <== NOT EXECUTED 2015ea0: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 2015ea4: 21 00 80 e4 sethi %hi(0x2039000), %l0 <== NOT EXECUTED 2015ea8: 92 14 20 88 or %l0, 0x88, %o1 ! 2039088 <== NOT EXECUTED 2015eac: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 2015eb0: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2015eb4: 7f ff ff a6 call 2015d4c <== NOT EXECUTED 2015eb8: b0 14 20 88 or %l0, 0x88, %i0 <== NOT EXECUTED 2015ebc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015ec0: 12 80 00 03 bne 2015ecc <== NOT EXECUTED 2015ec4: 01 00 00 00 nop <== NOT EXECUTED 2015ec8: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED return NULL; return &grent; } 2015ecc: 81 c7 e0 08 ret <== NOT EXECUTED 2015ed0: 81 e8 00 00 restore <== NOT EXECUTED 0201625c : } struct group *getgrgid( gid_t gid ) { 201625c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 2016260: 13 00 80 e4 sethi %hi(0x2039000), %o1 <== NOT EXECUTED 2016264: 91 2e 20 10 sll %i0, 0x10, %o0 <== NOT EXECUTED 2016268: 92 12 60 88 or %o1, 0x88, %o1 <== NOT EXECUTED 201626c: 91 32 20 10 srl %o0, 0x10, %o0 <== NOT EXECUTED 2016270: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED 2016274: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2016278: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 201627c: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 2016280: 7f ff ff e9 call 2016224 <== NOT EXECUTED 2016284: b0 10 20 00 clr %i0 <== NOT EXECUTED 2016288: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201628c: 22 80 00 02 be,a 2016294 <== NOT EXECUTED 2016290: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 2016294: 81 c7 e0 08 ret <== NOT EXECUTED 2016298: 81 e8 00 00 restore <== NOT EXECUTED 02016224 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 2016224: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED 2016228: 84 10 00 0a mov %o2, %g2 <== NOT EXECUTED 201622c: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 2016230: 93 2a 20 10 sll %o0, 0x10, %o1 <== NOT EXECUTED struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 2016234: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 2016238: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 201623c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED 2016240: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED 2016244: 98 10 00 03 mov %g3, %o4 <== NOT EXECUTED 2016248: 90 10 20 00 clr %o0 <== NOT EXECUTED 201624c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2016250: 7f ff ff c2 call 2016158 <== NOT EXECUTED 2016254: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2016258: 01 00 00 00 nop 020162c8 : } struct group *getgrnam( const char *name ) { 20162c8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 20162cc: 13 00 80 e4 sethi %hi(0x2039000), %o1 <== NOT EXECUTED 20162d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20162d4: 92 12 60 88 or %o1, 0x88, %o1 <== NOT EXECUTED 20162d8: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED 20162dc: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 20162e0: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 20162e4: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 20162e8: 7f ff ff ed call 201629c <== NOT EXECUTED 20162ec: b0 10 20 00 clr %i0 <== NOT EXECUTED 20162f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20162f4: 22 80 00 02 be,a 20162fc <== NOT EXECUTED 20162f8: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 20162fc: 81 c7 e0 08 ret <== NOT EXECUTED 2016300: 81 e8 00 00 restore <== NOT EXECUTED 0201629c : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 201629c: 82 10 00 0a mov %o2, %g1 <== NOT EXECUTED 20162a0: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 20162a4: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 20162a8: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 20162ac: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 20162b0: 98 10 00 02 mov %g2, %o4 <== NOT EXECUTED 20162b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20162b8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20162bc: 7f ff ff a7 call 2016158 <== NOT EXECUTED 20162c0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20162c4: 01 00 00 00 nop 02016348 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 2016348: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 201634c: 7f ff ff 3b call 2016038 <== NOT EXECUTED 2016350: 01 00 00 00 nop <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 2016354: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 2016358: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 201635c: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED 2016360: 40 00 30 db call 20226cc <== NOT EXECUTED 2016364: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 2016368: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED 201636c: 12 80 00 08 bne 201638c <== NOT EXECUTED 2016370: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED errno = EINVAL; 2016374: 40 00 2e 82 call 2021d7c <__errno> <== NOT EXECUTED 2016378: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201637c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2016380: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016384: 81 c7 e0 08 ret <== NOT EXECUTED 2016388: 81 e8 00 00 restore <== NOT EXECUTED return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 201638c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2016390: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 2016394: 7f ff fe d0 call 2015ed4 <== NOT EXECUTED 2016398: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 201639c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20163a0: 12 80 00 0a bne 20163c8 <== NOT EXECUTED 20163a4: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED errno = EINVAL; 20163a8: 40 00 2e 75 call 2021d7c <__errno> <== NOT EXECUTED 20163ac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20163b0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20163b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED fclose(fp); 20163b8: 40 00 2e c7 call 2021ed4 <== NOT EXECUTED 20163bc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20163c0: 81 c7 e0 08 ret <== NOT EXECUTED 20163c4: 81 e8 00 00 restore <== NOT EXECUTED return -1; } if (name) { 20163c8: 22 80 00 07 be,a 20163e4 <== NOT EXECUTED 20163cc: c2 16 a0 08 lduh [ %i2 + 8 ], %g1 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); 20163d0: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED 20163d4: 40 00 3d 40 call 20258d4 <== NOT EXECUTED 20163d8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20163dc: 10 80 00 04 b 20163ec <== NOT EXECUTED 20163e0: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); 20163e4: 82 18 40 19 xor %g1, %i1, %g1 <== NOT EXECUTED 20163e8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20163ec: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } if (match) { 20163f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20163f4: 02 bf ff e6 be 201638c <== NOT EXECUTED 20163f8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED fclose(fp); 20163fc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016400: 40 00 2e b5 call 2021ed4 <== NOT EXECUTED 2016404: b0 10 20 00 clr %i0 <== NOT EXECUTED *result = pwd; 2016408: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 201640c: 81 c7 e0 08 ret <== NOT EXECUTED 2016410: 81 e8 00 00 restore <== NOT EXECUTED 02015ff0 : return NULL; return p; } struct passwd *getpwent() { 2015ff0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (passwd_fp == NULL) 2015ff4: 03 00 80 e3 sethi %hi(0x2038c00), %g1 <== NOT EXECUTED 2015ff8: d0 00 62 d4 ld [ %g1 + 0x2d4 ], %o0 ! 2038ed4 <== NOT EXECUTED 2015ffc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016000: 02 80 00 0b be 201602c <== NOT EXECUTED 2016004: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 2016008: 21 00 80 e3 sethi %hi(0x2038c00), %l0 <== NOT EXECUTED 201600c: 92 14 23 a0 or %l0, 0x3a0, %o1 ! 2038fa0 <== NOT EXECUTED 2016010: 94 12 a2 d8 or %o2, 0x2d8, %o2 <== NOT EXECUTED 2016014: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2016018: 7f ff ff af call 2015ed4 <== NOT EXECUTED 201601c: b0 14 23 a0 or %l0, 0x3a0, %i0 <== NOT EXECUTED 2016020: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016024: 12 80 00 03 bne 2016030 <== NOT EXECUTED 2016028: 01 00 00 00 nop <== NOT EXECUTED 201602c: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED return NULL; return &pwent; } 2016030: 81 c7 e0 08 ret <== NOT EXECUTED 2016034: 81 e8 00 00 restore <== NOT EXECUTED 020164b8 : } struct passwd *getpwnam( const char *name ) { 20164b8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 20164bc: 13 00 80 e3 sethi %hi(0x2038c00), %o1 <== NOT EXECUTED 20164c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20164c4: 92 12 63 a0 or %o1, 0x3a0, %o1 <== NOT EXECUTED 20164c8: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED 20164cc: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 20164d0: 94 12 a2 d8 or %o2, 0x2d8, %o2 <== NOT EXECUTED 20164d4: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 20164d8: 7f ff ff ed call 201648c <== NOT EXECUTED 20164dc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20164e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20164e4: 22 80 00 02 be,a 20164ec <== NOT EXECUTED 20164e8: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 20164ec: 81 c7 e0 08 ret <== NOT EXECUTED 20164f0: 81 e8 00 00 restore <== NOT EXECUTED 0201648c : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 201648c: 82 10 00 0a mov %o2, %g1 <== NOT EXECUTED 2016490: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 2016494: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 2016498: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 201649c: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 20164a0: 98 10 00 02 mov %g2, %o4 <== NOT EXECUTED 20164a4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20164a8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20164ac: 7f ff ff a7 call 2016348 <== NOT EXECUTED 20164b0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20164b4: 01 00 00 00 nop 0201644c : } struct passwd *getpwuid( uid_t uid ) { 201644c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 2016450: 13 00 80 e3 sethi %hi(0x2038c00), %o1 <== NOT EXECUTED 2016454: 91 2e 20 10 sll %i0, 0x10, %o0 <== NOT EXECUTED 2016458: 92 12 63 a0 or %o1, 0x3a0, %o1 <== NOT EXECUTED 201645c: 91 32 20 10 srl %o0, 0x10, %o0 <== NOT EXECUTED 2016460: 15 00 80 e3 sethi %hi(0x2038c00), %o2 <== NOT EXECUTED 2016464: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2016468: 94 12 a2 d8 or %o2, 0x2d8, %o2 <== NOT EXECUTED 201646c: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 2016470: 7f ff ff e9 call 2016414 <== NOT EXECUTED 2016474: b0 10 20 00 clr %i0 <== NOT EXECUTED 2016478: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201647c: 22 80 00 02 be,a 2016484 <== NOT EXECUTED 2016480: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 2016484: 81 c7 e0 08 ret <== NOT EXECUTED 2016488: 81 e8 00 00 restore <== NOT EXECUTED 02016414 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 2016414: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED 2016418: 84 10 00 0a mov %o2, %g2 <== NOT EXECUTED 201641c: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 2016420: 93 2a 20 10 sll %o0, 0x10, %o1 <== NOT EXECUTED struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 2016424: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 2016428: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 201642c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED 2016430: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED 2016434: 98 10 00 03 mov %g3, %o4 <== NOT EXECUTED 2016438: 90 10 20 00 clr %o0 <== NOT EXECUTED 201643c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2016440: 7f ff ff c2 call 2016348 <== NOT EXECUTED 2016444: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2016448: 01 00 00 00 nop 0200b9c0 : int gettimeofday( struct timeval *tp, void * __tz ) { 200b9c0: 9d e3 bf 90 save %sp, -112, %sp /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 200b9c4: 80 a6 20 00 cmp %i0, 0 200b9c8: 12 80 00 08 bne 200b9e8 200b9cc: 01 00 00 00 nop errno = EFAULT; 200b9d0: 40 00 0a 84 call 200e3e0 <__errno> <== NOT EXECUTED 200b9d4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200b9d8: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED 200b9dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b9e0: 81 c7 e0 08 ret <== NOT EXECUTED 200b9e4: 81 e8 00 00 restore <== NOT EXECUTED ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 200b9e8: 7f ff d8 dd call 2001d5c 200b9ec: 01 00 00 00 nop 200b9f0: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 200b9f4: 7f ff ec 8f call 2006c30 <_TOD_Get> 200b9f8: 90 07 bf f0 add %fp, -16, %o0 _ISR_Enable(level); 200b9fc: 7f ff d8 dc call 2001d6c 200ba00: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200ba04: d0 07 bf f4 ld [ %fp + -12 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 200ba08: c2 07 bf f0 ld [ %fp + -16 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200ba0c: 92 10 23 e8 mov 0x3e8, %o1 200ba10: 40 00 26 11 call 2015254 <.udiv> 200ba14: c2 26 00 00 st %g1, [ %i0 ] 200ba18: 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; } 200ba1c: 81 c7 e0 08 ret 200ba20: 91 e8 20 00 restore %g0, 0, %o0 020164f4 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { 20164f4: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 20164f8: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2037710 <== NOT EXECUTED return _POSIX_types_Uid; } 20164fc: 81 c3 e0 08 retl <== NOT EXECUTED 2016500: d0 10 60 28 lduh [ %g1 + 0x28 ], %o0 <== NOT EXECUTED 0201f478 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 201f478: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 201f47c: e0 06 00 00 ld [ %i0 ], %l0 /* * You cannot remove a node that still has children */ if ( ! Chain_Is_empty( &the_jnode->info.directory.Entries ) ) 201f480: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 201f484: 82 04 20 50 add %l0, 0x50, %g1 201f488: 80 a0 80 01 cmp %g2, %g1 201f48c: 22 80 00 06 be,a 201f4a4 201f490: c2 06 20 0c ld [ %i0 + 0xc ], %g1 rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 201f494: 40 00 0a 3a call 2021d7c <__errno> 201f498: 01 00 00 00 nop 201f49c: 10 80 00 0d b 201f4d0 201f4a0: 82 10 20 5a mov 0x5a, %g1 ! 5a /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 201f4a4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 201f4a8: 80 a0 40 10 cmp %g1, %l0 201f4ac: 02 80 00 06 be 201f4c4 201f4b0: 01 00 00 00 nop /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 201f4b4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 201f4b8: 80 a0 60 00 cmp %g1, 0 201f4bc: 22 80 00 08 be,a 201f4dc 201f4c0: c2 04 20 08 ld [ %l0 + 8 ], %g1 rtems_set_errno_and_return_minus_one( EBUSY ); 201f4c4: 40 00 0a 2e call 2021d7c <__errno> 201f4c8: 01 00 00 00 nop 201f4cc: 82 10 20 10 mov 0x10, %g1 ! 10 201f4d0: c2 22 00 00 st %g1, [ %o0 ] 201f4d4: 81 c7 e0 08 ret 201f4d8: 91 e8 3f ff restore %g0, -1, %o0 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 201f4dc: 80 a0 60 00 cmp %g1, 0 201f4e0: 22 80 00 06 be,a 201f4f8 201f4e4: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 Chain_Extract( (Chain_Node *) the_jnode ); 201f4e8: 7f ff e2 b4 call 2017fb8 <_Chain_Extract> 201f4ec: 90 10 00 10 mov %l0, %o0 the_jnode->Parent = NULL; 201f4f0: c0 24 20 08 clr [ %l0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 201f4f4: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 201f4f8: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 201f4fc: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 201f500: 90 07 bf f0 add %fp, -16, %o0 201f504: 7f ff 92 35 call 2003dd8 201f508: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] 201f50c: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * 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) ) { 201f510: 90 10 00 10 mov %l0, %o0 201f514: 7f ff 92 9b call 2003f80 201f518: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 201f51c: 80 a2 20 00 cmp %o0, 0 201f520: 12 80 00 11 bne 201f564 201f524: 01 00 00 00 nop 201f528: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 201f52c: 80 a0 60 00 cmp %g1, 0 201f530: 12 80 00 0d bne 201f564 201f534: 03 00 80 dd sethi %hi(0x2037400), %g1 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 201f538: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 ! 2037710 201f53c: c4 06 00 00 ld [ %i0 ], %g2 201f540: c2 00 e0 04 ld [ %g3 + 4 ], %g1 201f544: 80 a0 40 02 cmp %g1, %g2 201f548: 22 80 00 02 be,a 201f550 201f54c: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 201f550: 90 10 00 10 mov %l0, %o0 201f554: 7f ff 93 2f call 2004210 201f558: b0 10 20 00 clr %i0 201f55c: 81 c7 e0 08 ret 201f560: 81 e8 00 00 restore } return 0; } 201f564: 81 c7 e0 08 ret 201f568: 91 e8 20 00 restore %g0, 0, %o0 02016038 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 2016038: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 201603c: 05 00 80 e3 sethi %hi(0x2038c00), %g2 <== NOT EXECUTED 2016040: c2 48 a2 d0 ldsb [ %g2 + 0x2d0 ], %g1 ! 2038ed0 <== NOT EXECUTED 2016044: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016048: 12 80 00 31 bne 201610c <== NOT EXECUTED 201604c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED return; etc_passwd_initted = 1; mkdir("/etc", 0777); 2016050: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 2016054: c2 28 a2 d0 stb %g1, [ %g2 + 0x2d0 ] <== NOT EXECUTED mkdir("/etc", 0777); 2016058: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 201605c: 40 00 01 2f call 2016518 <== NOT EXECUTED 2016060: 90 12 20 68 or %o0, 0x68, %o0 ! 2034468 <_CPU_Trap_slot_template+0xe70> <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 2016064: 31 00 80 d1 sethi %hi(0x2034400), %i0 <== NOT EXECUTED 2016068: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 201606c: 90 16 20 70 or %i0, 0x70, %o0 <== NOT EXECUTED 2016070: 40 00 31 97 call 20226cc <== NOT EXECUTED 2016074: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 2016078: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201607c: 12 80 00 0d bne 20160b0 <== NOT EXECUTED 2016080: 01 00 00 00 nop <== NOT EXECUTED fclose(fp); } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 2016084: 90 16 20 70 or %i0, 0x70, %o0 <== NOT EXECUTED 2016088: 13 00 80 cd sethi %hi(0x2033400), %o1 <== NOT EXECUTED 201608c: 40 00 31 90 call 20226cc <== NOT EXECUTED 2016090: 92 12 62 08 or %o1, 0x208, %o1 ! 2033608 <_CPU_Trap_slot_template+0x10> <== NOT EXECUTED 2016094: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2016098: 02 80 00 08 be 20160b8 <== NOT EXECUTED 201609c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 20160a0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20160a4: 40 00 31 df call 2022820 <== NOT EXECUTED 20160a8: 90 12 20 80 or %o0, 0x80, %o0 <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 20160ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20160b0: 40 00 2f 89 call 2021ed4 <== NOT EXECUTED 20160b4: 01 00 00 00 nop <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 20160b8: 31 00 80 d1 sethi %hi(0x2034400), %i0 <== NOT EXECUTED 20160bc: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 20160c0: 90 16 20 e8 or %i0, 0xe8, %o0 <== NOT EXECUTED 20160c4: 40 00 31 82 call 20226cc <== NOT EXECUTED 20160c8: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 20160cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20160d0: 22 80 00 04 be,a 20160e0 <== NOT EXECUTED 20160d4: 90 16 20 e8 or %i0, 0xe8, %o0 <== NOT EXECUTED fclose(fp); 20160d8: 10 80 00 0b b 2016104 <== NOT EXECUTED 20160dc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } else if ((fp = fopen("/etc/group", "w")) != NULL) { 20160e0: 13 00 80 cd sethi %hi(0x2033400), %o1 <== NOT EXECUTED 20160e4: 40 00 31 7a call 20226cc <== NOT EXECUTED 20160e8: 92 12 62 08 or %o1, 0x208, %o1 ! 2033608 <_CPU_Trap_slot_template+0x10> <== NOT EXECUTED 20160ec: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 20160f0: 02 80 00 07 be 201610c <== NOT EXECUTED 20160f4: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 20160f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20160fc: 40 00 31 c9 call 2022820 <== NOT EXECUTED 2016100: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 2016104: 40 00 2f 74 call 2021ed4 <== NOT EXECUTED 2016108: 81 e8 00 00 restore <== NOT EXECUTED 201610c: 81 c7 e0 08 ret <== NOT EXECUTED 2016110: 81 e8 00 00 restore <== NOT EXECUTED 02016110 : int ioctl( int fd, ioctl_command_t command, ... ) { 2016110: 9d e3 bf 90 save %sp, -112, %sp va_list ap; rtems_status_code rc; rtems_libio_t *iop; void *buffer; rtems_libio_check_fd( fd ); 2016114: 03 00 80 95 sethi %hi(0x2025400), %g1 2016118: c2 00 60 dc ld [ %g1 + 0xdc ], %g1 ! 20254dc int ioctl( int fd, ioctl_command_t command, ... ) { 201611c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2016120: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2016124: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2016128: f4 27 a0 4c st %i2, [ %fp + 0x4c ] va_list ap; rtems_status_code rc; rtems_libio_t *iop; void *buffer; rtems_libio_check_fd( fd ); 201612c: 80 a6 00 01 cmp %i0, %g1 2016130: 1a 80 00 14 bcc 2016180 2016134: 92 10 00 19 mov %i1, %o1 iop = rtems_libio_iop( fd ); 2016138: 03 00 80 9e sethi %hi(0x2027800), %g1 201613c: c6 00 60 84 ld [ %g1 + 0x84 ], %g3 ! 2027884 2016140: 85 2e 20 02 sll %i0, 2, %g2 2016144: 83 2e 20 04 sll %i0, 4, %g1 2016148: 82 20 40 02 sub %g1, %g2, %g1 201614c: 82 00 40 18 add %g1, %i0, %g1 2016150: 83 28 60 02 sll %g1, 2, %g1 2016154: 90 00 40 03 add %g1, %g3, %o0 rtems_libio_check_is_open(iop); 2016158: c2 02 20 0c ld [ %o0 + 0xc ], %g1 201615c: 80 88 61 00 btst 0x100, %g1 2016160: 02 80 00 08 be 2016180 2016164: 01 00 00 00 nop /* * Now process the ioctl(). */ if ( !iop->handlers ) 2016168: c4 02 20 30 ld [ %o0 + 0x30 ], %g2 iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); va_start(ap, command); buffer = va_arg(ap, void *); 201616c: 82 07 a0 50 add %fp, 0x50, %g1 2016170: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now process the ioctl(). */ if ( !iop->handlers ) 2016174: 80 a0 a0 00 cmp %g2, 0 2016178: 12 80 00 06 bne 2016190 201617c: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EBADF ); 2016180: 40 00 02 63 call 2016b0c <__errno> <== NOT EXECUTED 2016184: 01 00 00 00 nop <== NOT EXECUTED 2016188: 10 80 00 09 b 20161ac <== NOT EXECUTED 201618c: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED if ( !iop->handlers->ioctl_h ) 2016190: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2016194: 80 a0 60 00 cmp %g1, 0 2016198: 12 80 00 08 bne 20161b8 201619c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 20161a0: 40 00 02 5b call 2016b0c <__errno> <== NOT EXECUTED 20161a4: 01 00 00 00 nop <== NOT EXECUTED 20161a8: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 20161ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20161b0: 10 80 00 04 b 20161c0 <== NOT EXECUTED 20161b4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 20161b8: 9f c0 40 00 call %g1 20161bc: 01 00 00 00 nop return rc; } 20161c0: 81 c7 e0 08 ret 20161c4: 91 e8 00 08 restore %g0, %o0, %o0 02003ba8 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 2003ba8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 2003bac: c4 06 60 30 ld [ %i1 + 0x30 ], %g2 <== NOT EXECUTED 2003bb0: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED 2003bb4: 02 80 00 03 be 2003bc0 <== NOT EXECUTED 2003bb8: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED c &= 0x7f; 2003bbc: a2 0e 20 7f and %i0, 0x7f, %l1 <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 2003bc0: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED 2003bc4: 02 80 00 0b be 2003bf0 <== NOT EXECUTED 2003bc8: 82 0c 60 ff and %l1, 0xff, %g1 <== NOT EXECUTED c = tolower (c); 2003bcc: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 2003bd0: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 20180e0 <__ctype_ptr> <== NOT EXECUTED 2003bd4: 90 0c 60 ff and %l1, 0xff, %o0 <== NOT EXECUTED 2003bd8: c2 08 40 08 ldub [ %g1 + %o0 ], %g1 <== NOT EXECUTED 2003bdc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 2003be0: 32 80 00 02 bne,a 2003be8 <== NOT EXECUTED 2003be4: 90 02 20 20 add %o0, 0x20, %o0 <== NOT EXECUTED 2003be8: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED if (c == '\r') { 2003bec: 82 0c 60 ff and %l1, 0xff, %g1 <== NOT EXECUTED 2003bf0: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED 2003bf4: 12 80 00 09 bne 2003c18 <== NOT EXECUTED 2003bf8: 80 a0 60 0a cmp %g1, 0xa <== NOT EXECUTED if (tty->termios.c_iflag & IGNCR) 2003bfc: 80 88 a0 80 btst 0x80, %g2 <== NOT EXECUTED 2003c00: 12 80 00 59 bne 2003d64 <== NOT EXECUTED 2003c04: 80 88 a1 00 btst 0x100, %g2 <== NOT EXECUTED return 0; if (tty->termios.c_iflag & ICRNL) 2003c08: 32 80 00 0d bne,a 2003c3c <== NOT EXECUTED 2003c0c: a2 10 20 0a mov 0xa, %l1 <== NOT EXECUTED c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 2003c10: 10 80 00 0c b 2003c40 <== NOT EXECUTED 2003c14: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== 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)) { 2003c18: 12 80 00 07 bne 2003c34 <== NOT EXECUTED 2003c1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003c20: 80 88 a0 40 btst 0x40, %g2 <== NOT EXECUTED 2003c24: 32 80 00 06 bne,a 2003c3c <== NOT EXECUTED 2003c28: a2 10 20 0d mov 0xd, %l1 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 2003c2c: 10 80 00 05 b 2003c40 <== NOT EXECUTED 2003c30: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED 2003c34: 02 80 00 3a be 2003d1c <== NOT EXECUTED 2003c38: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2003c3c: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED 2003c40: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED 2003c44: 02 80 00 36 be 2003d1c <== NOT EXECUTED 2003c48: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 2003c4c: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1 <== NOT EXECUTED 2003c50: a0 0c 60 ff and %l1, 0xff, %l0 <== NOT EXECUTED erase (tty, 0); 2003c54: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { if (c == tty->termios.c_cc[VERASE]) { 2003c58: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2003c5c: 02 80 00 08 be 2003c7c <== NOT EXECUTED 2003c60: 92 10 20 00 clr %o1 <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 2003c64: c2 0e 60 44 ldub [ %i1 + 0x44 ], %g1 <== NOT EXECUTED 2003c68: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2003c6c: 32 80 00 07 bne,a 2003c88 <== NOT EXECUTED 2003c70: c2 0e 60 45 ldub [ %i1 + 0x45 ], %g1 <== NOT EXECUTED erase (tty, 1); 2003c74: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2003c78: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2003c7c: 7f ff ff 3e call 2003974 <== NOT EXECUTED 2003c80: b0 10 20 00 clr %i0 <== NOT EXECUTED 2003c84: 30 80 00 39 b,a 2003d68 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VEOF]) { 2003c88: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2003c8c: 02 80 00 37 be 2003d68 <== NOT EXECUTED 2003c90: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return 1; } else if (c == '\n') { 2003c94: 80 a4 20 0a cmp %l0, 0xa <== NOT EXECUTED 2003c98: 32 80 00 0d bne,a 2003ccc <== NOT EXECUTED 2003c9c: c2 0e 60 4c ldub [ %i1 + 0x4c ], %g1 <== NOT EXECUTED if (tty->termios.c_lflag & (ECHO | ECHONL)) 2003ca0: 80 88 a0 48 btst 0x48, %g2 <== NOT EXECUTED 2003ca4: 22 80 00 06 be,a 2003cbc <== NOT EXECUTED 2003ca8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED echo (c, tty); 2003cac: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED 2003cb0: 7f ff ff 0f call 20038ec <== NOT EXECUTED 2003cb4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2003cb8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED 2003cbc: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED 2003cc0: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED 2003cc4: 10 80 00 13 b 2003d10 <== NOT EXECUTED 2003cc8: e0 28 80 01 stb %l0, [ %g2 + %g1 ] <== NOT EXECUTED return 1; } else if ((c == tty->termios.c_cc[VEOL]) 2003ccc: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2003cd0: 02 80 00 07 be 2003cec <== NOT EXECUTED 2003cd4: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED 2003cd8: c2 0e 60 51 ldub [ %i1 + 0x51 ], %g1 <== NOT EXECUTED 2003cdc: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2003ce0: 12 80 00 0f bne 2003d1c <== NOT EXECUTED 2003ce4: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 2003ce8: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED 2003cec: 22 80 00 06 be,a 2003d04 <== NOT EXECUTED 2003cf0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED echo (c, tty); 2003cf4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2003cf8: 7f ff fe fd call 20038ec <== NOT EXECUTED 2003cfc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2003d00: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED 2003d04: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED 2003d08: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED 2003d0c: e2 28 80 01 stb %l1, [ %g2 + %g1 ] <== NOT EXECUTED 2003d10: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED 2003d14: 81 c7 e0 08 ret <== NOT EXECUTED 2003d18: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 2003d1c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2 <== NOT EXECUTED 2003d20: c2 00 60 9c ld [ %g1 + 0x9c ], %g1 <== NOT EXECUTED 2003d24: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003d28: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2003d2c: 16 80 00 0f bge 2003d68 <== NOT EXECUTED 2003d30: b0 10 20 00 clr %i0 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 2003d34: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 2003d38: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED 2003d3c: 22 80 00 06 be,a 2003d54 <== NOT EXECUTED 2003d40: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED echo (c, tty); 2003d44: 90 0c 60 ff and %l1, 0xff, %o0 <== NOT EXECUTED 2003d48: 7f ff fe e9 call 20038ec <== NOT EXECUTED 2003d4c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2003d50: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED 2003d54: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED 2003d58: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED 2003d5c: e2 28 80 01 stb %l1, [ %g2 + %g1 ] <== NOT EXECUTED 2003d60: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED 2003d64: b0 10 20 00 clr %i0 <== NOT EXECUTED } return 0; } 2003d68: 81 c7 e0 08 ret <== NOT EXECUTED 2003d6c: 81 e8 00 00 restore <== NOT EXECUTED 02020f60 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 2020f60: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 2020f64: 7f ff ff 15 call 2020bb8 2020f68: 01 00 00 00 nop 2020f6c: 80 a6 00 08 cmp %i0, %o0 2020f70: 02 80 00 06 be 2020f88 2020f74: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 2020f78: 7f ff d6 e5 call 2016b0c <__errno> 2020f7c: 01 00 00 00 nop 2020f80: 10 80 00 07 b 2020f9c 2020f84: 82 10 20 03 mov 3, %g1 ! 3 /* * Validate the signal passed. */ if ( !sig ) 2020f88: 12 80 00 08 bne 2020fa8 2020f8c: 82 06 7f ff add %i1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 2020f90: 7f ff d6 df call 2016b0c <__errno> 2020f94: 01 00 00 00 nop 2020f98: 82 10 20 16 mov 0x16, %g1 ! 16 2020f9c: c2 22 00 00 st %g1, [ %o0 ] 2020fa0: 10 80 00 bc b 2021290 2020fa4: 90 10 3f ff mov -1, %o0 if ( !is_valid_signo(sig) ) 2020fa8: 80 a0 60 1f cmp %g1, 0x1f 2020fac: 18 bf ff f9 bgu 2020f90 2020fb0: 83 2e 60 02 sll %i1, 2, %g1 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 2020fb4: 85 2e 60 04 sll %i1, 4, %g2 2020fb8: 84 20 80 01 sub %g2, %g1, %g2 2020fbc: 03 00 80 a0 sethi %hi(0x2028000), %g1 2020fc0: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 2020fc4: 84 00 80 01 add %g2, %g1, %g2 2020fc8: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2020fcc: 80 a0 60 01 cmp %g1, 1 2020fd0: 02 80 00 b0 be 2021290 2020fd4: 90 10 20 00 clr %o0 * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ switch ( sig ) { 2020fd8: 80 a6 60 0b cmp %i1, 0xb 2020fdc: 18 80 00 0d bgu 2021010 2020fe0: 84 10 20 01 mov 1, %g2 2020fe4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2020fe8: 83 28 40 19 sll %g1, %i1, %g1 <== NOT EXECUTED 2020fec: 80 88 69 10 btst 0x910, %g1 <== NOT EXECUTED 2020ff0: 22 80 00 09 be,a 2021014 <== NOT EXECUTED 2020ff4: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED case SIGFPE: case SIGILL: case SIGSEGV: return pthread_kill( pthread_self(), sig ); 2020ff8: 40 00 01 4c call 2021528 <== NOT EXECUTED 2020ffc: 01 00 00 00 nop <== NOT EXECUTED 2021000: 40 00 01 09 call 2021424 <== NOT EXECUTED 2021004: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 2021008: 81 c7 e0 08 ret <== NOT EXECUTED 202100c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 2021010: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 2021014: c4 27 bf f0 st %g2, [ %fp + -16 ] return pthread_kill( pthread_self(), sig ); default: break; } mask = signo_to_mask( sig ); 2021018: 82 06 7f ff add %i1, -1, %g1 */ siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { 202101c: 80 a6 a0 00 cmp %i2, 0 2021020: 12 80 00 04 bne 2021030 2021024: b1 28 80 01 sll %g2, %g1, %i0 siginfo->si_value.sival_int = 0; 2021028: 10 80 00 04 b 2021038 202102c: c0 27 bf f4 clr [ %fp + -12 ] } else { siginfo->si_value = *value; 2021030: c2 06 80 00 ld [ %i2 ], %g1 2021034: c2 27 bf f4 st %g1, [ %fp + -12 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2021038: 05 00 80 9e sethi %hi(0x2027800), %g2 202103c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2021040: 82 00 60 01 inc %g1 2021044: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 2021048: 03 00 80 9e sethi %hi(0x2027800), %g1 202104c: c4 00 63 30 ld [ %g1 + 0x330 ], %g2 ! 2027b30 <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 2021050: c2 00 a1 74 ld [ %g2 + 0x174 ], %g1 2021054: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 2021058: 80 ae 00 01 andncc %i0, %g1, %g0 202105c: 12 80 00 65 bne 20211f0 2021060: 03 00 80 a0 sethi %hi(0x2028000), %g1 goto process_it; 2021064: 88 10 62 f4 or %g1, 0x2f4, %g4 ! 20282f4 <_POSIX_signals_Wait_queue> */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 2021068: 98 01 20 30 add %g4, 0x30, %o4 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 202106c: c2 01 00 00 ld [ %g4 ], %g1 !_Chain_Is_tail( the_chain, the_node ) ; 2021070: 10 80 00 0b b 202109c 2021074: 9a 01 20 04 add %g4, 4, %o5 the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 2021078: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 202107c: 80 8e 00 01 btst %i0, %g1 2021080: 12 80 00 5c bne 20211f0 2021084: c6 00 a1 74 ld [ %g2 + 0x174 ], %g3 2021088: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 <== NOT EXECUTED 202108c: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 2021090: 12 80 00 59 bne 20211f4 <== NOT EXECUTED 2021094: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 2021098: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 202109c: 80 a0 40 0d cmp %g1, %o5 20210a0: 12 bf ff f6 bne 2021078 20210a4: 84 10 00 01 mov %g1, %g2 20210a8: 88 01 20 0c add %g4, 0xc, %g4 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210ac: 80 a1 00 0c cmp %g4, %o4 20210b0: 32 bf ff f0 bne,a 2021070 20210b4: c2 01 00 00 ld [ %g4 ], %g1 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 20210b8: 03 00 80 9e sethi %hi(0x2027800), %g1 20210bc: ae 10 61 b0 or %g1, 0x1b0, %l7 ! 20279b0 <_Objects_Information_table> continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 20210c0: 03 00 80 95 sethi %hi(0x2025400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210c4: a0 10 20 00 clr %l0 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 20210c8: ac 10 60 00 mov %g1, %l6 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210cc: b4 10 20 02 mov 2, %i2 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 20210d0: 03 00 80 95 sethi %hi(0x2025400), %g1 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 20210d4: a4 10 21 00 mov 0x100, %l2 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 20210d8: aa 10 60 48 or %g1, 0x48, %l5 * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 20210dc: 10 80 00 04 b 20210ec 20210e0: 29 04 00 00 sethi %hi(0x10000000), %l4 for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) 20210e4: 22 80 00 3d be,a 20211d8 20210e8: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 20210ec: 83 2e a0 02 sll %i2, 2, %g1 20210f0: c2 05 c0 01 ld [ %l7 + %g1 ], %g1 20210f4: 80 a0 60 00 cmp %g1, 0 20210f8: 22 80 00 38 be,a 20211d8 20210fc: b4 06 a0 01 inc %i2 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 2021100: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( !the_info ) /* manager not installed */ 2021104: 80 a0 60 00 cmp %g1, 0 2021108: 22 80 00 34 be,a 20211d8 202110c: b4 06 a0 01 inc %i2 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; 2021110: e2 00 60 20 ld [ %g1 + 0x20 ], %l1 assert( object_table ); /* always at least 1 entry */ 2021114: 80 a4 60 00 cmp %l1, 0 2021118: 12 80 00 06 bne 2021130 202111c: e6 10 60 10 lduh [ %g1 + 0x10 ], %l3 2021120: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED 2021124: 92 10 20 c1 mov 0xc1, %o1 <== NOT EXECUTED 2021128: 7f ff 93 a3 call 2005fb4 <__assert> <== NOT EXECUTED 202112c: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED 2021130: 10 80 00 26 b 20211c8 2021134: 9a 10 20 01 mov 1, %o5 for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 2021138: c4 00 40 11 ld [ %g1 + %l1 ], %g2 if ( !the_thread ) 202113c: 80 a0 a0 00 cmp %g2, 0 2021140: 22 80 00 22 be,a 20211c8 2021144: 9a 03 60 01 inc %o5 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 2021148: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4 202114c: 80 a1 00 12 cmp %g4, %l2 2021150: 38 80 00 1e bgu,a 20211c8 2021154: 9a 03 60 01 inc %o5 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2021158: c2 00 a1 74 ld [ %g2 + 0x174 ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 202115c: 80 a0 60 00 cmp %g1, 0 2021160: 22 80 00 1a be,a 20211c8 2021164: 9a 03 60 01 inc %o5 <== NOT EXECUTED 2021168: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 202116c: 80 ae 00 01 andncc %i0, %g1, %g0 2021170: 22 80 00 16 be,a 20211c8 2021174: 9a 03 60 01 inc %o5 * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 2021178: 80 a1 00 12 cmp %g4, %l2 202117c: 2a 80 00 11 bcs,a 20211c0 2021180: a0 10 00 02 mov %g2, %l0 * Now the thread and the interested thread have the same priority. * If the interested thread is ready, then we don't need to send it * to a blocked thread. */ if ( _States_Is_ready( interested_thread->current_state ) ) 2021184: c6 04 20 10 ld [ %l0 + 0x10 ], %g3 <== NOT EXECUTED 2021188: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 202118c: 22 80 00 0f be,a 20211c8 <== NOT EXECUTED 2021190: 9a 03 60 01 inc %o5 <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 2021194: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED 2021198: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 202119c: 22 80 00 09 be,a 20211c0 <== NOT EXECUTED 20211a0: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 20211a4: 80 88 c0 14 btst %g3, %l4 <== NOT EXECUTED 20211a8: 32 80 00 08 bne,a 20211c8 <== NOT EXECUTED 20211ac: 9a 03 60 01 inc %o5 <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 20211b0: 80 88 40 14 btst %g1, %l4 <== NOT EXECUTED 20211b4: 22 80 00 05 be,a 20211c8 <== NOT EXECUTED 20211b8: 9a 03 60 01 inc %o5 <== NOT EXECUTED 20211bc: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED 20211c0: a4 10 00 04 mov %g4, %l2 maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ for ( index = 1 ; index <= maximum ; index++ ) { 20211c4: 9a 03 60 01 inc %o5 20211c8: 80 a3 40 13 cmp %o5, %l3 20211cc: 08 bf ff db bleu 2021138 20211d0: 83 2b 60 02 sll %o5, 2, %g1 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 20211d4: b4 06 a0 01 inc %i2 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; 20211d8: 80 a6 a0 04 cmp %i2, 4 20211dc: 08 bf ff c2 bleu 20210e4 20211e0: 80 a6 a0 01 cmp %i2, 1 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 20211e4: 80 a4 20 00 cmp %l0, 0 20211e8: 02 80 00 0b be 2021214 20211ec: 84 10 00 10 mov %l0, %g2 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 20211f0: 82 10 20 01 mov 1, %g1 /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 20211f4: 90 10 00 02 mov %g2, %o0 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 20211f8: c2 20 a0 78 st %g1, [ %g2 + 0x78 ] /* * Returns TRUE if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 20211fc: 92 10 00 19 mov %i1, %o1 2021200: 40 00 00 37 call 20212dc <_POSIX_signals_Unblock_thread> 2021204: 94 07 bf ec add %fp, -20, %o2 2021208: 80 a2 20 00 cmp %o0, 0 202120c: 12 80 00 1e bne 2021284 2021210: 01 00 00 00 nop /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 2021214: 40 00 00 22 call 202129c <_POSIX_signals_Set_process_signals> 2021218: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 202121c: 83 2e 60 02 sll %i1, 2, %g1 2021220: 85 2e 60 04 sll %i1, 4, %g2 2021224: b2 20 80 01 sub %g2, %g1, %i1 2021228: 03 00 80 a0 sethi %hi(0x2028000), %g1 202122c: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 2021230: c2 00 40 19 ld [ %g1 + %i1 ], %g1 2021234: 80 a0 60 02 cmp %g1, 2 2021238: 12 80 00 13 bne 2021284 202123c: 11 00 80 a0 sethi %hi(0x2028000), %o0 psiginfo = (POSIX_signals_Siginfo_node *) 2021240: 7f ff a7 ac call 200b0f0 <_Chain_Get> 2021244: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 20282e8 <_POSIX_signals_Inactive_siginfo> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 2021248: b4 92 20 00 orcc %o0, 0, %i2 202124c: 12 80 00 06 bne 2021264 2021250: 92 07 bf ec add %fp, -20, %o1 rtems_set_errno_and_return_minus_one( EAGAIN ); 2021254: 7f ff d6 2e call 2016b0c <__errno> <== NOT EXECUTED 2021258: 01 00 00 00 nop <== NOT EXECUTED 202125c: 10 bf ff 50 b 2020f9c <== NOT EXECUTED 2021260: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED } psiginfo->Info = *siginfo; 2021264: 90 06 a0 08 add %i2, 8, %o0 2021268: 7f ff dc 1b call 20182d4 202126c: 94 10 20 0c mov 0xc, %o2 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 2021270: 11 00 80 a0 sethi %hi(0x2028000), %o0 2021274: 92 10 00 1a mov %i2, %o1 2021278: 90 12 23 38 or %o0, 0x338, %o0 202127c: 7f ff a7 91 call 200b0c0 <_Chain_Append> 2021280: 90 06 40 08 add %i1, %o0, %o0 } _Thread_Enable_dispatch(); 2021284: 7f ff ff 2a call 2020f2c <_Thread_Enable_dispatch> 2021288: 01 00 00 00 nop 202128c: 90 10 20 00 clr %o0 ! 0 return 0; } 2021290: b0 10 00 08 mov %o0, %i0 2021294: 81 c7 e0 08 ret 2021298: 81 e8 00 00 restore 020161a0 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 20161a0: 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())) 20161a4: 03 00 80 63 sethi %hi(0x2018c00), %g1 20161a8: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 20161ac: 80 a0 60 03 cmp %g1, 3 20161b0: 12 80 00 15 bne 2016204 20161b4: 21 00 80 60 sethi %hi(0x2018000), %l0 /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 20161b8: c4 04 20 e8 ld [ %l0 + 0xe8 ], %g2 ! 20180e8 <_impure_ptr> 20161bc: 03 00 80 5e sethi %hi(0x2017800), %g1 20161c0: b0 10 60 98 or %g1, 0x98, %i0 ! 2017898 20161c4: 80 a0 80 18 cmp %g2, %i0 20161c8: 02 80 00 06 be 20161e0 20161cc: c2 04 20 e8 ld [ %l0 + 0xe8 ], %g1 _wrapup_reent(&libc_global_reent); 20161d0: 40 00 00 a1 call 2016454 <_wrapup_reent> 20161d4: 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; 20161d8: f0 24 20 e8 st %i0, [ %l0 + 0xe8 ] * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 20161dc: c2 04 20 e8 ld [ %l0 + 0xe8 ], %g1 20161e0: 7f ff e0 d6 call 200e538 20161e4: d0 00 60 04 ld [ %g1 + 4 ], %o0 fclose (stdout); 20161e8: c2 04 20 e8 ld [ %l0 + 0xe8 ], %g1 20161ec: 7f ff e0 d3 call 200e538 20161f0: d0 00 60 08 ld [ %g1 + 8 ], %o0 fclose (stderr); 20161f4: c2 04 20 e8 ld [ %l0 + 0xe8 ], %g1 20161f8: f0 00 60 0c ld [ %g1 + 0xc ], %i0 20161fc: 7f ff e0 cf call 200e538 2016200: 81 e8 00 00 restore 2016204: 81 c7 e0 08 ret <== NOT EXECUTED 2016208: 81 e8 00 00 restore <== NOT EXECUTED 02003810 : int link( const char *existing, const char *new ) { 2003810: 9d e3 bf 70 save %sp, -144, %sp /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, TRUE ); 2003814: 92 10 20 00 clr %o1 2003818: 90 10 00 18 mov %i0, %o0 200381c: 94 07 bf e4 add %fp, -28, %o2 2003820: 96 10 20 01 mov 1, %o3 2003824: 7f ff fe a8 call 20032c4 2003828: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 200382c: 80 a2 20 00 cmp %o0, 0 2003830: 12 80 00 8e bne 2003a68 2003834: 01 00 00 00 nop /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 2003838: c2 4e 40 00 ldsb [ %i1 ], %g1 200383c: 80 a0 60 2f cmp %g1, 0x2f 2003840: 02 80 00 06 be 2003858 2003844: 80 a0 60 5c cmp %g1, 0x5c 2003848: 02 80 00 04 be 2003858 200384c: 80 a0 60 00 cmp %g1, 0 2003850: 12 80 00 0a bne 2003878 2003854: 03 00 80 64 sethi %hi(0x2019000), %g1 2003858: 03 00 80 64 sethi %hi(0x2019000), %g1 200385c: d2 00 60 70 ld [ %g1 + 0x70 ], %o1 ! 2019070 2003860: 90 07 bf d4 add %fp, -44, %o0 2003864: 92 02 60 14 add %o1, 0x14, %o1 2003868: 40 00 36 cc call 2011398 200386c: 94 10 20 10 mov 0x10, %o2 2003870: 10 80 00 08 b 2003890 2003874: 84 10 20 01 mov 1, %g2 2003878: d2 00 60 70 ld [ %g1 + 0x70 ], %o1 200387c: 90 07 bf d4 add %fp, -44, %o0 2003880: 92 02 60 04 add %o1, 4, %o1 2003884: 40 00 36 c5 call 2011398 2003888: 94 10 20 10 mov 0x10, %o2 200388c: 84 10 20 00 clr %g2 if ( !parent_loc.ops->evalformake_h ) { 2003890: c2 07 bf dc ld [ %fp + -36 ], %g1 2003894: c2 00 60 04 ld [ %g1 + 4 ], %g1 2003898: 80 a0 60 00 cmp %g1, 0 200389c: 12 80 00 0b bne 20038c8 20038a0: 90 06 40 02 add %i1, %g2, %o0 rtems_filesystem_freenode( &existing_loc ); 20038a4: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 20038a8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20038ac: 02 80 00 51 be 20039f0 <== NOT EXECUTED 20038b0: 01 00 00 00 nop <== NOT EXECUTED 20038b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20038b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20038bc: 12 80 00 4b bne 20039e8 <== NOT EXECUTED 20038c0: 90 07 bf e4 add %fp, -28, %o0 <== NOT EXECUTED 20038c4: 30 80 00 4b b,a 20039f0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 20038c8: b0 07 bf d4 add %fp, -44, %i0 20038cc: 94 07 bf f4 add %fp, -12, %o2 20038d0: 9f c0 40 00 call %g1 20038d4: 92 10 00 18 mov %i0, %o1 if ( result != 0 ) { 20038d8: b2 92 20 00 orcc %o0, 0, %i1 20038dc: 02 80 00 11 be 2003920 20038e0: c4 07 bf e0 ld [ %fp + -32 ], %g2 rtems_filesystem_freenode( &existing_loc ); 20038e4: c2 07 bf ec ld [ %fp + -20 ], %g1 20038e8: 80 a0 60 00 cmp %g1, 0 20038ec: 02 80 00 08 be 200390c 20038f0: 01 00 00 00 nop 20038f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20038f8: 80 a0 60 00 cmp %g1, 0 20038fc: 02 80 00 04 be 200390c 2003900: 01 00 00 00 nop 2003904: 9f c0 40 00 call %g1 2003908: 90 07 bf e4 add %fp, -28, %o0 rtems_set_errno_and_return_minus_one( result ); 200390c: 40 00 34 c2 call 2010c14 <__errno> 2003910: b0 10 3f ff mov -1, %i0 2003914: f2 22 00 00 st %i1, [ %o0 ] 2003918: 81 c7 e0 08 ret 200391c: 81 e8 00 00 restore /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 2003920: c2 07 bf f0 ld [ %fp + -16 ], %g1 2003924: 80 a0 80 01 cmp %g2, %g1 2003928: 02 80 00 1a be 2003990 200392c: c2 07 bf dc ld [ %fp + -36 ], %g1 rtems_filesystem_freenode( &existing_loc ); 2003930: c2 07 bf ec ld [ %fp + -20 ], %g1 2003934: 80 a0 60 00 cmp %g1, 0 2003938: 22 80 00 09 be,a 200395c 200393c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003940: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003944: 80 a0 60 00 cmp %g1, 0 2003948: 22 80 00 05 be,a 200395c 200394c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003950: 9f c0 40 00 call %g1 2003954: 90 07 bf e4 add %fp, -28, %o0 rtems_filesystem_freenode( &parent_loc ); 2003958: c2 07 bf dc ld [ %fp + -36 ], %g1 200395c: 80 a0 60 00 cmp %g1, 0 2003960: 02 80 00 08 be 2003980 2003964: 01 00 00 00 nop 2003968: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200396c: 80 a0 60 00 cmp %g1, 0 2003970: 02 80 00 04 be 2003980 2003974: 01 00 00 00 nop 2003978: 9f c0 40 00 call %g1 200397c: 90 07 bf d4 add %fp, -44, %o0 rtems_set_errno_and_return_minus_one( EXDEV ); 2003980: 40 00 34 a5 call 2010c14 <__errno> 2003984: b0 10 3f ff mov -1, %i0 2003988: 10 80 00 1d b 20039fc 200398c: 82 10 20 12 mov 0x12, %g1 } if ( !parent_loc.ops->link_h ) { 2003990: c2 00 60 08 ld [ %g1 + 8 ], %g1 2003994: 80 a0 60 00 cmp %g1, 0 2003998: 12 80 00 1c bne 2003a08 200399c: d4 07 bf f4 ld [ %fp + -12 ], %o2 rtems_filesystem_freenode( &existing_loc ); 20039a0: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 20039a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20039a8: 22 80 00 09 be,a 20039cc <== NOT EXECUTED 20039ac: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 20039b0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20039b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20039b8: 22 80 00 05 be,a 20039cc <== NOT EXECUTED 20039bc: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 20039c0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20039c4: 90 07 bf e4 add %fp, -28, %o0 <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 20039c8: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 20039cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20039d0: 02 80 00 08 be 20039f0 <== NOT EXECUTED 20039d4: 01 00 00 00 nop <== NOT EXECUTED 20039d8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20039dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20039e0: 02 80 00 04 be 20039f0 <== NOT EXECUTED 20039e4: 90 07 bf d4 add %fp, -44, %o0 <== NOT EXECUTED 20039e8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20039ec: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 20039f0: 40 00 34 89 call 2010c14 <__errno> <== NOT EXECUTED 20039f4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 20039f8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 20039fc: c2 22 00 00 st %g1, [ %o0 ] 2003a00: 81 c7 e0 08 ret 2003a04: 81 e8 00 00 restore } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 2003a08: 92 10 00 18 mov %i0, %o1 2003a0c: b2 07 bf e4 add %fp, -28, %i1 2003a10: 9f c0 40 00 call %g1 2003a14: 90 10 00 19 mov %i1, %o0 rtems_filesystem_freenode( &existing_loc ); 2003a18: c2 07 bf ec ld [ %fp + -20 ], %g1 2003a1c: 80 a0 60 00 cmp %g1, 0 2003a20: 02 80 00 08 be 2003a40 2003a24: b0 10 00 08 mov %o0, %i0 2003a28: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003a2c: 80 a0 60 00 cmp %g1, 0 2003a30: 22 80 00 05 be,a 2003a44 2003a34: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003a38: 9f c0 40 00 call %g1 2003a3c: 90 10 00 19 mov %i1, %o0 rtems_filesystem_freenode( &parent_loc ); 2003a40: c2 07 bf dc ld [ %fp + -36 ], %g1 2003a44: 80 a0 60 00 cmp %g1, 0 2003a48: 02 80 00 08 be 2003a68 2003a4c: 01 00 00 00 nop 2003a50: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003a54: 80 a0 60 00 cmp %g1, 0 2003a58: 02 80 00 04 be 2003a68 2003a5c: 01 00 00 00 nop 2003a60: 9f c0 40 00 call %g1 2003a64: 90 07 bf d4 add %fp, -44, %o0 return result; } 2003a68: 81 c7 e0 08 ret 2003a6c: 81 e8 00 00 restore 02016090 : off_t lseek( int fd, off_t offset, int whence ) { 2016090: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 2016094: 03 00 80 5d sethi %hi(0x2017400), %g1 2016098: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 201779c off_t lseek( int fd, off_t offset, int whence ) { 201609c: 92 10 00 19 mov %i1, %o1 rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 20160a0: 80 a6 00 01 cmp %i0, %g1 20160a4: 1a 80 00 0e bcc 20160dc 20160a8: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 20160ac: 03 00 80 62 sethi %hi(0x2018800), %g1 20160b0: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 20160b4: 85 2e 20 02 sll %i0, 2, %g2 20160b8: 83 2e 20 04 sll %i0, 4, %g1 20160bc: 82 20 40 02 sub %g1, %g2, %g1 20160c0: 82 00 40 18 add %g1, %i0, %g1 20160c4: 83 28 60 02 sll %g1, 2, %g1 20160c8: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 20160cc: c2 06 20 0c ld [ %i0 + 0xc ], %g1 20160d0: 80 88 61 00 btst 0x100, %g1 20160d4: 32 80 00 06 bne,a 20160ec 20160d8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 20160dc: 7f ff e0 c1 call 200e3e0 <__errno> <== NOT EXECUTED 20160e0: 01 00 00 00 nop <== NOT EXECUTED 20160e4: 10 80 00 1c b 2016154 <== NOT EXECUTED 20160e8: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 20160ec: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 20160f0: 80 a0 60 00 cmp %g1, 0 20160f4: 12 80 00 06 bne 201610c 20160f8: 80 a6 a0 01 cmp %i2, 1 rtems_set_errno_and_return_minus_one( ENOTSUP ); 20160fc: 7f ff e0 b9 call 200e3e0 <__errno> <== NOT EXECUTED 2016100: 01 00 00 00 nop <== NOT EXECUTED 2016104: 10 80 00 14 b 2016154 <== NOT EXECUTED 2016108: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; switch ( whence ) { 201610c: 02 80 00 09 be 2016130 2016110: f4 06 20 08 ld [ %i0 + 8 ], %i2 2016114: 80 a2 a0 02 cmp %o2, 2 2016118: 02 80 00 08 be 2016138 201611c: 80 a2 a0 00 cmp %o2, 0 2016120: 12 80 00 0a bne 2016148 2016124: 01 00 00 00 nop case SEEK_SET: iop->offset = offset; 2016128: 10 80 00 0e b 2016160 201612c: f2 26 20 08 st %i1, [ %i0 + 8 ] break; case SEEK_CUR: iop->offset += offset; 2016130: 10 80 00 04 b 2016140 2016134: 82 06 40 1a add %i1, %i2, %g1 break; case SEEK_END: iop->offset = iop->size + offset; 2016138: c2 06 20 04 ld [ %i0 + 4 ], %g1 201613c: 82 06 40 01 add %i1, %g1, %g1 2016140: 10 80 00 08 b 2016160 2016144: c2 26 20 08 st %g1, [ %i0 + 8 ] break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2016148: 7f ff e0 a6 call 200e3e0 <__errno> 201614c: 01 00 00 00 nop 2016150: 82 10 20 16 mov 0x16, %g1 ! 16 2016154: c2 22 00 00 st %g1, [ %o0 ] 2016158: 10 80 00 09 b 201617c 201615c: 90 10 3f ff mov -1, %o0 /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 2016160: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2016164: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 2016168: 9f c0 40 00 call %g1 201616c: 90 10 00 18 mov %i0, %o0 if ( status == (off_t) -1 ) 2016170: 80 a2 3f ff cmp %o0, -1 2016174: 22 80 00 02 be,a 201617c 2016178: f4 26 20 08 st %i2, [ %i0 + 8 ] /* * So if the operation failed, we have to restore iop->offset. */ return status; } 201617c: 81 c7 e0 08 ret 2016180: 91 e8 00 08 restore %g0, %o0, %o0 0200229c : #ifdef RTEMS_NEWLIB void *malloc( size_t size ) { 200229c: 9d e3 bf 98 save %sp, -104, %sp uint32_t sbrk_amount; Chain_Node *to_be_freed; MSBUMP(malloc_calls, 1); if ( !size ) 20022a0: a4 96 20 00 orcc %i0, 0, %l2 20022a4: 02 80 00 41 be 20023a8 20022a8: 03 00 80 63 sethi %hi(0x2018c00), %g1 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 20022ac: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 20022b0: 80 a0 60 03 cmp %g1, 3 20022b4: 12 80 00 10 bne 20022f4 20022b8: 03 00 80 62 sethi %hi(0x2018800), %g1 if (_Thread_Dispatch_disable_level > 0) 20022bc: 03 00 80 62 sethi %hi(0x2018800), %g1 20022c0: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20022c4: 80 a0 60 00 cmp %g1, 0 20022c8: 12 80 00 36 bne 20023a0 20022cc: b0 10 20 00 clr %i0 return (void *) 0; if (_ISR_Nest_level > 0) 20022d0: 03 00 80 62 sethi %hi(0x2018800), %g1 20022d4: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 2018bb8 <_ISR_Nest_level> 20022d8: 80 a0 60 00 cmp %g1, 0 20022dc: 02 80 00 06 be 20022f4 20022e0: 03 00 80 62 sethi %hi(0x2018800), %g1 20022e4: 30 80 00 32 b,a 20023ac <== NOT EXECUTED /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = Chain_Get(&RTEMS_Malloc_GC_list)) != NULL) free(to_be_freed); 20022e8: 7f ff ff c5 call 20021fc 20022ec: 01 00 00 00 nop 20022f0: 30 80 00 02 b,a 20022f8 } /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = Chain_Get(&RTEMS_Malloc_GC_list)) != NULL) 20022f4: a0 10 61 88 or %g1, 0x188, %l0 20022f8: 40 00 11 67 call 2006894 <_Chain_Get> 20022fc: 90 10 00 10 mov %l0, %o0 2002300: 80 a2 20 00 cmp %o0, 0 2002304: 12 bf ff f9 bne 20022e8 2002308: 23 00 80 62 sethi %hi(0x2018800), %l1 */ #ifdef MALLOC_ARENA_CHECK size += sizeof(struct mallocNode) + SENTINELSIZE; #endif return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 200230c: 92 10 00 12 mov %l2, %o1 2002310: 40 00 16 24 call 2007ba0 <_Protected_heap_Allocate> 2002314: 90 14 61 2c or %l1, 0x12c, %o0 if ( !return_this ) { 2002318: b0 92 20 00 orcc %o0, 0, %i0 200231c: 12 80 00 21 bne 20023a0 2002320: 03 00 80 62 sethi %hi(0x2018800), %g1 * Round to the "requested sbrk amount" so hopefully we won't have * to grow again for a while. This effectively does sbrk() calls * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; 2002324: e0 00 61 84 ld [ %g1 + 0x184 ], %l0 ! 2018984 <== NOT EXECUTED if ( sbrk_amount == 0 ) 2002328: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 200232c: 02 80 00 1d be 20023a0 <== NOT EXECUTED 2002330: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 2002334: 40 00 4b c8 call 2015254 <.udiv> <== NOT EXECUTED 2002338: 90 04 80 10 add %l2, %l0, %o0 <== NOT EXECUTED 200233c: 40 00 4b 8c call 201516c <.umul> <== NOT EXECUTED 2002340: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if ((starting_address = (void *)sbrk(the_size)) 2002344: 40 00 4f 01 call 2015f48 <== NOT EXECUTED 2002348: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 200234c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 2002350: 02 80 00 14 be 20023a0 <== NOT EXECUTED 2002354: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED == (void*) -1) return (void *) 0; if ( !_Protected_heap_Extend( 2002358: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 200235c: 40 00 16 a2 call 2007de4 <_Protected_heap_Extend> <== NOT EXECUTED 2002360: 90 14 61 2c or %l1, 0x12c, %o0 <== NOT EXECUTED 2002364: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002368: 12 80 00 05 bne 200237c <== NOT EXECUTED 200236c: 90 14 61 2c or %l1, 0x12c, %o0 <== NOT EXECUTED &RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 2002370: 40 00 4e f6 call 2015f48 <== NOT EXECUTED 2002374: 90 20 00 10 neg %l0, %o0 <== NOT EXECUTED 2002378: 30 80 00 06 b,a 2002390 <== NOT EXECUTED return (void *) 0; } MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 200237c: 40 00 16 09 call 2007ba0 <_Protected_heap_Allocate> <== NOT EXECUTED 2002380: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED if ( !return_this ) { 2002384: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2002388: 12 80 00 09 bne 20023ac <== NOT EXECUTED 200238c: 01 00 00 00 nop <== NOT EXECUTED errno = ENOMEM; 2002390: 40 00 30 14 call 200e3e0 <__errno> <== NOT EXECUTED 2002394: 01 00 00 00 nop <== NOT EXECUTED 2002398: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 200239c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20023a0: 81 c7 e0 08 ret 20023a4: 81 e8 00 00 restore return (void *) 0; 20023a8: b0 10 20 00 clr %i0 mallocNodeHead.forw = mp; rtems_interrupt_enable(key); } #endif return return_this; } 20023ac: 81 c7 e0 08 ret 20023b0: 81 e8 00 00 restore 020041e0 : /* * Find amount of free heap remaining */ size_t malloc_free_space( void ) { 20041e0: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED Heap_Information info; _Protected_heap_Get_free_information( &RTEMS_Malloc_Heap, &info ); 20041e4: 11 00 80 e6 sethi %hi(0x2039800), %o0 <== NOT EXECUTED 20041e8: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED 20041ec: 40 00 1a 08 call 200aa0c <_Protected_heap_Get_free_information> <== NOT EXECUTED 20041f0: 90 12 21 3c or %o0, 0x13c, %o0 <== NOT EXECUTED return (size_t) info.largest; } 20041f4: f0 07 bf f0 ld [ %fp + -16 ], %i0 <== NOT EXECUTED 20041f8: 81 c7 e0 08 ret <== NOT EXECUTED 20041fc: 81 e8 00 00 restore <== NOT EXECUTED 020190e8 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 20190e8: 9d e3 bf 98 save %sp, -104, %sp /* * 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) ) { 20190ec: 7f ff ab a5 call 2003f80 20190f0: 90 10 00 18 mov %i0, %o0 20190f4: 80 a2 20 00 cmp %o0, 0 20190f8: 12 80 00 13 bne 2019144 20190fc: 01 00 00 00 nop 2019100: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 2019104: 80 a0 60 00 cmp %g1, 0 2019108: 12 80 00 0f bne 2019144 201910c: 03 00 80 dd sethi %hi(0x2037400), %g1 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 2019110: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2037710 2019114: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2019118: 80 a0 40 18 cmp %g1, %i0 201911c: 22 80 00 02 be,a 2019124 2019120: c0 20 a0 04 clr [ %g2 + 4 ] <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 2019124: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2019128: 80 a0 60 06 cmp %g1, 6 201912c: 02 80 00 04 be 201913c 2019130: 01 00 00 00 nop IMFS_memfile_remove( the_jnode ); 2019134: 7f ff ff 84 call 2018f44 2019138: 90 10 00 18 mov %i0, %o0 free( the_jnode ); 201913c: 7f ff ac 35 call 2004210 2019140: 90 10 00 18 mov %i0, %o0 } return 0; } 2019144: 81 c7 e0 08 ret 2019148: 91 e8 20 00 restore %g0, 0, %o0 02018ed4 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 2018ed4: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( block_table ); 2018ed8: 80 a6 20 00 cmp %i0, 0 2018edc: 32 80 00 08 bne,a 2018efc 2018ee0: e2 06 00 00 ld [ %i0 ], %l1 2018ee4: 31 00 80 d1 sethi %hi(0x2034400), %i0 <== NOT EXECUTED 2018ee8: 35 00 80 d1 sethi %hi(0x2034400), %i2 <== NOT EXECUTED 2018eec: b0 16 21 68 or %i0, 0x168, %i0 <== NOT EXECUTED 2018ef0: b4 16 a1 f0 or %i2, 0x1f0, %i2 <== NOT EXECUTED 2018ef4: 7f ff aa fe call 2003aec <__assert> <== NOT EXECUTED 2018ef8: 93 e8 21 b1 restore %g0, 0x1b1, %o1 <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 2018efc: a0 10 20 00 clr %l0 2018f00: 10 80 00 09 b 2018f24 2018f04: b4 10 20 00 clr %i2 for ( i=0 ; i 2018f10: a0 04 20 01 inc %l0 memfile_free_block( b[i] ); 2018f14: 7f ff ff 1e call 2018b8c 2018f18: 01 00 00 00 nop b[i] = 0; 2018f1c: c0 26 80 11 clr [ %i2 + %l1 ] * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i 2018f2c: d0 06 80 11 ld [ %i2 + %l1 ], %o0 /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 2018f30: 7f ff ff 17 call 2018b8c 2018f34: d0 06 00 00 ld [ %i0 ], %o0 *block_table = 0; 2018f38: c0 26 00 00 clr [ %i0 ] } 2018f3c: 81 c7 e0 08 ret 2018f40: 81 e8 00 00 restore 020193d4 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 20193d4: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 20193d8: e0 06 20 2c ld [ %i0 + 0x2c ], %l0 * POSIX 1003.1b does not specify what happens if you truncate a file * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) 20193dc: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 20193e0: 80 a6 40 01 cmp %i1, %g1 20193e4: 04 80 00 06 ble 20193fc 20193e8: 92 10 00 19 mov %i1, %o1 return IMFS_memfile_extend( the_jnode, length ); 20193ec: 7f ff ff a6 call 2019284 <== NOT EXECUTED 20193f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 20193f4: 81 c7 e0 08 ret <== NOT EXECUTED 20193f8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * The in-memory files do not currently reclaim memory until the file is * deleted. So we leave the previously allocated blocks in place for * future use and just set the length. */ the_jnode->info.file.size = length; 20193fc: f2 24 20 4c st %i1, [ %l0 + 0x4c ] iop->size = the_jnode->info.file.size; 2019400: f2 26 20 04 st %i1, [ %i0 + 4 ] IMFS_update_atime( the_jnode ); 2019404: 90 07 bf f0 add %fp, -16, %o0 2019408: 7f ff aa 74 call 2003dd8 201940c: 92 10 20 00 clr %o1 2019410: c2 07 bf f0 ld [ %fp + -16 ], %g1 2019414: 90 10 20 00 clr %o0 2019418: c2 24 20 3c st %g1, [ %l0 + 0x3c ] return 0; } 201941c: b0 10 00 08 mov %o0, %i0 2019420: 81 c7 e0 08 ret 2019424: 81 e8 00 00 restore 02019428 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 2019428: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 201942c: e0 06 20 2c ld [ %i0 + 0x2c ], %l0 if (the_jnode->type == IMFS_LINEAR_FILE) { 2019430: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2019434: 80 a0 60 06 cmp %g1, 6 2019438: 12 80 00 09 bne 201945c 201943c: d2 06 20 08 ld [ %i0 + 8 ], %o1 if (iop->offset > the_jnode->info.linearfile.size) 2019440: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 <== NOT EXECUTED 2019444: 80 a2 40 08 cmp %o1, %o0 <== NOT EXECUTED 2019448: 34 80 00 11 bg,a 201948c <== NOT EXECUTED 201944c: d0 26 20 08 st %o0, [ %i0 + 8 ] <== NOT EXECUTED 2019450: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 2019454: 81 c7 e0 08 ret <== NOT EXECUTED 2019458: 81 e8 00 00 restore <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 201945c: 7f ff ff 8a call 2019284 2019460: 90 10 00 10 mov %l0, %o0 2019464: 80 a2 20 00 cmp %o0, 0 2019468: 22 80 00 08 be,a 2019488 201946c: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 rtems_set_errno_and_return_minus_one( ENOSPC ); 2019470: 40 00 22 43 call 2021d7c <__errno> <== NOT EXECUTED 2019474: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2019478: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED 201947c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019480: 81 c7 e0 08 ret <== NOT EXECUTED 2019484: 81 e8 00 00 restore <== NOT EXECUTED iop->size = the_jnode->info.file.size; 2019488: c2 26 20 04 st %g1, [ %i0 + 4 ] } return iop->offset; 201948c: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 2019490: 81 c7 e0 08 ret 2019494: 81 e8 00 00 restore 02019730 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 2019730: 9d e3 bf 98 save %sp, -104, %sp the_jnode = iop->file_info; /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 2019734: c2 06 20 0c ld [ %i0 + 0xc ], %g1 rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 2019738: a2 10 00 18 mov %i0, %l1 the_jnode = iop->file_info; /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 201973c: 80 88 62 04 btst 0x204, %g1 2019740: 02 80 00 17 be 201979c 2019744: e0 06 20 2c ld [ %i0 + 0x2c ], %l0 2019748: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 201974c: 80 a0 60 06 cmp %g1, 6 2019750: 32 80 00 14 bne,a 20197a0 2019754: c2 04 60 0c ld [ %l1 + 0xc ], %g1 && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 2019758: d6 04 20 4c ld [ %l0 + 0x4c ], %o3 <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 201975c: d4 04 20 50 ld [ %l0 + 0x50 ], %o2 <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 2019760: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED the_jnode->info.file.size = 0; the_jnode->info.file.indirect = 0; the_jnode->info.file.doubly_indirect = 0; 2019764: c0 24 20 54 clr [ %l0 + 0x54 ] <== NOT EXECUTED && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; const unsigned char *buffer = the_jnode->info.linearfile.direct; the_jnode->type = IMFS_MEMORY_FILE; the_jnode->info.file.size = 0; 2019768: c0 24 20 4c clr [ %l0 + 0x4c ] <== NOT EXECUTED the_jnode->info.file.indirect = 0; the_jnode->info.file.doubly_indirect = 0; the_jnode->info.file.triply_indirect = 0; 201976c: c0 24 20 58 clr [ %l0 + 0x58 ] <== NOT EXECUTED uint32_t count = the_jnode->info.linearfile.size; const unsigned char *buffer = the_jnode->info.linearfile.direct; the_jnode->type = IMFS_MEMORY_FILE; the_jnode->info.file.size = 0; the_jnode->info.file.indirect = 0; 2019770: c0 24 20 50 clr [ %l0 + 0x50 ] <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; the_jnode->info.file.triply_indirect = 0; if ((count != 0) 2019774: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 2019778: 02 80 00 09 be 201979c <== NOT EXECUTED 201977c: c2 24 20 48 st %g1, [ %l0 + 0x48 ] <== NOT EXECUTED 2019780: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2019784: 92 10 20 00 clr %o1 <== NOT EXECUTED 2019788: 7f ff ff 44 call 2019498 <== NOT EXECUTED 201978c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2019790: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 2019794: 02 80 00 0a be 20197bc <== NOT EXECUTED 2019798: 01 00 00 00 nop <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 201979c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 20197a0: 80 88 62 00 btst 0x200, %g1 20197a4: 02 80 00 04 be 20197b4 20197a8: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 iop->offset = the_jnode->info.file.size; 20197ac: c2 24 60 08 st %g1, [ %l1 + 8 ] iop->size = the_jnode->info.file.size; 20197b0: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 20197b4: b0 10 20 00 clr %i0 20197b8: c2 24 60 04 st %g1, [ %l1 + 4 ] return 0; } 20197bc: 81 c7 e0 08 ret 20197c0: 81 e8 00 00 restore 02019a40 : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 2019a40: 82 10 00 09 mov %o1, %g1 IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return IMFS_memfile_read( the_jnode, iop->offset, buffer, count ); 2019a44: d2 02 20 08 ld [ %o0 + 8 ], %o1 2019a48: d0 02 20 2c ld [ %o0 + 0x2c ], %o0 ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 2019a4c: 96 10 00 0a mov %o2, %o3 IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return IMFS_memfile_read( the_jnode, iop->offset, buffer, count ); 2019a50: 94 10 00 01 mov %g1, %o2 2019a54: 82 13 c0 00 mov %o7, %g1 2019a58: 7f ff ff 5b call 20197c4 2019a5c: 9e 10 40 00 mov %g1, %o7 2019a60: 01 00 00 00 nop <== NOT EXECUTED 0201914c : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 201914c: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 2019150: f0 06 00 00 ld [ %i0 ], %i0 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 2019154: c2 06 20 08 ld [ %i0 + 8 ], %g1 2019158: 80 a0 60 00 cmp %g1, 0 201915c: 22 80 00 06 be,a 2019174 2019160: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Chain_Extract( (Chain_Node *) the_jnode ); 2019164: 7f ff fb 95 call 2017fb8 <_Chain_Extract> 2019168: 90 10 00 18 mov %i0, %o0 the_jnode->Parent = NULL; 201916c: c0 26 20 08 clr [ %i0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 2019170: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 2019174: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 2019178: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 201917c: 90 07 bf f0 add %fp, -16, %o0 2019180: 7f ff ab 16 call 2003dd8 2019184: c2 36 20 30 sth %g1, [ %i0 + 0x30 ] 2019188: c2 07 bf f0 ld [ %fp + -16 ], %g1 return memfile_check_rmnod( the_jnode ); 201918c: 90 10 00 18 mov %i0, %o0 2019190: 7f ff ff d6 call 20190e8 2019194: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } 2019198: 81 c7 e0 08 ret 201919c: 91 e8 00 08 restore %g0, %o0, %o0 0200a9f8 : int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { return IMFS_initialize_support( 200a9f8: 13 00 80 5f sethi %hi(0x2017c00), %o1 200a9fc: 15 00 80 61 sethi %hi(0x2018400), %o2 200aa00: 92 12 60 f4 or %o1, 0xf4, %o1 200aa04: 94 12 a3 1c or %o2, 0x31c, %o2 200aa08: 96 10 00 0a mov %o2, %o3 200aa0c: 82 13 c0 00 mov %o7, %g1 200aa10: 40 00 02 6b call 200b3bc 200aa14: 9e 10 40 00 mov %g1, %o7 200aa18: 01 00 00 00 nop <== NOT EXECUTED 02002600 : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 2002600: 9d e3 bf 80 save %sp, -128, %sp rtems_filesystem_location_info_t temp_loc; int i; const char *name_start; int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) 2002604: 03 00 00 3c sethi %hi(0xf000), %g1 2002608: b3 2e 60 10 sll %i1, 0x10, %i1 200260c: b3 36 60 10 srl %i1, 0x10, %i1 2002610: 84 8e 40 01 andcc %i1, %g1, %g2 2002614: 32 80 00 06 bne,a 200262c 2002618: 03 00 00 04 sethi %hi(0x1000), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 200261c: 40 00 2f 71 call 200e3e0 <__errno> <== NOT EXECUTED 2002620: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002624: 10 80 00 35 b 20026f8 <== NOT EXECUTED 2002628: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED if ( S_ISFIFO(mode) ) 200262c: 80 a0 80 01 cmp %g2, %g1 2002630: 02 80 00 2f be 20026ec 2002634: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 2002638: c2 4e 00 00 ldsb [ %i0 ], %g1 200263c: 80 a0 60 2f cmp %g1, 0x2f 2002640: 02 80 00 06 be 2002658 2002644: 80 a0 60 5c cmp %g1, 0x5c 2002648: 02 80 00 04 be 2002658 200264c: 80 a0 60 00 cmp %g1, 0 2002650: 12 80 00 0a bne 2002678 2002654: 03 00 80 5f sethi %hi(0x2017c00), %g1 2002658: 03 00 80 5f sethi %hi(0x2017c00), %g1 200265c: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 ! 2017db8 2002660: 90 07 bf e4 add %fp, -28, %o0 2002664: 92 02 60 14 add %o1, 0x14, %o1 2002668: 40 00 31 33 call 200eb34 200266c: 94 10 20 10 mov 0x10, %o2 2002670: 10 80 00 08 b 2002690 2002674: 84 10 20 01 mov 1, %g2 2002678: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 200267c: 90 07 bf e4 add %fp, -28, %o0 2002680: 92 02 60 04 add %o1, 4, %o1 2002684: 40 00 31 2c call 200eb34 2002688: 94 10 20 10 mov 0x10, %o2 200268c: 84 10 20 00 clr %g2 if ( !temp_loc.ops->evalformake_h ) { 2002690: c2 07 bf ec ld [ %fp + -20 ], %g1 2002694: c2 00 60 04 ld [ %g1 + 4 ], %g1 2002698: 80 a0 60 00 cmp %g1, 0 200269c: 02 80 00 14 be 20026ec 20026a0: 90 06 00 02 add %i0, %g2, %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 20026a4: a0 07 bf e4 add %fp, -28, %l0 20026a8: 94 07 bf f4 add %fp, -12, %o2 20026ac: 92 10 00 10 mov %l0, %o1 20026b0: 9f c0 40 00 call %g1 20026b4: b0 10 3f ff mov -1, %i0 &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 20026b8: 80 a2 20 00 cmp %o0, 0 20026bc: 12 80 00 10 bne 20026fc 20026c0: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !temp_loc.ops->mknod_h ) { 20026c4: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 20026c8: 80 a0 a0 00 cmp %g2, 0 20026cc: 12 80 00 0e bne 2002704 20026d0: d0 07 bf f4 ld [ %fp + -12 ], %o0 rtems_filesystem_freenode( &temp_loc ); 20026d4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20026d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20026dc: 02 80 00 04 be 20026ec <== NOT EXECUTED 20026e0: 01 00 00 00 nop <== NOT EXECUTED 20026e4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20026e8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 20026ec: 40 00 2f 3d call 200e3e0 <__errno> 20026f0: b0 10 3f ff mov -1, %i0 20026f4: 82 10 20 86 mov 0x86, %g1 20026f8: c2 22 00 00 st %g1, [ %o0 ] 20026fc: 81 c7 e0 08 ret 2002700: 81 e8 00 00 restore } result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 2002704: 92 10 00 19 mov %i1, %o1 2002708: 94 10 00 1a mov %i2, %o2 200270c: 96 10 00 1b mov %i3, %o3 2002710: 9f c0 80 00 call %g2 2002714: 98 10 00 10 mov %l0, %o4 rtems_filesystem_freenode( &temp_loc ); 2002718: c2 07 bf ec ld [ %fp + -20 ], %g1 200271c: 80 a0 60 00 cmp %g1, 0 2002720: 02 bf ff f7 be 20026fc 2002724: b0 10 00 08 mov %o0, %i0 2002728: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200272c: 80 a0 60 00 cmp %g1, 0 2002730: 02 80 00 04 be 2002740 2002734: 01 00 00 00 nop 2002738: 9f c0 40 00 call %g1 200273c: 90 10 00 10 mov %l0, %o0 return result; } 2002740: 81 c7 e0 08 ret 2002744: 81 e8 00 00 restore 0200bd4c : rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, char *device, char *mount_point ) { 200bd4c: 9d e3 bf 88 save %sp, -120, %sp /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 200bd50: 80 a6 60 00 cmp %i1, 0 200bd54: 02 80 00 05 be 200bd68 200bd58: a2 10 00 18 mov %i0, %l1 /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 200bd5c: 80 a6 a0 01 cmp %i2, 1 200bd60: 28 80 00 06 bleu,a 200bd78 200bd64: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 200bd68: 40 00 09 9e call 200e3e0 <__errno> 200bd6c: 01 00 00 00 nop 200bd70: 10 80 00 17 b 200bdcc 200bd74: 82 10 20 16 mov 0x16, %g1 ! 16 return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 200bd78: 80 a0 60 00 cmp %g1, 0 200bd7c: 12 80 00 07 bne 200bd98 200bd80: 80 a6 e0 00 cmp %i3, 0 errno = ENOTSUP; 200bd84: 40 00 09 97 call 200e3e0 <__errno> <== NOT EXECUTED 200bd88: b4 10 20 00 clr %i2 <== NOT EXECUTED 200bd8c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 200bd90: 10 80 00 77 b 200bf6c <== NOT EXECUTED 200bd94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 200bd98: 02 80 00 05 be 200bdac 200bd9c: 90 10 20 64 mov 0x64, %o0 size += strlen( device ) + 1; 200bda0: 40 00 0e 6e call 200f758 <== NOT EXECUTED 200bda4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 200bda8: 90 02 20 65 add %o0, 0x65, %o0 <== NOT EXECUTED temp_mt_entry = malloc( size ); 200bdac: 7f ff d9 3c call 200229c 200bdb0: 01 00 00 00 nop if ( !temp_mt_entry ) { 200bdb4: a0 92 20 00 orcc %o0, 0, %l0 200bdb8: 32 80 00 07 bne,a 200bdd4 200bdbc: f4 24 20 28 st %i2, [ %l0 + 0x28 ] errno = ENOMEM; 200bdc0: 40 00 09 88 call 200e3e0 <__errno> <== NOT EXECUTED 200bdc4: 01 00 00 00 nop <== NOT EXECUTED 200bdc8: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 200bdcc: 10 80 00 78 b 200bfac 200bdd0: c2 22 00 00 st %g1, [ %o0 ] return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 200bdd4: e0 24 20 24 st %l0, [ %l0 + 0x24 ] temp_mt_entry->options = options; if ( device ) { 200bdd8: 80 a6 e0 00 cmp %i3, 0 200bddc: 02 80 00 08 be 200bdfc 200bde0: b4 10 00 10 mov %l0, %i2 temp_mt_entry->dev = 200bde4: 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 ); 200bde8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 200bdec: 40 00 0e 3b call 200f6d8 <== NOT EXECUTED 200bdf0: 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 ) { 200bdf4: 10 80 00 04 b 200be04 <== NOT EXECUTED 200bdf8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED if ( device ) { temp_mt_entry->dev = (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); strcpy( temp_mt_entry->dev, device ); } else temp_mt_entry->dev = 0; 200bdfc: c0 24 20 60 clr [ %l0 + 0x60 ] /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 200be00: 80 a7 20 00 cmp %i4, 0 200be04: 02 80 00 3b be 200bef0 200be08: 90 10 00 1c mov %i4, %o0 if ( rtems_filesystem_evaluate_path( 200be0c: 92 10 20 07 mov 7, %o1 200be10: b8 07 bf e8 add %fp, -24, %i4 200be14: 96 10 20 01 mov 1, %o3 200be18: 7f ff d8 73 call 2001fe4 200be1c: 94 10 00 1c mov %i4, %o2 200be20: 80 a2 3f ff cmp %o0, -1 200be24: 02 80 00 52 be 200bf6c 200be28: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 200be2c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 200be30: 80 a0 60 00 cmp %g1, 0 200be34: 12 80 00 06 bne 200be4c 200be38: 01 00 00 00 nop errno = ENOTSUP; 200be3c: 40 00 09 69 call 200e3e0 <__errno> <== NOT EXECUTED 200be40: 01 00 00 00 nop <== 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; 200be44: 10 80 00 0a b 200be6c <== NOT EXECUTED 200be48: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 200be4c: 9f c0 40 00 call %g1 200be50: 90 10 00 1c mov %i4, %o0 200be54: 80 a2 20 01 cmp %o0, 1 200be58: 02 80 00 07 be 200be74 200be5c: 03 00 80 64 sethi %hi(0x2019000), %g1 errno = ENOTDIR; 200be60: 40 00 09 60 call 200e3e0 <__errno> 200be64: 01 00 00 00 nop 200be68: 82 10 20 14 mov 0x14, %g1 ! 14 200be6c: 10 80 00 41 b 200bf70 200be70: c2 22 00 00 st %g1, [ %o0 ] for ( the_node = rtems_filesystem_mount_table_control.first; !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node; if ( the_mount_entry->mt_fs_root.node_access == loc->node_access ) 200be74: c8 07 bf e8 ld [ %fp + -24 ], %g4 /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 200be78: c4 00 61 78 ld [ %g1 + 0x178 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200be7c: 03 00 80 64 sethi %hi(0x2019000), %g1 200be80: 10 80 00 06 b 200be98 200be84: 86 10 61 7c or %g1, 0x17c, %g3 ! 201917c !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node; if ( the_mount_entry->mt_fs_root.node_access == loc->node_access ) 200be88: 80 a0 40 04 cmp %g1, %g4 200be8c: 02 80 00 08 be 200beac 200be90: 01 00 00 00 nop * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 200be94: c4 00 80 00 ld [ %g2 ], %g2 /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); 200be98: 80 a0 80 03 cmp %g2, %g3 200be9c: 32 bf ff fb bne,a 200be88 200bea0: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 * 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; 200bea4: 10 80 00 44 b 200bfb4 200bea8: c4 07 bf ec ld [ %fp + -20 ], %g2 /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 200beac: 40 00 09 4d call 200e3e0 <__errno> 200beb0: b8 07 bf e8 add %fp, -24, %i4 200beb4: 10 bf ff ee b 200be6c 200beb8: 82 10 20 10 mov 0x10, %g1 * 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; 200bebc: 40 00 09 49 call 200e3e0 <__errno> <== NOT EXECUTED 200bec0: b8 07 bf e8 add %fp, -24, %i4 <== NOT EXECUTED 200bec4: 10 bf ff ea b 200be6c <== NOT EXECUTED 200bec8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 200becc: 9f c0 c0 00 call %g3 200bed0: 90 10 00 10 mov %l0, %o0 200bed4: 80 a2 20 00 cmp %o0, 0 200bed8: 02 80 00 04 be 200bee8 200bedc: 90 07 bf e8 add %fp, -24, %o0 200bee0: 10 80 00 24 b 200bf70 <== NOT EXECUTED 200bee4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED 200bee8: 10 80 00 0a b 200bf10 200beec: b8 10 00 08 mov %o0, %i4 * 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; 200bef0: c0 24 20 18 clr [ %l0 + 0x18 ] temp_mt_entry->mt_fs_root.handlers = NULL; 200bef4: c0 24 20 1c clr [ %l0 + 0x1c ] temp_mt_entry->mt_fs_root.ops = NULL; 200bef8: c0 24 20 20 clr [ %l0 + 0x20 ] temp_mt_entry->mt_point_node.node_access = NULL; 200befc: c0 24 20 08 clr [ %l0 + 8 ] temp_mt_entry->mt_point_node.handlers = NULL; 200bf00: c0 24 20 0c clr [ %l0 + 0xc ] temp_mt_entry->mt_point_node.ops = NULL; 200bf04: c0 24 20 10 clr [ %l0 + 0x10 ] temp_mt_entry->mt_point_node.mt_entry = NULL; 200bf08: c0 24 20 14 clr [ %l0 + 0x14 ] 200bf0c: b8 10 20 00 clr %i4 } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 200bf10: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 200bf14: 9f c0 40 00 call %g1 200bf18: 90 10 00 10 mov %l0, %o0 200bf1c: 80 a2 20 00 cmp %o0, 0 200bf20: 02 80 00 09 be 200bf44 200bf24: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 200bf28: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 <== NOT EXECUTED 200bf2c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200bf30: 02 80 00 10 be 200bf70 <== NOT EXECUTED 200bf34: 01 00 00 00 nop <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 200bf38: 9f c0 40 00 call %g1 <== NOT EXECUTED 200bf3c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200bf40: 30 80 00 0c b,a 200bf70 <== NOT EXECUTED /* * Add the mount table entry to the mount table chain */ Chain_Append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); 200bf44: 11 00 80 64 sethi %hi(0x2019000), %o0 200bf48: 92 10 00 10 mov %l0, %o1 200bf4c: 7f ff ea 46 call 2006864 <_Chain_Append> 200bf50: 90 12 21 78 or %o0, 0x178, %o0 if ( mt_entry ) 200bf54: 80 a4 60 00 cmp %l1, 0 200bf58: 02 80 00 03 be 200bf64 200bf5c: b0 10 20 00 clr %i0 *mt_entry = temp_mt_entry; 200bf60: e0 24 40 00 st %l0, [ %l1 ] 200bf64: 81 c7 e0 08 ret 200bf68: 81 e8 00 00 restore 200bf6c: b8 10 20 00 clr %i4 <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 200bf70: 7f ff d8 a3 call 20021fc 200bf74: 90 10 00 1a mov %i2, %o0 if ( loc_to_free ) 200bf78: 80 a7 20 00 cmp %i4, 0 200bf7c: 02 80 00 0c be 200bfac 200bf80: 01 00 00 00 nop rtems_filesystem_freenode( loc_to_free ); 200bf84: c2 07 20 08 ld [ %i4 + 8 ], %g1 200bf88: 80 a0 60 00 cmp %g1, 0 200bf8c: 02 80 00 08 be 200bfac 200bf90: 01 00 00 00 nop 200bf94: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200bf98: 80 a0 60 00 cmp %g1, 0 200bf9c: 02 80 00 04 be 200bfac 200bfa0: 01 00 00 00 nop 200bfa4: 9f c0 40 00 call %g1 200bfa8: 90 10 00 1c mov %i4, %o0 200bfac: 81 c7 e0 08 ret 200bfb0: 91 e8 3f ff restore %g0, -1, %o0 * 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; 200bfb4: c2 07 bf f0 ld [ %fp + -16 ], %g1 * 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; 200bfb8: c4 24 20 0c st %g2, [ %l0 + 0xc ] temp_mt_entry->mt_point_node.ops = loc.ops; temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 200bfbc: c4 07 bf f4 ld [ %fp + -12 ], %g2 /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ 200bfc0: c6 00 60 20 ld [ %g1 + 0x20 ], %g3 * 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; 200bfc4: c8 24 20 08 st %g4, [ %l0 + 8 ] temp_mt_entry->mt_point_node.handlers = loc.handlers; temp_mt_entry->mt_point_node.ops = loc.ops; temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 200bfc8: c4 24 20 14 st %g2, [ %l0 + 0x14 ] /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ 200bfcc: 80 a0 e0 00 cmp %g3, 0 200bfd0: 12 bf ff bf bne 200becc 200bfd4: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 200bfd8: 30 bf ff b9 b,a 200bebc <== NOT EXECUTED 02009878 : */ int mq_close( mqd_t mqdes ) { 2009878: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) 200987c: 21 00 80 8f sethi %hi(0x2023c00), %l0 2009880: 92 10 00 18 mov %i0, %o1 2009884: 94 07 bf f4 add %fp, -12, %o2 2009888: 40 00 12 6e call 200e240 <_Objects_Get> 200988c: 90 14 23 20 or %l0, 0x320, %o0 POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009890: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009894: 80 a0 60 01 cmp %g1, 1 2009898: 02 80 00 0e be 20098d0 200989c: b0 10 00 08 mov %o0, %i0 20098a0: 80 a0 60 01 cmp %g1, 1 20098a4: 2a 80 00 11 bcs,a 20098e8 20098a8: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 20098ac: 80 a0 60 02 cmp %g1, 2 20098b0: 12 80 00 2f bne 200996c 20098b4: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 20098b8: 40 00 2f 37 call 2015594 <__errno> 20098bc: 01 00 00 00 nop 20098c0: 82 10 20 09 mov 9, %g1 ! 9 20098c4: c2 22 00 00 st %g1, [ %o0 ] 20098c8: 10 80 00 2b b 2009974 20098cc: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 20098d0: 40 00 17 22 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 20098d4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 20098d8: 40 00 07 53 call 200b624 <== NOT EXECUTED 20098dc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 20098e0: 81 c7 e0 08 ret <== NOT EXECUTED 20098e4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; the_mq->open_count -= 1; 20098e8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _POSIX_Message_queue_Delete( the_mq ); 20098ec: 90 10 00 02 mov %g2, %o0 * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; the_mq->open_count -= 1; 20098f0: 82 00 7f ff add %g1, -1, %g1 _POSIX_Message_queue_Delete( the_mq ); 20098f4: 40 00 00 23 call 2009980 <_POSIX_Message_queue_Delete> 20098f8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20098fc: 90 14 23 20 or %l0, 0x320, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2009900: c4 06 20 08 ld [ %i0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009904: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2009908: 03 00 00 3f sethi %hi(0xfc00), %g1 200990c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009910: 82 08 80 01 and %g2, %g1, %g1 2009914: 80 a0 40 03 cmp %g1, %g3 2009918: 38 80 00 06 bgu,a 2009930 200991c: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2009920: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2009924: 83 28 60 02 sll %g1, 2, %g1 2009928: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200992c: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free_fd ( POSIX_Message_queue_Control_fd *the_mq_fd ) { _Objects_Free( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); 2009930: 40 00 12 02 call 200e138 <_Objects_Free> 2009934: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2009938: 03 00 80 8e sethi %hi(0x2023800), %g1 200993c: c4 00 61 50 ld [ %g1 + 0x150 ], %g2 ! 2023950 <_Thread_Dispatch_disable_level> 2009940: 90 10 20 00 clr %o0 2009944: 84 00 bf ff add %g2, -1, %g2 2009948: c4 20 61 50 st %g2, [ %g1 + 0x150 ] 200994c: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 2009950: 80 a0 60 00 cmp %g1, 0 2009954: 32 80 00 09 bne,a 2009978 2009958: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200995c: 40 00 16 ff call 200f558 <_Thread_Dispatch> 2009960: 01 00 00 00 nop 2009964: 10 80 00 04 b 2009974 2009968: 90 10 20 00 clr %o0 ! 0 _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200996c: 40 00 07 24 call 200b5fc <== NOT EXECUTED 2009970: 01 00 00 00 nop <== NOT EXECUTED } 2009974: b0 10 00 08 mov %o0, %i0 2009978: 81 c7 e0 08 ret 200997c: 81 e8 00 00 restore 02009a10 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 2009a10: 9d e3 bf 90 save %sp, -112, %sp POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 2009a14: 80 a6 60 00 cmp %i1, 0 2009a18: 12 80 00 06 bne 2009a30 2009a1c: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 2009a20: 40 00 2e dd call 2015594 <__errno> 2009a24: 01 00 00 00 nop 2009a28: 10 80 00 12 b 2009a70 2009a2c: 82 10 20 16 mov 0x16, %g1 ! 16 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) 2009a30: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009a34: 94 07 bf f4 add %fp, -12, %o2 2009a38: 40 00 12 02 call 200e240 <_Objects_Get> 2009a3c: 90 12 23 20 or %o0, 0x320, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009a40: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009a44: 80 a0 60 01 cmp %g1, 1 2009a48: 02 80 00 0d be 2009a7c 2009a4c: 01 00 00 00 nop 2009a50: 2a 80 00 11 bcs,a 2009a94 2009a54: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2009a58: 80 a0 60 02 cmp %g1, 2 2009a5c: 12 80 00 23 bne 2009ae8 2009a60: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 2009a64: 40 00 2e cc call 2015594 <__errno> 2009a68: 01 00 00 00 nop 2009a6c: 82 10 20 09 mov 9, %g1 ! 9 2009a70: c2 22 00 00 st %g1, [ %o0 ] 2009a74: 10 80 00 1f b 2009af0 2009a78: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2009a7c: 40 00 16 b7 call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009a80: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009a84: 40 00 06 e8 call 200b624 <== NOT EXECUTED 2009a88: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009a8c: 81 c7 e0 08 ret <== NOT EXECUTED 2009a90: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 2009a94: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2009a98: c2 26 40 00 st %g1, [ %i1 ] mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 2009a9c: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 2009aa0: c2 26 60 08 st %g1, [ %i1 + 8 ] mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 2009aa4: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 2009aa8: c2 26 60 04 st %g1, [ %i1 + 4 ] mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 2009aac: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 2009ab0: c2 26 60 0c st %g1, [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2009ab4: 05 00 80 8e sethi %hi(0x2023800), %g2 2009ab8: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2009abc: 90 10 20 00 clr %o0 2009ac0: 82 00 7f ff add %g1, -1, %g1 2009ac4: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] 2009ac8: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 2009acc: 80 a0 60 00 cmp %g1, 0 2009ad0: 32 80 00 09 bne,a 2009af4 2009ad4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2009ad8: 40 00 16 a0 call 200f558 <_Thread_Dispatch> 2009adc: 01 00 00 00 nop 2009ae0: 10 80 00 04 b 2009af0 2009ae4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2009ae8: 40 00 06 c5 call 200b5fc <== NOT EXECUTED 2009aec: 01 00 00 00 nop <== NOT EXECUTED } 2009af0: b0 10 00 08 mov %o0, %i0 2009af4: 81 c7 e0 08 ret 2009af8: 81 e8 00 00 restore 02009b54 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 2009b54: 9d e3 bf 90 save %sp, -112, %sp 2009b58: 11 00 80 8f sethi %hi(0x2023c00), %o0 2009b5c: 92 10 00 18 mov %i0, %o1 2009b60: 90 12 23 20 or %o0, 0x320, %o0 2009b64: 40 00 11 b7 call 200e240 <_Objects_Get> 2009b68: 94 07 bf f4 add %fp, -12, %o2 POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 2009b6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009b70: 80 a0 60 01 cmp %g1, 1 2009b74: 02 80 00 0c be 2009ba4 2009b78: 92 10 00 19 mov %i1, %o1 2009b7c: 80 a0 60 01 cmp %g1, 1 2009b80: 0a 80 00 0f bcs 2009bbc 2009b84: 80 a6 60 00 cmp %i1, 0 2009b88: 80 a0 60 02 cmp %g1, 2 2009b8c: 12 80 00 29 bne 2009c30 2009b90: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 2009b94: 40 00 2e 80 call 2015594 <__errno> 2009b98: 01 00 00 00 nop 2009b9c: 10 80 00 13 b 2009be8 2009ba0: 82 10 20 09 mov 9, %g1 ! 9 case OBJECTS_REMOTE: _Thread_Dispatch(); 2009ba4: 40 00 16 6d call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 2009ba8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009bac: 40 00 06 9e call 200b624 <== NOT EXECUTED 2009bb0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009bb4: 81 c7 e0 08 ret <== NOT EXECUTED 2009bb8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { 2009bbc: 02 80 00 17 be 2009c18 2009bc0: f0 02 20 10 ld [ %o0 + 0x10 ], %i0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 2009bc4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 2009bc8: 80 a0 60 00 cmp %g1, 0 2009bcc: 22 80 00 0a be,a 2009bf4 2009bd0: c0 26 20 80 clr [ %i0 + 0x80 ] _Thread_Enable_dispatch(); 2009bd4: 7f ff ff ca call 2009afc <_Thread_Enable_dispatch> 2009bd8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBUSY ); 2009bdc: 40 00 2e 6e call 2015594 <__errno> 2009be0: 01 00 00 00 nop 2009be4: 82 10 20 10 mov 0x10, %g1 ! 10 2009be8: c2 22 00 00 st %g1, [ %o0 ] 2009bec: 10 80 00 13 b 2009c38 2009bf0: 90 10 3f ff mov -1, %o0 the_message_queue->notify_argument = the_argument; 2009bf4: c0 26 20 84 clr [ %i0 + 0x84 ] } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 2009bf8: 90 06 20 94 add %i0, 0x94, %o0 2009bfc: 40 00 30 4c call 2015d2c 2009c00: 94 10 20 14 mov 0x14, %o2 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 2009c04: 03 00 80 26 sethi %hi(0x2009800), %g1 the_message_queue->notify_argument = the_argument; 2009c08: f0 26 20 84 st %i0, [ %i0 + 0x84 ] CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 2009c0c: 82 10 63 30 or %g1, 0x330, %g1 2009c10: 10 80 00 04 b 2009c20 2009c14: c2 26 20 80 st %g1, [ %i0 + 0x80 ] the_message_queue->notify_argument = the_argument; 2009c18: c0 26 20 84 clr [ %i0 + 0x84 ] CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 2009c1c: c0 26 20 80 clr [ %i0 + 0x80 ] _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 2009c20: 7f ff ff b7 call 2009afc <_Thread_Enable_dispatch> 2009c24: 01 00 00 00 nop 2009c28: 10 80 00 04 b 2009c38 2009c2c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2009c30: 40 00 06 73 call 200b5fc <== NOT EXECUTED 2009c34: 01 00 00 00 nop <== NOT EXECUTED } 2009c38: b0 10 00 08 mov %o0, %i0 2009c3c: 81 c7 e0 08 ret 2009c40: 81 e8 00 00 restore 02009cc4 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 2009cc4: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009cc8: 05 00 80 8e sethi %hi(0x2023800), %g2 2009ccc: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 2009cd0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2009cd4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2009cd8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2009cdc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2009ce0: 82 00 60 01 inc %g1 2009ce4: a0 10 00 18 mov %i0, %l0 2009ce8: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 2009cec: b6 8e 62 00 andcc %i1, 0x200, %i3 2009cf0: 02 80 00 05 be 2009d04 2009cf4: b4 10 20 00 clr %i2 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 2009cf8: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 2009cfc: 82 07 a0 54 add %fp, 0x54, %g1 2009d00: c2 27 bf f4 st %g1, [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 2009d04: 39 00 80 8f sethi %hi(0x2023c00), %i4 2009d08: 40 00 10 0a call 200dd30 <_Objects_Allocate> 2009d0c: 90 17 23 20 or %i4, 0x320, %o0 ! 2023f20 <_POSIX_Message_queue_Information_fds> va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 2009d10: b0 92 20 00 orcc %o0, 0, %i0 2009d14: 32 80 00 08 bne,a 2009d34 2009d18: f2 26 20 14 st %i1, [ %i0 + 0x14 ] _Thread_Enable_dispatch(); 2009d1c: 7f ff ff dd call 2009c90 <_Thread_Enable_dispatch> 2009d20: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENFILE ); 2009d24: 40 00 2e 1c call 2015594 <__errno> 2009d28: 01 00 00 00 nop 2009d2c: 10 80 00 20 b 2009dac 2009d30: 82 10 20 17 mov 0x17, %g1 ! 17 } the_mq_fd->oflag = oflag; status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 2009d34: 90 10 00 10 mov %l0, %o0 2009d38: 40 00 24 0c call 2012d68 <_POSIX_Message_queue_Name_to_id> 2009d3c: 92 07 bf f0 add %fp, -16, %o1 * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "message queue does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 2009d40: ba 92 20 00 orcc %o0, 0, %i5 2009d44: 02 80 00 10 be 2009d84 2009d48: 82 0e 6a 00 and %i1, 0xa00, %g1 /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 2009d4c: 80 a7 60 02 cmp %i5, 2 2009d50: 12 80 00 04 bne 2009d60 2009d54: 80 a6 e0 00 cmp %i3, 0 2009d58: 12 80 00 2c bne 2009e08 2009d5c: 90 10 00 10 mov %l0, %o0 _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009d60: 7f ff ff c5 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009d64: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2009d68: 7f ff ff ca call 2009c90 <_Thread_Enable_dispatch> 2009d6c: b0 10 3f ff mov -1, %i0 rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 2009d70: 40 00 2e 09 call 2015594 <__errno> 2009d74: 01 00 00 00 nop 2009d78: fa 22 00 00 st %i5, [ %o0 ] 2009d7c: 81 c7 e0 08 ret 2009d80: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 2009d84: 80 a0 6a 00 cmp %g1, 0xa00 2009d88: 12 80 00 0b bne 2009db4 2009d8c: d2 07 bf f0 ld [ %fp + -16 ], %o1 _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009d90: 7f ff ff b9 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009d94: 90 10 00 18 mov %i0, %o0 _Thread_Enable_dispatch(); 2009d98: 7f ff ff be call 2009c90 <_Thread_Enable_dispatch> 2009d9c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 2009da0: 40 00 2d fd call 2015594 <__errno> 2009da4: 01 00 00 00 nop 2009da8: 82 10 20 11 mov 0x11, %g1 ! 11 2009dac: 10 80 00 22 b 2009e34 2009db0: c2 22 00 00 st %g1, [ %o0 ] RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 2009db4: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED 2009db8: 11 00 80 8f sethi %hi(0x2023c00), %o0 <== NOT EXECUTED 2009dbc: 40 00 11 21 call 200e240 <_Objects_Get> <== NOT EXECUTED 2009dc0: 90 12 21 68 or %o0, 0x168, %o0 ! 2023d68 <_POSIX_Message_queue_Information> <== NOT EXECUTED * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); the_mq->open_count += 1; 2009dc4: c4 02 20 1c ld [ %o0 + 0x1c ], %g2 <== NOT EXECUTED 2009dc8: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 2009dcc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED /* * In this case we need to do an ID->pointer conversion to * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); 2009dd0: c2 27 bf ec st %g1, [ %fp + -20 ] <== NOT EXECUTED the_mq->open_count += 1; 2009dd4: 84 00 a0 01 inc %g2 <== NOT EXECUTED the_mq_fd->Queue = the_mq; _Objects_Open( 2009dd8: 90 17 23 20 or %i4, 0x320, %o0 <== NOT EXECUTED 2009ddc: 94 10 20 00 clr %o2 <== NOT EXECUTED * check the mode. */ the_mq = _POSIX_Message_queue_Get( the_mq_id, &location ); the_mq->open_count += 1; the_mq_fd->Queue = the_mq; 2009de0: c2 26 20 10 st %g1, [ %i0 + 0x10 ] <== NOT EXECUTED _Objects_Open( 2009de4: 7f ff ff 98 call 2009c44 <_Objects_Open> <== NOT EXECUTED 2009de8: c4 20 60 1c st %g2, [ %g1 + 0x1c ] <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009dec: 7f ff ff a9 call 2009c90 <_Thread_Enable_dispatch> <== NOT EXECUTED 2009df0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); 2009df4: 7f ff ff a7 call 2009c90 <_Thread_Enable_dispatch> <== NOT EXECUTED 2009df8: 01 00 00 00 nop <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 2009dfc: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 2009e00: 81 c7 e0 08 ret <== NOT EXECUTED 2009e04: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 2009e08: 94 10 00 1a mov %i2, %o2 2009e0c: 92 10 20 01 mov 1, %o1 2009e10: 40 00 23 6a call 2012bb8 <_POSIX_Message_queue_Create_support> 2009e14: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 2009e18: 80 a2 3f ff cmp %o0, -1 2009e1c: 12 80 00 08 bne 2009e3c 2009e20: c2 07 bf ec ld [ %fp + -20 ], %g1 _Thread_Enable_dispatch(); 2009e24: 7f ff ff 9b call 2009c90 <_Thread_Enable_dispatch> 2009e28: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); 2009e2c: 7f ff ff 92 call 2009c74 <_POSIX_Message_queue_Free_fd> 2009e30: 90 10 00 18 mov %i0, %o0 2009e34: 81 c7 e0 08 ret 2009e38: 91 e8 3f ff restore %g0, -1, %o0 return (mqd_t) -1; } the_mq_fd->Queue = the_mq; _Objects_Open( 2009e3c: 92 10 00 18 mov %i0, %o1 2009e40: 90 17 23 20 or %i4, 0x320, %o0 2009e44: 94 10 20 00 clr %o2 2009e48: 7f ff ff 7f call 2009c44 <_Objects_Open> 2009e4c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 2009e50: 7f ff ff 90 call 2009c90 <_Thread_Enable_dispatch> 2009e54: 01 00 00 00 nop return (mqd_t) the_mq_fd->Object.id; 2009e58: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 2009e5c: 81 c7 e0 08 ret 2009e60: 81 e8 00 00 restore 0200a17c : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 200a17c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) 200a180: 80 a6 60 00 cmp %i1, 0 200a184: 12 80 00 06 bne 200a19c 200a188: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); 200a18c: 40 00 2d 02 call 2015594 <__errno> 200a190: 01 00 00 00 nop 200a194: 10 80 00 12 b 200a1dc 200a198: 82 10 20 16 mov 0x16, %g1 ! 16 200a19c: 11 00 80 8f sethi %hi(0x2023c00), %o0 200a1a0: 94 07 bf f4 add %fp, -12, %o2 200a1a4: 40 00 10 27 call 200e240 <_Objects_Get> 200a1a8: 90 12 23 20 or %o0, 0x320, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a1ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a1b0: 80 a0 60 01 cmp %g1, 1 200a1b4: 02 80 00 0d be 200a1e8 200a1b8: 01 00 00 00 nop 200a1bc: 0a 80 00 11 bcs 200a200 200a1c0: 80 a6 a0 00 cmp %i2, 0 200a1c4: 80 a0 60 02 cmp %g1, 2 200a1c8: 12 80 00 27 bne 200a264 200a1cc: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a1d0: 40 00 2c f1 call 2015594 <__errno> 200a1d4: 01 00 00 00 nop 200a1d8: 82 10 20 09 mov 9, %g1 ! 9 200a1dc: c2 22 00 00 st %g1, [ %o0 ] 200a1e0: 10 80 00 23 b 200a26c 200a1e4: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 200a1e8: 40 00 14 dc call 200f558 <_Thread_Dispatch> <== NOT EXECUTED 200a1ec: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a1f0: 40 00 05 0d call 200b624 <== NOT EXECUTED 200a1f4: 01 00 00 00 nop <== NOT EXECUTED the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a1f8: 81 c7 e0 08 ret <== NOT EXECUTED 200a1fc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 200a200: 02 80 00 0a be 200a228 200a204: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 omqstat->mq_flags = the_mq_fd->oflag; 200a208: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a20c: c2 26 80 00 st %g1, [ %i2 ] omqstat->mq_msgsize = the_core_mq->maximum_message_size; 200a210: c2 00 a0 6c ld [ %g2 + 0x6c ], %g1 200a214: c2 26 a0 08 st %g1, [ %i2 + 8 ] omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 200a218: c2 00 a0 64 ld [ %g2 + 0x64 ], %g1 200a21c: c2 26 a0 04 st %g1, [ %i2 + 4 ] omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 200a220: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1 200a224: c2 26 a0 0c st %g1, [ %i2 + 0xc ] } the_mq_fd->oflag = mqstat->mq_flags; 200a228: c2 06 40 00 ld [ %i1 ], %g1 200a22c: c2 22 20 14 st %g1, [ %o0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a230: 05 00 80 8e sethi %hi(0x2023800), %g2 200a234: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 ! 2023950 <_Thread_Dispatch_disable_level> 200a238: 90 10 20 00 clr %o0 200a23c: 82 00 7f ff add %g1, -1, %g1 200a240: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] 200a244: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 200a248: 80 a0 60 00 cmp %g1, 0 200a24c: 32 80 00 09 bne,a 200a270 200a250: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200a254: 40 00 14 c1 call 200f558 <_Thread_Dispatch> 200a258: 01 00 00 00 nop 200a25c: 10 80 00 04 b 200a26c 200a260: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200a264: 40 00 04 e6 call 200b5fc <== NOT EXECUTED 200a268: 01 00 00 00 nop <== NOT EXECUTED } 200a26c: b0 10 00 08 mov %o0, %i0 200a270: 81 c7 e0 08 ret 200a274: 81 e8 00 00 restore 0200a278 : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200a278: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a27c: 92 07 bf f4 add %fp, -12, %o1 200a280: 40 00 00 88 call 200a4a0 <_POSIX_Absolute_timeout_to_ticks> 200a284: 90 10 00 1c mov %i4, %o0 char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200a288: 92 10 00 19 mov %i1, %o1 200a28c: 94 10 00 1a mov %i2, %o2 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a290: 80 a2 20 02 cmp %o0, 2 200a294: 08 80 00 07 bleu 200a2b0 200a298: 96 10 00 1b mov %i3, %o3 200a29c: 80 a2 20 03 cmp %o0, 3 200a2a0: 22 80 00 05 be,a 200a2b4 200a2a4: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 200a2a8: 10 80 00 04 b 200a2b8 <== NOT EXECUTED 200a2ac: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a2b0: b8 10 20 00 clr %i4 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 200a2b4: da 07 bf f4 ld [ %fp + -12 ], %o5 200a2b8: 90 10 00 18 mov %i0, %o0 200a2bc: 7f ff fe fd call 2009eb0 <_POSIX_Message_queue_Receive_support> 200a2c0: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200a2c4: 81 c7 e0 08 ret 200a2c8: 91 e8 00 08 restore %g0, %o0, %o0 0200a2cc : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200a2cc: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a2d0: 92 07 bf f4 add %fp, -12, %o1 200a2d4: 40 00 00 73 call 200a4a0 <_POSIX_Absolute_timeout_to_ticks> 200a2d8: 90 10 00 1c mov %i4, %o0 const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200a2dc: 92 10 00 19 mov %i1, %o1 200a2e0: 94 10 00 1a mov %i2, %o2 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a2e4: 80 a2 20 02 cmp %o0, 2 200a2e8: 08 80 00 07 bleu 200a304 200a2ec: 96 10 00 1b mov %i3, %o3 200a2f0: 80 a2 20 03 cmp %o0, 3 200a2f4: 22 80 00 05 be,a 200a308 200a2f8: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 200a2fc: 10 80 00 04 b 200a30c <== NOT EXECUTED 200a300: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ switch ( _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ) ) { 200a304: b8 10 20 00 clr %i4 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 200a308: da 07 bf f4 ld [ %fp + -12 ], %o5 200a30c: 90 10 00 18 mov %i0, %o0 200a310: 7f ff ff 4e call 200a048 <_POSIX_Message_queue_Send_support> 200a314: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200a318: 81 c7 e0 08 ret 200a31c: 91 e8 00 08 restore %g0, %o0, %o0 020027d4 : */ int newlib_free_buffers( FILE *fp ) { 20027d4: 9d e3 bf 98 save %sp, -104, %sp switch ( fileno(fp) ) { 20027d8: 40 00 2f d2 call 200e720 20027dc: 90 10 00 18 mov %i0, %o0 20027e0: 80 a2 20 02 cmp %o0, 2 20027e4: 18 80 00 0e bgu 200281c 20027e8: 01 00 00 00 nop case 0: case 1: case 2: if (fp->_flags & __SMBF) { 20027ec: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 20027f0: 80 88 60 80 btst 0x80, %g1 20027f4: 02 80 00 0c be 2002824 20027f8: 01 00 00 00 nop free( fp->_bf._base ); 20027fc: 7f ff fe 80 call 20021fc 2002800: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 fp->_flags &= ~__SMBF; 2002804: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 fp->_bf._base = fp->_p = (unsigned char *) NULL; 2002808: c0 26 20 10 clr [ %i0 + 0x10 ] case 0: case 1: case 2: if (fp->_flags & __SMBF) { free( fp->_bf._base ); fp->_flags &= ~__SMBF; 200280c: 82 08 7f 7f and %g1, -129, %g1 fp->_bf._base = fp->_p = (unsigned char *) NULL; 2002810: c0 26 00 00 clr [ %i0 ] case 0: case 1: case 2: if (fp->_flags & __SMBF) { free( fp->_bf._base ); fp->_flags &= ~__SMBF; 2002814: 10 80 00 04 b 2002824 2002818: c2 36 20 0c sth %g1, [ %i0 + 0xc ] fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 200281c: 40 00 2f 47 call 200e538 <== NOT EXECUTED 2002820: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } return 0; } 2002824: 81 c7 e0 08 ret 2002828: 91 e8 20 00 restore %g0, 0, %o0 020028fc : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 20028fc: 9d e3 bf 98 save %sp, -104, %sp rtems_device_driver status; if ( !initialized ) { 2002900: 05 00 80 72 sethi %hi(0x201c800), %g2 2002904: c2 48 a0 54 ldsb [ %g2 + 0x54 ], %g1 ! 201c854 2002908: 80 a0 60 00 cmp %g1, 0 200290c: 12 80 00 0f bne 2002948 2002910: 82 10 20 01 mov 1, %g1 initialized = 1; status = rtems_io_register_name( 2002914: 11 00 80 67 sethi %hi(0x2019c00), %o0 ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 2002918: c2 28 a0 54 stb %g1, [ %g2 + 0x54 ] status = rtems_io_register_name( 200291c: 90 12 23 98 or %o0, 0x398, %o0 2002920: 92 10 00 18 mov %i0, %o1 2002924: 40 00 00 4e call 2002a5c 2002928: 94 10 20 00 clr %o2 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 200292c: 80 a2 20 00 cmp %o0, 0 2002930: 02 80 00 05 be 2002944 2002934: 03 00 80 72 sethi %hi(0x201c800), %g1 rtems_fatal_error_occurred(status); 2002938: 40 00 12 95 call 200738c <== NOT EXECUTED 200293c: 01 00 00 00 nop <== NOT EXECUTED NULL_major = major; 2002940: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED 2002944: f0 20 63 bc st %i0, [ %g1 + 0x3bc ] ! 201cbbc } return RTEMS_SUCCESSFUL; } 2002948: 81 c7 e0 08 ret 200294c: 91 e8 20 00 restore %g0, 0, %o0 020028d8 : void *pargp ) { rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 20028d8: 80 a2 a0 00 cmp %o2, 0 20028dc: 02 80 00 04 be 20028ec 20028e0: 01 00 00 00 nop rw_args->bytes_moved = rw_args->count; 20028e4: c2 02 a0 0c ld [ %o2 + 0xc ], %g1 <== NOT EXECUTED 20028e8: c2 22 a0 14 st %g1, [ %o2 + 0x14 ] <== NOT EXECUTED return NULL_SUCCESSFUL; } 20028ec: 81 c3 e0 08 retl 20028f0: 90 10 20 00 clr %o0 02002a30 : int open( const char *pathname, int flags, ... ) { 2002a30: 9d e3 bf 80 save %sp, -128, %sp 2002a34: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2002a38: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2002a3c: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2002a40: f4 27 a0 4c st %i2, [ %fp + 0x4c ] /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 2002a44: 82 06 60 01 add %i1, 1, %g1 if ( ( status & _FREAD ) == _FREAD ) eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 2002a48: 80 88 60 02 btst 2, %g1 * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; if ( ( status & _FREAD ) == _FREAD ) 2002a4c: 82 08 60 01 and %g1, 1, %g1 eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 2002a50: 02 80 00 03 be 2002a5c 2002a54: a1 28 60 02 sll %g1, 2, %l0 eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 2002a58: a0 14 20 02 or %l0, 2, %l0 va_start(ap, flags); mode = va_arg( ap, int ); 2002a5c: 82 07 a0 50 add %fp, 0x50, %g1 * descriptors are obtained using socket(), not open(). */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { 2002a60: b8 10 20 17 mov 0x17, %i4 * 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(); 2002a64: 40 00 24 65 call 200bbf8 2002a68: c2 27 bf f4 st %g1, [ %fp + -12 ] if ( iop == 0 ) { 2002a6c: ba 92 20 00 orcc %o0, 0, %i5 2002a70: 02 80 00 98 be 2002cd0 2002a74: 92 10 00 10 mov %l0, %o1 /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 2002a78: 90 10 00 18 mov %i0, %o0 2002a7c: a0 07 bf e4 add %fp, -28, %l0 2002a80: 96 10 20 01 mov 1, %o3 2002a84: 7f ff fd 58 call 2001fe4 2002a88: 94 10 00 10 mov %l0, %o2 pathname, eval_flags, &loc, TRUE ); if ( status == -1 ) { 2002a8c: 80 a2 3f ff cmp %o0, -1 2002a90: 12 80 00 28 bne 2002b30 2002a94: 82 0e 6a 00 and %i1, 0xa00, %g1 if ( errno != ENOENT ) { 2002a98: 40 00 2e 52 call 200e3e0 <__errno> 2002a9c: 01 00 00 00 nop 2002aa0: c2 02 00 00 ld [ %o0 ], %g1 2002aa4: 80 a0 60 02 cmp %g1, 2 2002aa8: 02 80 00 06 be 2002ac0 2002aac: 80 8e 62 00 btst 0x200, %i1 rc = errno; 2002ab0: 40 00 2e 4c call 200e3e0 <__errno> 2002ab4: b6 10 20 00 clr %i3 2002ab8: 10 80 00 71 b 2002c7c 2002abc: f8 02 00 00 ld [ %o0 ], %i4 goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 2002ac0: b6 10 20 00 clr %i3 2002ac4: 02 80 00 71 be 2002c88 2002ac8: b8 10 20 02 mov 2, %i4 rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 2002acc: 13 3f ff e0 sethi %hi(0xffff8000), %o1 2002ad0: 90 10 00 18 mov %i0, %o0 2002ad4: 92 16 80 09 or %i2, %o1, %o1 2002ad8: 94 10 20 00 clr %o2 2002adc: 93 2a 60 10 sll %o1, 0x10, %o1 2002ae0: 96 10 20 00 clr %o3 2002ae4: 7f ff fe c7 call 2002600 2002ae8: 93 32 60 10 srl %o1, 0x10, %o1 if ( rc ) { 2002aec: 80 a2 20 00 cmp %o0, 0 2002af0: 02 80 00 06 be 2002b08 2002af4: 94 10 00 10 mov %l0, %o2 rc = errno; 2002af8: 40 00 2e 3a call 200e3e0 <__errno> <== NOT EXECUTED 2002afc: 01 00 00 00 nop <== NOT EXECUTED 2002b00: 10 80 00 5f b 2002c7c <== NOT EXECUTED 2002b04: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED goto done; } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, TRUE ); 2002b08: 90 10 00 18 mov %i0, %o0 2002b0c: 92 10 20 00 clr %o1 2002b10: 96 10 20 01 mov 1, %o3 2002b14: 7f ff fd 34 call 2001fe4 2002b18: b6 10 20 00 clr %i3 if ( status != 0 ) { /* The file did not exist */ 2002b1c: 80 a2 20 00 cmp %o0, 0 2002b20: 12 80 00 5a bne 2002c88 2002b24: b8 10 20 0d mov 0xd, %i4 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 2002b28: 10 80 00 07 b 2002b44 2002b2c: c2 07 bf e8 ld [ %fp + -24 ], %g1 if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 2002b30: b6 10 00 10 mov %l0, %i3 2002b34: 80 a0 6a 00 cmp %g1, 0xa00 2002b38: 02 80 00 54 be 2002c88 2002b3c: b8 10 20 11 mov 0x11, %i4 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 2002b40: c2 07 bf e8 ld [ %fp + -24 ], %g1 iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); 2002b44: e0 07 60 0c ld [ %i5 + 0xc ], %l0 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 2002b48: c2 27 60 30 st %g1, [ %i5 + 0x30 ] iop->file_info = loc.node_access; 2002b4c: c2 07 bf e4 ld [ %fp + -28 ], %g1 iop->flags |= rtems_libio_fcntl_flags( flags ); 2002b50: 90 10 00 19 mov %i1, %o0 2002b54: 40 00 24 5f call 200bcd0 2002b58: c2 27 60 2c st %g1, [ %i5 + 0x2c ] 2002b5c: 90 12 00 10 or %o0, %l0, %o0 iop->pathinfo = loc; 2002b60: 94 10 20 10 mov 0x10, %o2 * returned by successful path evaluation. */ iop->handlers = loc.handlers; iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); 2002b64: d0 27 60 0c st %o0, [ %i5 + 0xc ] iop->pathinfo = loc; 2002b68: a0 07 bf e4 add %fp, -28, %l0 2002b6c: 90 07 60 10 add %i5, 0x10, %o0 2002b70: 40 00 2f f1 call 200eb34 2002b74: 92 10 00 10 mov %l0, %o1 if ( !iop->handlers->open_h ) { 2002b78: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 2002b7c: b6 10 00 10 mov %l0, %i3 2002b80: c2 00 40 00 ld [ %g1 ], %g1 2002b84: 80 a0 60 00 cmp %g1, 0 2002b88: 02 80 00 40 be 2002c88 2002b8c: b8 10 20 86 mov 0x86, %i4 rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 2002b90: 92 10 00 18 mov %i0, %o1 2002b94: 96 10 00 1a mov %i2, %o3 2002b98: 90 10 00 1d mov %i5, %o0 2002b9c: 9f c0 40 00 call %g1 2002ba0: 94 10 00 19 mov %i1, %o2 if ( rc ) 2002ba4: b8 92 20 00 orcc %o0, 0, %i4 2002ba8: 12 80 00 36 bne 2002c80 2002bac: 80 a7 20 00 cmp %i4, 0 /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 2002bb0: 80 8e 64 00 btst 0x400, %i1 2002bb4: 02 80 00 4c be 2002ce4 2002bb8: 03 00 80 62 sethi %hi(0x2018800), %g1 rc = ftruncate( iop - rtems_libio_iops, 0 ); 2002bbc: 21 00 80 62 sethi %hi(0x2018800), %l0 2002bc0: c4 04 21 20 ld [ %l0 + 0x120 ], %g2 ! 2018920 2002bc4: 92 10 20 00 clr %o1 2002bc8: 84 27 40 02 sub %i5, %g2, %g2 2002bcc: 85 38 a0 02 sra %g2, 2, %g2 2002bd0: 87 28 a0 02 sll %g2, 2, %g3 2002bd4: 83 28 a0 06 sll %g2, 6, %g1 2002bd8: 82 20 40 03 sub %g1, %g3, %g1 2002bdc: 91 28 60 06 sll %g1, 6, %o0 2002be0: 90 22 00 01 sub %o0, %g1, %o0 2002be4: 83 2a 20 0c sll %o0, 0xc, %g1 2002be8: 90 02 00 01 add %o0, %g1, %o0 2002bec: 90 02 00 02 add %o0, %g2, %o0 2002bf0: 91 2a 20 04 sll %o0, 4, %o0 2002bf4: 90 22 00 02 sub %o0, %g2, %o0 2002bf8: 91 2a 20 02 sll %o0, 2, %o0 2002bfc: 40 00 23 2d call 200b8b0 2002c00: 90 20 80 08 sub %g2, %o0, %o0 if ( rc ) { 2002c04: b8 92 20 00 orcc %o0, 0, %i4 2002c08: 02 80 00 37 be 2002ce4 2002c0c: 03 00 80 62 sethi %hi(0x2018800), %g1 if(errno) rc = errno; 2002c10: 40 00 2d f4 call 200e3e0 <__errno> <== NOT EXECUTED 2002c14: 01 00 00 00 nop <== NOT EXECUTED 2002c18: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2002c1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2002c20: 02 80 00 06 be 2002c38 <== NOT EXECUTED 2002c24: c4 04 21 20 ld [ %l0 + 0x120 ], %g2 <== NOT EXECUTED 2002c28: 40 00 2d ee call 200e3e0 <__errno> <== NOT EXECUTED 2002c2c: 01 00 00 00 nop <== NOT EXECUTED 2002c30: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED close( iop - rtems_libio_iops ); 2002c34: c4 04 21 20 ld [ %l0 + 0x120 ], %g2 <== NOT EXECUTED 2002c38: b6 10 20 00 clr %i3 <== NOT EXECUTED 2002c3c: 84 27 40 02 sub %i5, %g2, %g2 <== NOT EXECUTED 2002c40: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED 2002c44: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED 2002c48: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED 2002c4c: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 2002c50: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED 2002c54: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED 2002c58: 83 2a 20 0c sll %o0, 0xc, %g1 <== NOT EXECUTED 2002c5c: ba 10 20 00 clr %i5 <== NOT EXECUTED 2002c60: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 2002c64: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED 2002c68: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED 2002c6c: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED 2002c70: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 2002c74: 40 00 22 dd call 200b7e8 <== NOT EXECUTED 2002c78: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 2002c7c: 80 a7 20 00 cmp %i4, 0 2002c80: 02 80 00 19 be 2002ce4 2002c84: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( iop ) 2002c88: 80 a7 60 00 cmp %i5, 0 2002c8c: 02 80 00 05 be 2002ca0 2002c90: 80 a6 e0 00 cmp %i3, 0 rtems_libio_free( iop ); 2002c94: 40 00 23 c2 call 200bb9c 2002c98: 90 10 00 1d mov %i5, %o0 if ( loc_to_free ) 2002c9c: 80 a6 e0 00 cmp %i3, 0 2002ca0: 02 80 00 0c be 2002cd0 2002ca4: 01 00 00 00 nop rtems_filesystem_freenode( loc_to_free ); 2002ca8: c2 06 e0 08 ld [ %i3 + 8 ], %g1 2002cac: 80 a0 60 00 cmp %g1, 0 2002cb0: 02 80 00 08 be 2002cd0 2002cb4: 01 00 00 00 nop 2002cb8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2002cbc: 80 a0 60 00 cmp %g1, 0 2002cc0: 02 80 00 04 be 2002cd0 2002cc4: 01 00 00 00 nop 2002cc8: 9f c0 40 00 call %g1 2002ccc: 90 10 00 1b mov %i3, %o0 rtems_set_errno_and_return_minus_one( rc ); 2002cd0: 40 00 2d c4 call 200e3e0 <__errno> 2002cd4: b0 10 3f ff mov -1, %i0 2002cd8: f8 22 00 00 st %i4, [ %o0 ] 2002cdc: 81 c7 e0 08 ret 2002ce0: 81 e8 00 00 restore } return iop - rtems_libio_iops; 2002ce4: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 2002ce8: 86 27 40 03 sub %i5, %g3, %g3 2002cec: 87 38 e0 02 sra %g3, 2, %g3 2002cf0: 83 28 e0 02 sll %g3, 2, %g1 2002cf4: 85 28 e0 06 sll %g3, 6, %g2 2002cf8: 84 20 80 01 sub %g2, %g1, %g2 2002cfc: 83 28 a0 06 sll %g2, 6, %g1 2002d00: 82 20 40 02 sub %g1, %g2, %g1 2002d04: 85 28 60 0c sll %g1, 0xc, %g2 2002d08: 82 00 40 02 add %g1, %g2, %g1 2002d0c: 82 00 40 03 add %g1, %g3, %g1 2002d10: 83 28 60 04 sll %g1, 4, %g1 2002d14: 82 20 40 03 sub %g1, %g3, %g1 2002d18: 83 28 60 02 sll %g1, 2, %g1 2002d1c: b0 20 c0 01 sub %g3, %g1, %i0 } 2002d20: 81 c7 e0 08 ret 2002d24: 81 e8 00 00 restore 020029b8 : /* * This is a replaceable stub */ void open_dev_console(void) { 20029b8: 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) { 20029bc: 31 00 80 5a sethi %hi(0x2016800), %i0 20029c0: 92 10 20 00 clr %o1 20029c4: 90 16 20 50 or %i0, 0x50, %o0 20029c8: 40 00 00 1a call 2002a30 20029cc: 94 10 20 00 clr %o2 20029d0: 80 a2 3f ff cmp %o0, -1 20029d4: 02 80 00 15 be 2002a28 20029d8: 90 16 20 50 or %i0, 0x50, %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) 20029dc: 92 10 20 01 mov 1, %o1 20029e0: 40 00 00 14 call 2002a30 20029e4: 94 10 20 00 clr %o2 20029e8: 80 a2 3f ff cmp %o0, -1 20029ec: 32 80 00 06 bne,a 2002a04 20029f0: 90 16 20 50 or %i0, 0x50, %o0 rtems_fatal_error_occurred( error_code | '1' ); 20029f4: 11 14 d5 11 sethi %hi(0x53544400), %o0 <== NOT EXECUTED 20029f8: 40 00 0e dc call 2006568 <== NOT EXECUTED 20029fc: 90 12 20 31 or %o0, 0x31, %o0 ! 53544431 <== NOT EXECUTED if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 2002a00: 90 16 20 50 or %i0, 0x50, %o0 <== NOT EXECUTED 2002a04: 92 10 20 01 mov 1, %o1 2002a08: 40 00 00 0a call 2002a30 2002a0c: 94 10 20 00 clr %o2 2002a10: 80 a2 3f ff cmp %o0, -1 2002a14: 12 80 00 05 bne 2002a28 2002a18: 31 14 d5 11 sethi %hi(0x53544400), %i0 rtems_fatal_error_occurred( error_code | '2' ); 2002a1c: b0 16 20 32 or %i0, 0x32, %i0 ! 53544432 <== NOT EXECUTED 2002a20: 40 00 0e d2 call 2006568 <== NOT EXECUTED 2002a24: 81 e8 00 00 restore <== NOT EXECUTED 2002a28: 81 c7 e0 08 ret 2002a2c: 81 e8 00 00 restore 020165c4 : * open a directory. */ DIR * opendir(name) const char *name; { 20165c4: 9d e3 bf 98 save %sp, -104, %sp register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 20165c8: 92 10 20 00 clr %o1 20165cc: 90 10 00 18 mov %i0, %o0 20165d0: 7f ff b9 c9 call 2004cf4 20165d4: b0 10 20 00 clr %i0 20165d8: 80 a2 3f ff cmp %o0, -1 20165dc: 02 80 00 18 be 201663c 20165e0: a0 10 00 08 mov %o0, %l0 return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 20165e4: 92 10 20 02 mov 2, %o1 20165e8: 40 00 24 3e call 201f6e0 20165ec: 94 10 20 01 mov 1, %o2 20165f0: 80 a2 3f ff cmp %o0, -1 20165f4: 02 80 00 10 be 2016634 20165f8: 90 10 00 10 mov %l0, %o0 20165fc: 7f ff b7 2d call 20042b0 2016600: 90 10 20 18 mov 0x18, %o0 2016604: 80 a2 20 00 cmp %o0, 0 2016608: 22 80 00 0b be,a 2016634 201660c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016610: b0 10 00 08 mov %o0, %i0 * If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE * buffer that it cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdirentries() */ dirp->dd_buf = malloc (512); 2016614: 7f ff b7 27 call 20042b0 2016618: 90 10 22 00 mov 0x200, %o0 dirp->dd_len = 512; 201661c: 82 10 22 00 mov 0x200, %g1 * If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE * buffer that it cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdirentries() */ dirp->dd_buf = malloc (512); 2016620: d0 26 20 0c st %o0, [ %i0 + 0xc ] dirp->dd_len = 512; if (dirp->dd_buf == NULL) { 2016624: 80 a2 20 00 cmp %o0, 0 2016628: 12 80 00 07 bne 2016644 201662c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] close (fd); 2016630: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016634: 7f ff b5 39 call 2003b18 <== NOT EXECUTED 2016638: b0 10 20 00 clr %i0 <== NOT EXECUTED 201663c: 81 c7 e0 08 ret <== NOT EXECUTED 2016640: 81 e8 00 00 restore <== NOT EXECUTED return NULL; } dirp->dd_fd = fd; 2016644: e0 26 00 00 st %l0, [ %i0 ] dirp->dd_loc = 0; 2016648: c0 26 20 04 clr [ %i0 + 4 ] dirp->dd_seek = 0; 201664c: c0 26 20 14 clr [ %i0 + 0x14 ] /* * Set up seek point for rewinddir. */ return dirp; } 2016650: 81 c7 e0 08 ret 2016654: 81 e8 00 00 restore 02003764 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 2003764: 9d e3 bf 98 save %sp, -104, %sp int i; if (tty->termios.c_oflag & OPOST) { 2003768: c8 06 60 34 ld [ %i1 + 0x34 ], %g4 200376c: 80 89 20 01 btst 1, %g4 2003770: 02 80 00 59 be 20038d4 2003774: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] switch (c) { 2003778: 82 0e 20 ff and %i0, 0xff, %g1 200377c: 80 a0 60 09 cmp %g1, 9 2003780: 22 80 00 2b be,a 200382c 2003784: c6 06 60 28 ld [ %i1 + 0x28 ], %g3 2003788: 18 80 00 07 bgu 20037a4 200378c: 80 a0 60 0a cmp %g1, 0xa 2003790: 80 a0 60 08 cmp %g1, 8 <== NOT EXECUTED 2003794: 12 80 00 3c bne 2003884 <== NOT EXECUTED 2003798: 80 89 20 02 btst 2, %g4 <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 200379c: 10 80 00 35 b 2003870 <== NOT EXECUTED 20037a0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 20037a4: 02 80 00 06 be 20037bc 20037a8: 80 a0 60 0d cmp %g1, 0xd 20037ac: 32 80 00 36 bne,a 2003884 20037b0: 80 89 20 02 btst 2, %g4 tty->column = 0; } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 20037b4: 10 80 00 10 b 20037f4 <== NOT EXECUTED 20037b8: 80 89 20 10 btst 0x10, %g4 <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { switch (c) { case '\n': if (tty->termios.c_oflag & ONLRET) 20037bc: 80 89 20 20 btst 0x20, %g4 20037c0: 32 80 00 02 bne,a 20037c8 20037c4: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED tty->column = 0; if (tty->termios.c_oflag & ONLCR) { 20037c8: c2 06 60 34 ld [ %i1 + 0x34 ], %g1 20037cc: 80 88 60 04 btst 4, %g1 20037d0: 02 80 00 42 be 20038d8 20037d4: 94 10 00 19 mov %i1, %o2 rtems_termios_puts ("\r", 1, tty); 20037d8: 11 00 80 5b sethi %hi(0x2016c00), %o0 20037dc: 92 10 20 01 mov 1, %o1 20037e0: 90 12 20 18 or %o0, 0x18, %o0 20037e4: 7f ff ff 94 call 2003634 20037e8: 94 10 00 19 mov %i1, %o2 c = '\n'; if (tty->termios.c_oflag & ONLRET) tty->column = 0; break; } tty->column = 0; 20037ec: 10 80 00 3a b 20038d4 20037f0: c0 26 60 28 clr [ %i1 + 0x28 ] tty->column = 0; } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 20037f4: 02 80 00 06 be 200380c <== NOT EXECUTED 20037f8: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED 20037fc: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED 2003800: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003804: 02 80 00 17 be 2003860 <== NOT EXECUTED 2003808: 80 89 20 08 btst 8, %g4 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 200380c: 22 80 00 32 be,a 20038d4 <== NOT EXECUTED 2003810: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED c = '\n'; 2003814: 82 10 20 0a mov 0xa, %g1 <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 2003818: 80 89 20 20 btst 0x20, %g4 <== NOT EXECUTED 200381c: 02 80 00 2e be 20038d4 <== NOT EXECUTED 2003820: c2 2f a0 44 stb %g1, [ %fp + 0x44 ] <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 2003824: 10 80 00 2c b 20038d4 <== NOT EXECUTED 2003828: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { 200382c: 05 00 00 06 sethi %hi(0x1800), %g2 2003830: 82 09 00 02 and %g4, %g2, %g1 2003834: 80 a0 40 02 cmp %g1, %g2 } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 2003838: 84 08 e0 07 and %g3, 7, %g2 200383c: 82 10 20 08 mov 8, %g1 2003840: 92 20 40 02 sub %g1, %g2, %o1 if ((tty->termios.c_oflag & TABDLY) == XTABS) { 2003844: 12 80 00 09 bne 2003868 2003848: 84 02 40 03 add %o1, %g3, %g2 tty->column += i; 200384c: c4 26 60 28 st %g2, [ %i1 + 0x28 ] rtems_termios_puts ( " ", i, tty); 2003850: 94 10 00 19 mov %i1, %o2 2003854: 11 00 80 5b sethi %hi(0x2016c00), %o0 2003858: 7f ff ff 77 call 2003634 200385c: 90 12 20 20 or %o0, 0x20, %o0 ! 2016c20 2003860: 81 c7 e0 08 ret 2003864: 81 e8 00 00 restore return; } tty->column += i; 2003868: 10 80 00 1b b 20038d4 <== NOT EXECUTED 200386c: c4 26 60 28 st %g2, [ %i1 + 0x28 ] <== NOT EXECUTED break; case '\b': if (tty->column > 0) 2003870: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003874: 04 80 00 18 ble 20038d4 <== NOT EXECUTED 2003878: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); if (!iscntrl(c)) tty->column++; 200387c: 10 80 00 16 b 20038d4 <== NOT EXECUTED 2003880: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 2003884: 02 80 00 0b be 20038b0 2003888: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2 c = toupper(c); 200388c: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 2003890: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 20180e0 <__ctype_ptr> <== NOT EXECUTED oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 2003894: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 2003898: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 <== NOT EXECUTED 200389c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 20038a0: 32 80 00 02 bne,a 20038a8 <== NOT EXECUTED 20038a4: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED 20038a8: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED if (!iscntrl(c)) 20038ac: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2 <== NOT EXECUTED 20038b0: 03 00 80 60 sethi %hi(0x2018000), %g1 20038b4: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 20180e0 <__ctype_ptr> 20038b8: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 20038bc: 80 88 60 20 btst 0x20, %g1 20038c0: 12 80 00 06 bne 20038d8 20038c4: 94 10 00 19 mov %i1, %o2 tty->column++; 20038c8: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 20038cc: 82 00 60 01 inc %g1 20038d0: c2 26 60 28 st %g1, [ %i1 + 0x28 ] break; } } rtems_termios_puts (&c, 1, tty); 20038d4: 94 10 00 19 mov %i1, %o2 20038d8: 90 07 a0 44 add %fp, 0x44, %o0 20038dc: 7f ff ff 56 call 2003634 20038e0: 92 10 20 01 mov 1, %o1 20038e4: 81 c7 e0 08 ret 20038e8: 81 e8 00 00 restore 020057a8 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 20057a8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 20057ac: 80 a6 20 00 cmp %i0, 0 20057b0: 02 80 00 2c be 2005860 20057b4: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 20057b8: d2 06 00 00 ld [ %i0 ], %o1 20057bc: 31 00 80 69 sethi %hi(0x201a400), %i0 20057c0: 40 00 0c b3 call 2008a8c <_Objects_Get> 20057c4: 90 16 22 d0 or %i0, 0x2d0, %o0 ! 201a6d0 <_POSIX_Barrier_Information> return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 20057c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057cc: 80 a0 60 00 cmp %g1, 0 20057d0: 02 80 00 07 be 20057ec 20057d4: 88 10 00 08 mov %o0, %g4 20057d8: 80 a0 60 02 cmp %g1, 2 20057dc: 18 80 00 1d bgu 2005850 20057e0: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 20057e4: 81 c7 e0 08 ret 20057e8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 20057ec: c2 02 20 58 ld [ %o0 + 0x58 ], %g1 20057f0: 80 a0 60 00 cmp %g1, 0 20057f4: 22 80 00 06 be,a 200580c 20057f8: 90 16 22 d0 or %i0, 0x2d0, %o0 _Thread_Enable_dispatch(); 20057fc: 7f ff ff de call 2005774 <_Thread_Enable_dispatch> 2005800: 01 00 00 00 nop 2005804: 10 80 00 18 b 2005864 2005808: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200580c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005810: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005814: 05 00 00 3f sethi %hi(0xfc00), %g2 2005818: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200581c: 82 08 40 02 and %g1, %g2, %g1 2005820: 80 a0 40 03 cmp %g1, %g3 2005824: 18 80 00 05 bgu 2005838 2005828: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200582c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005830: 83 28 60 02 sll %g1, 2, %g1 2005834: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free ( POSIX_Barrier_Control *the_barrier ) { _Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object ); 2005838: 40 00 0c 53 call 2008984 <_Objects_Free> 200583c: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 2005840: 7f ff ff cd call 2005774 <_Thread_Enable_dispatch> 2005844: 01 00 00 00 nop 2005848: 10 80 00 07 b 2005864 200584c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005850: 40 00 01 fc call 2006040 <== NOT EXECUTED 2005854: 01 00 00 00 nop <== NOT EXECUTED } 2005858: 81 c7 e0 08 ret <== NOT EXECUTED 200585c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005860: 90 10 20 16 mov 0x16, %o0 } 2005864: b0 10 00 08 mov %o0, %i0 2005868: 81 c7 e0 08 ret 200586c: 81 e8 00 00 restore 020058a4 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 20058a4: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 20058a8: 80 a6 20 00 cmp %i0, 0 20058ac: 02 80 00 36 be 2005984 20058b0: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 20058b4: 80 a6 a0 00 cmp %i2, 0 20058b8: 02 80 00 33 be 2005984 20058bc: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 20058c0: 32 80 00 06 bne,a 20058d8 20058c4: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 20058c8: a0 07 bf e8 add %fp, -24, %l0 20058cc: 7f ff ff 93 call 2005718 20058d0: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 20058d4: c2 04 00 00 ld [ %l0 ], %g1 20058d8: 80 a0 60 00 cmp %g1, 0 20058dc: 02 80 00 2a be 2005984 20058e0: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 20058e4: c2 04 20 04 ld [ %l0 + 4 ], %g1 20058e8: 80 a0 60 00 cmp %g1, 0 20058ec: 12 80 00 26 bne 2005984 20058f0: 05 00 80 68 sethi %hi(0x201a000), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20058f4: c2 00 a2 20 ld [ %g2 + 0x220 ], %g1 ! 201a220 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 20058f8: f4 27 bf f4 st %i2, [ %fp + -12 ] 20058fc: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2005900: c0 27 bf f0 clr [ %fp + -16 ] 2005904: c2 20 a2 20 st %g1, [ %g2 + 0x220 ] * This function allocates a barrier control block from * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) 2005908: 35 00 80 69 sethi %hi(0x201a400), %i2 200590c: 40 00 0b 1c call 200857c <_Objects_Allocate> 2005910: 90 16 a2 d0 or %i2, 0x2d0, %o0 ! 201a6d0 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 2005914: a0 92 20 00 orcc %o0, 0, %l0 2005918: 12 80 00 06 bne 2005930 200591c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 2005920: 7f ff ff d4 call 2005870 <_Thread_Enable_dispatch> 2005924: b0 10 20 0b mov 0xb, %i0 2005928: 81 c7 e0 08 ret 200592c: 81 e8 00 00 restore return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005930: 40 00 08 6a call 2007ad8 <_CORE_barrier_Initialize> 2005934: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005938: 90 16 a2 d0 or %i2, 0x2d0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200593c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005940: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005944: 05 00 00 3f sethi %hi(0xfc00), %g2 2005948: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200594c: 82 08 40 02 and %g1, %g2, %g1 2005950: 80 a0 40 03 cmp %g1, %g3 2005954: 38 80 00 06 bgu,a 200596c 2005958: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200595c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005960: 83 28 60 02 sll %g1, 2, %g1 2005964: e0 20 80 01 st %l0, [ %g2 + %g1 ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 2005968: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200596c: c0 24 20 0c clr [ %l0 + 0xc ] 2005970: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005974: 7f ff ff bf call 2005870 <_Thread_Enable_dispatch> 2005978: b0 10 20 00 clr %i0 200597c: 81 c7 e0 08 ret 2005980: 81 e8 00 00 restore return 0; } 2005984: 81 c7 e0 08 ret 2005988: 91 e8 20 16 restore %g0, 0x16, %o0 0200598c : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 200598c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 2005990: 80 a6 20 00 cmp %i0, 0 2005994: 02 80 00 28 be 2005a34 2005998: 11 00 80 69 sethi %hi(0x201a400), %o0 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 200599c: d2 06 00 00 ld [ %i0 ], %o1 20059a0: 94 07 bf f4 add %fp, -12, %o2 20059a4: 40 00 0c 3a call 2008a8c <_Objects_Get> 20059a8: 90 12 22 d0 or %o0, 0x2d0, %o0 return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 20059ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20059b0: 80 a0 60 00 cmp %g1, 0 20059b4: 22 80 00 07 be,a 20059d0 20059b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20059bc: 80 a0 60 02 cmp %g1, 2 20059c0: 18 80 00 19 bgu 2005a24 20059c4: 90 10 20 16 mov 0x16, %o0 return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20059c8: 81 c7 e0 08 ret 20059cc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_barrier_Wait( 20059d0: 94 10 20 01 mov 1, %o2 20059d4: 90 02 20 10 add %o0, 0x10, %o0 20059d8: 96 10 20 00 clr %o3 20059dc: 40 00 08 4b call 2007b08 <_CORE_barrier_Wait> 20059e0: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20059e4: 03 00 80 68 sethi %hi(0x201a000), %g1 20059e8: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 201a220 <_Thread_Dispatch_disable_level> 20059ec: 84 00 bf ff add %g2, -1, %g2 20059f0: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20059f4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20059f8: 80 a0 60 00 cmp %g1, 0 20059fc: 12 80 00 05 bne 2005a10 2005a00: 03 00 80 68 sethi %hi(0x201a000), %g1 _Thread_Dispatch(); 2005a04: 40 00 10 e8 call 2009da4 <_Thread_Dispatch> 2005a08: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 2005a0c: 03 00 80 68 sethi %hi(0x201a000), %g1 2005a10: c2 00 63 00 ld [ %g1 + 0x300 ], %g1 ! 201a300 <_Thread_Executing> 2005a14: 40 00 1e e6 call 200d5ac <_POSIX_Barrier_Translate_core_barrier_return_code> 2005a18: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2005a1c: 81 c7 e0 08 ret 2005a20: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2005a24: 40 00 01 87 call 2006040 <== NOT EXECUTED 2005a28: 01 00 00 00 nop <== NOT EXECUTED } 2005a2c: 81 c7 e0 08 ret <== NOT EXECUTED 2005a30: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2005a34: 90 10 20 16 mov 0x16, %o0 } 2005a38: b0 10 00 08 mov %o0, %i0 2005a3c: 81 c7 e0 08 ret 2005a40: 81 e8 00 00 restore 02004f24 : */ int pthread_cancel( pthread_t thread ) { 2004f24: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004f28: 03 00 80 5c sethi %hi(0x2017000), %g1 2004f2c: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 2004f30: 92 10 00 18 mov %i0, %o1 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 2004f34: 80 a0 60 00 cmp %g1, 0 2004f38: 12 80 00 2e bne 2004ff0 2004f3c: 90 10 20 47 mov 0x47, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2004f40: 11 00 80 5d sethi %hi(0x2017400), %o0 2004f44: 94 07 bf f4 add %fp, -12, %o2 2004f48: 40 00 0d 00 call 2008348 <_Objects_Get> 2004f4c: 90 12 21 08 or %o0, 0x108, %o0 return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2004f50: c2 07 bf f4 ld [ %fp + -12 ], %g1 2004f54: 80 a0 60 01 cmp %g1, 1 2004f58: 02 80 00 08 be 2004f78 2004f5c: 01 00 00 00 nop 2004f60: 2a 80 00 0a bcs,a 2004f88 2004f64: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 2004f68: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2004f6c: 02 80 00 21 be 2004ff0 <== NOT EXECUTED 2004f70: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2004f74: 30 80 00 1d b,a 2004fe8 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); 2004f78: 40 00 02 9b call 20059e4 <== NOT EXECUTED 2004f7c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2004f80: 81 c7 e0 08 ret <== NOT EXECUTED 2004f84: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; thread_support->cancelation_requested = 1; 2004f88: 82 10 20 01 mov 1, %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2004f8c: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 2004f90: 80 a0 a0 00 cmp %g2, 0 2004f94: 12 80 00 08 bne 2004fb4 2004f98: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 2004f9c: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 2004fa0: 80 a0 60 01 cmp %g1, 1 2004fa4: 12 80 00 04 bne 2004fb4 2004fa8: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS ) { _POSIX_Threads_cancel_run( the_thread ); 2004fac: 40 00 00 14 call 2004ffc <_POSIX_Threads_cancel_run> 2004fb0: 01 00 00 00 nop #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2004fb4: 03 00 80 5c sethi %hi(0x2017000), %g1 2004fb8: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 2004fbc: 90 10 20 00 clr %o0 2004fc0: 84 00 bf ff add %g2, -1, %g2 2004fc4: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 2004fc8: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 2004fcc: 80 a0 60 00 cmp %g1, 0 2004fd0: 32 80 00 09 bne,a 2004ff4 2004fd4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2004fd8: 40 00 11 a2 call 2009660 <_Thread_Dispatch> 2004fdc: 01 00 00 00 nop 2004fe0: 10 80 00 04 b 2004ff0 2004fe4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2004fe8: 40 00 02 75 call 20059bc <== NOT EXECUTED 2004fec: 01 00 00 00 nop <== NOT EXECUTED } 2004ff0: b0 10 00 08 mov %o0, %i0 2004ff4: 81 c7 e0 08 ret 2004ff8: 81 e8 00 00 restore 02006198 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 2006198: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 200619c: 80 a6 20 00 cmp %i0, 0 20061a0: 32 80 00 05 bne,a 20061b4 20061a4: c2 06 00 00 ld [ %i0 ], %g1 *location = OBJECTS_ERROR; 20061a8: 82 10 20 02 mov 2, %g1 20061ac: 10 80 00 14 b 20061fc 20061b0: c2 27 bf f4 st %g1, [ %fp + -12 ] return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20061b4: 80 a0 7f ff cmp %g1, -1 20061b8: 32 80 00 0c bne,a 20061e8 20061bc: d2 06 00 00 ld [ %i0 ], %o1 /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 20061c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20061c4: 40 00 00 41 call 20062c8 <== NOT EXECUTED 20061c8: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 20061cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20061d0: 22 80 00 06 be,a 20061e8 <== NOT EXECUTED 20061d4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; 20061d8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20061dc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20061e0: 10 80 00 07 b 20061fc <== NOT EXECUTED 20061e4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 20061e8: 11 00 80 63 sethi %hi(0x2018c00), %o0 20061ec: 94 07 bf f4 add %fp, -12, %o2 20061f0: 40 00 0f 3f call 2009eec <_Objects_Get> 20061f4: 90 12 20 6c or %o0, 0x6c, %o0 20061f8: b0 10 00 08 mov %o0, %i0 POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 20061fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006200: 80 a0 60 00 cmp %g1, 0 2006204: 02 80 00 05 be 2006218 2006208: 80 a0 60 02 cmp %g1, 2 200620c: 08 80 00 20 bleu 200628c 2006210: 90 10 20 16 mov 0x16, %o0 2006214: 30 80 00 1c b,a 2006284 <== NOT EXECUTED return EINVAL; case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 2006218: 40 00 16 71 call 200bbdc <_Thread_queue_First> 200621c: 90 06 20 18 add %i0, 0x18, %o0 2006220: 80 a2 20 00 cmp %o0, 0 2006224: 02 80 00 06 be 200623c 2006228: 03 00 80 63 sethi %hi(0x2018c00), %g1 _Thread_Enable_dispatch(); 200622c: 7f ff ff ce call 2006164 <_Thread_Enable_dispatch> 2006230: 01 00 00 00 nop 2006234: 10 80 00 16 b 200628c 2006238: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200623c: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006240: 90 10 60 6c or %g1, 0x6c, %o0 2006244: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2006248: 03 00 00 3f sethi %hi(0xfc00), %g1 200624c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006250: 82 08 c0 01 and %g3, %g1, %g1 2006254: 80 a0 40 02 cmp %g1, %g2 2006258: 18 80 00 05 bgu 200626c 200625c: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2006260: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006264: 83 28 60 02 sll %g1, 2, %g1 2006268: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 200626c: 40 00 0e de call 2009de4 <_Objects_Free> 2006270: c0 26 20 0c clr [ %i0 + 0xc ] 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2006274: 7f ff ff bc call 2006164 <_Thread_Enable_dispatch> 2006278: 01 00 00 00 nop 200627c: 10 80 00 04 b 200628c 2006280: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2006284: 40 00 04 cb call 20075b0 <== NOT EXECUTED 2006288: 01 00 00 00 nop <== NOT EXECUTED } 200628c: 81 c7 e0 08 ret 2006290: 91 e8 00 08 restore %g0, %o0, %o0 020062c8 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 20062c8: 9d e3 bf 98 save %sp, -104, %sp POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 20062cc: 03 00 80 5a sethi %hi(0x2016800), %g1 int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 20062d0: a4 10 00 18 mov %i0, %l2 POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 20062d4: 80 a6 60 00 cmp %i1, 0 20062d8: 02 80 00 03 be 20062e4 20062dc: a0 10 60 9c or %g1, 0x9c, %l0 20062e0: a0 10 00 19 mov %i1, %l0 /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 20062e4: c2 04 20 04 ld [ %l0 + 4 ], %g1 20062e8: 80 a0 60 01 cmp %g1, 1 20062ec: 32 80 00 04 bne,a 20062fc 20062f0: c2 04 00 00 ld [ %l0 ], %g1 return POSIX_MP_NOT_IMPLEMENTED(); 20062f4: 40 00 04 b9 call 20075d8 <== NOT EXECUTED 20062f8: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_attr->is_initialized ) 20062fc: 80 a0 60 00 cmp %g1, 0 2006300: 02 80 00 0e be 2006338 2006304: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006308: 05 00 80 61 sethi %hi(0x2018400), %g2 200630c: c2 00 a3 20 ld [ %g2 + 0x320 ], %g1 ! 2018720 <_Thread_Dispatch_disable_level> 2006310: 82 00 60 01 inc %g1 2006314: c2 20 a3 20 st %g1, [ %g2 + 0x320 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 2006318: 23 00 80 63 sethi %hi(0x2018c00), %l1 200631c: 40 00 0d b0 call 20099dc <_Objects_Allocate> 2006320: 90 14 60 6c or %l1, 0x6c, %o0 ! 2018c6c <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 2006324: b2 92 20 00 orcc %o0, 0, %i1 2006328: 32 80 00 06 bne,a 2006340 200632c: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 2006330: 7f ff ff d9 call 2006294 <_Thread_Enable_dispatch> 2006334: b0 10 20 0c mov 0xc, %i0 2006338: 81 c7 e0 08 ret 200633c: 81 e8 00 00 restore the_cond->process_shared = the_attr->process_shared; the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 2006340: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return EAGAIN; } #endif the_cond->process_shared = the_attr->process_shared; 2006344: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 2006348: c0 26 60 14 clr [ %i1 + 0x14 ] /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 200634c: 92 10 20 00 clr %o1 2006350: 94 10 28 00 mov 0x800, %o2 2006354: 40 00 16 4c call 200bc84 <_Thread_queue_Initialize> 2006358: 96 10 20 74 mov 0x74, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200635c: 90 14 60 6c or %l1, 0x6c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2006360: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006364: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2006368: 03 00 00 3f sethi %hi(0xfc00), %g1 200636c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006370: 82 08 80 01 and %g2, %g1, %g1 2006374: 80 a0 40 03 cmp %g1, %g3 2006378: 38 80 00 06 bgu,a 2006390 200637c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2006380: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006384: 83 28 60 02 sll %g1, 2, %g1 2006388: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 200638c: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2006390: c0 26 60 0c clr [ %i1 + 0xc ] 2006394: c2 24 80 00 st %g1, [ %l2 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2006398: 7f ff ff bf call 2006294 <_Thread_Enable_dispatch> 200639c: b0 10 20 00 clr %i0 return 0; } 20063a0: 81 c7 e0 08 ret 20063a4: 81 e8 00 00 restore 020060dc : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 20060dc: 9d e3 bf 68 save %sp, -152, %sp Thread_Control *the_thread; POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 20060e0: 03 00 80 6a sethi %hi(0x201a800), %g1 pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 20060e4: ac 10 00 18 mov %i0, %l6 Thread_Control *the_thread; POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 20060e8: 80 a6 60 00 cmp %i1, 0 20060ec: 02 80 00 03 be 20060f8 20060f0: a2 10 60 90 or %g1, 0x90, %l1 20060f4: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 20060f8: c2 04 40 00 ld [ %l1 ], %g1 20060fc: 80 a0 60 00 cmp %g1, 0 2006100: 02 80 00 65 be 2006294 2006104: b0 10 20 16 mov 0x16, %i0 /* * Core Thread Initialize insures we get the minimum amount of * stack space if it is allowed to allocate it itself. */ if ( the_attr->stackaddr && !_Stack_Is_enough( the_attr->stacksize ) ) 2006108: c2 04 60 04 ld [ %l1 + 4 ], %g1 200610c: 80 a0 60 00 cmp %g1, 0 2006110: 22 80 00 07 be,a 200612c 2006114: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 2006118: c2 04 60 08 ld [ %l1 + 8 ], %g1 200611c: 80 a0 6f ff cmp %g1, 0xfff 2006120: 08 80 00 8b bleu 200634c 2006124: 01 00 00 00 nop * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 2006128: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 200612c: 80 a0 60 01 cmp %g1, 1 2006130: 02 80 00 06 be 2006148 2006134: 80 a0 60 02 cmp %g1, 2 2006138: 12 80 00 57 bne 2006294 200613c: b0 10 20 16 mov 0x16, %i0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 2006140: 10 80 00 0a b 2006168 2006144: e4 04 60 14 ld [ %l1 + 0x14 ], %l2 * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2006148: 03 00 80 72 sethi %hi(0x201c800), %g1 200614c: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 ! 201c8e0 <_Thread_Executing> schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2006150: 90 07 bf e0 add %fp, -32, %o0 * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2006154: d2 00 61 74 ld [ %g1 + 0x174 ], %o1 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2006158: 94 10 20 18 mov 0x18, %o2 */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; schedpolicy = api->schedpolicy; 200615c: e4 02 60 7c ld [ %o1 + 0x7c ], %l2 schedparam = api->schedparam; 2006160: 10 80 00 05 b 2006174 2006164: 92 02 60 80 add %o1, 0x80, %o1 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; 2006168: 90 07 bf e0 add %fp, -32, %o0 200616c: 92 04 60 18 add %l1, 0x18, %o1 2006170: 94 10 20 18 mov 0x18, %o2 2006174: 40 00 28 ff call 2010570 2006178: b0 10 20 86 mov 0x86, %i0 /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 200617c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006180: 80 a0 60 00 cmp %g1, 0 2006184: 12 80 00 44 bne 2006294 2006188: ea 07 bf e0 ld [ %fp + -32 ], %l5 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 200618c: 82 05 7f ff add %l5, -1, %g1 2006190: 80 a0 60 fd cmp %g1, 0xfd 2006194: 18 80 00 6d bgu 2006348 2006198: 80 a4 a0 01 cmp %l2, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 200619c: 02 80 00 10 be 20061dc 20061a0: a0 10 20 00 clr %l0 20061a4: 14 80 00 08 bg 20061c4 20061a8: 80 a4 a0 02 cmp %l2, 2 20061ac: 80 a4 a0 00 cmp %l2, 0 20061b0: a0 10 20 01 mov 1, %l0 20061b4: 02 80 00 1a be 200621c 20061b8: a8 10 20 00 clr %l4 *thread = the_thread->Object.id; _Thread_Enable_dispatch(); return 0; 20061bc: 81 c7 e0 08 ret 20061c0: 91 e8 20 16 restore %g0, 0x16, %o0 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20061c4: 02 80 00 05 be 20061d8 20061c8: 80 a4 a0 03 cmp %l2, 3 20061cc: 12 80 00 32 bne 2006294 20061d0: b0 10 20 16 mov 0x16, %i0 20061d4: 30 80 00 04 b,a 20061e4 20061d8: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED 20061dc: 10 80 00 10 b 200621c 20061e0: a8 10 20 00 clr %l4 case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) < 20061e4: 40 00 16 60 call 200bb64 <_Timespec_To_ticks> 20061e8: 90 07 bf e8 add %fp, -24, %o0 20061ec: a0 10 00 08 mov %o0, %l0 20061f0: 40 00 16 5d call 200bb64 <_Timespec_To_ticks> 20061f4: 90 07 bf f0 add %fp, -16, %o0 20061f8: 80 a4 00 08 cmp %l0, %o0 20061fc: 0a 80 00 53 bcs 2006348 2006200: c2 07 bf e4 ld [ %fp + -28 ], %g1 _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 2006204: 82 00 7f ff add %g1, -1, %g1 2006208: 80 a0 60 fd cmp %g1, 0xfd 200620c: 18 80 00 4f bgu 2006348 2006210: 03 00 80 19 sethi %hi(0x2006400), %g1 2006214: a0 10 20 03 mov 3, %l0 2006218: a8 10 63 04 or %g1, 0x304, %l4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200621c: 05 00 80 72 sethi %hi(0x201c800), %g2 2006220: c2 00 a0 00 ld [ %g2 ], %g1 2006224: 82 00 60 01 inc %g1 2006228: c2 20 a0 00 st %g1, [ %g2 ] * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 200622c: 27 00 80 72 sethi %hi(0x201c800), %l3 2006230: 40 00 0b 9c call 20090a0 <_Objects_Allocate> 2006234: 90 14 e2 e8 or %l3, 0x2e8, %o0 ! 201cae8 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 2006238: b2 92 20 00 orcc %o0, 0, %i1 200623c: 02 80 00 14 be 200628c 2006240: 90 14 e2 e8 or %l3, 0x2e8, %o0 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 2006244: d4 04 60 04 ld [ %l1 + 4 ], %o2 2006248: d6 04 60 08 ld [ %l1 + 8 ], %o3 200624c: e0 23 a0 60 st %l0, [ %sp + 0x60 ] 2006250: e8 23 a0 64 st %l4, [ %sp + 0x64 ] 2006254: c0 23 a0 68 clr [ %sp + 0x68 ] 2006258: c0 23 a0 6c clr [ %sp + 0x6c ] 200625c: 9a 10 20 ff mov 0xff, %o5 2006260: a6 10 20 01 mov 1, %l3 2006264: 9a 23 40 15 sub %o5, %l5, %o5 2006268: e6 23 a0 5c st %l3, [ %sp + 0x5c ] 200626c: 92 10 00 19 mov %i1, %o1 2006270: 40 00 12 19 call 200aad4 <_Thread_Initialize> 2006274: 98 10 20 01 mov 1, %o4 budget_callout, 0, /* isr level */ NULL /* posix threads don't have a name */ ); if ( !status ) { 2006278: 80 a2 20 00 cmp %o0, 0 200627c: 32 80 00 08 bne,a 200629c 2006280: e0 06 61 74 ld [ %i1 + 0x174 ], %l0 _POSIX_Threads_Free( the_thread ); 2006284: 7f ff ff 82 call 200608c <_POSIX_Threads_Free> 2006288: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); 200628c: 7f ff ff 87 call 20060a8 <_Thread_Enable_dispatch> 2006290: b0 10 20 0b mov 0xb, %i0 2006294: 81 c7 e0 08 ret 2006298: 81 e8 00 00 restore */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; 200629c: 92 10 00 11 mov %l1, %o1 20062a0: 94 10 20 38 mov 0x38, %o2 20062a4: 40 00 28 b3 call 2010570 20062a8: 90 10 00 10 mov %l0, %o0 api->detachstate = the_attr->detachstate; 20062ac: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; api->schedparam = schedparam; 20062b0: 92 07 bf e0 add %fp, -32, %o1 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 20062b4: c2 24 20 38 st %g1, [ %l0 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 20062b8: 94 10 20 18 mov 0x18, %o2 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; 20062bc: e4 24 20 7c st %l2, [ %l0 + 0x7c ] api->schedparam = schedparam; 20062c0: 40 00 28 ac call 2010570 20062c4: 90 04 20 80 add %l0, 0x80, %o0 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 20062c8: 94 10 00 1a mov %i2, %o2 * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = TRUE; 20062cc: e6 26 60 78 st %l3, [ %i1 + 0x78 ] /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 20062d0: 96 10 00 1b mov %i3, %o3 20062d4: 90 10 00 19 mov %i1, %o0 20062d8: 92 10 20 01 mov 1, %o1 20062dc: 40 00 15 6b call 200b888 <_Thread_Start> 20062e0: 98 10 20 00 clr %o4 start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 20062e4: 80 a4 a0 03 cmp %l2, 3 20062e8: 12 80 00 09 bne 200630c 20062ec: a2 10 00 08 mov %o0, %l1 _Watchdog_Insert_ticks( 20062f0: 40 00 16 1d call 200bb64 <_Timespec_To_ticks> 20062f4: 90 04 20 88 add %l0, 0x88, %o0 20062f8: 92 04 20 9c add %l0, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20062fc: d0 24 20 a8 st %o0, [ %l0 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006300: 11 00 80 72 sethi %hi(0x201c800), %o0 2006304: 40 00 17 11 call 200bf48 <_Watchdog_Insert> 2006308: 90 12 21 00 or %o0, 0x100, %o0 ! 201c900 <_Watchdog_Ticks_chain> /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 200630c: 80 a4 60 00 cmp %l1, 0 2006310: 12 80 00 08 bne 2006330 2006314: 90 10 00 19 mov %i1, %o0 _POSIX_Threads_Free( the_thread ); 2006318: 7f ff ff 5d call 200608c <_POSIX_Threads_Free> <== NOT EXECUTED 200631c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2006320: 7f ff ff 62 call 20060a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2006324: 01 00 00 00 nop <== NOT EXECUTED 2006328: 81 c7 e0 08 ret <== NOT EXECUTED 200632c: 81 e8 00 00 restore <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 2006330: c2 06 60 08 ld [ %i1 + 8 ], %g1 _Thread_Enable_dispatch(); 2006334: b0 10 20 00 clr %i0 2006338: 7f ff ff 5c call 20060a8 <_Thread_Enable_dispatch> 200633c: c2 25 80 00 st %g1, [ %l6 ] 2006340: 81 c7 e0 08 ret 2006344: 81 e8 00 00 restore return 0; 2006348: b0 10 20 16 mov 0x16, %i0 } 200634c: 81 c7 e0 08 ret 2006350: 81 e8 00 00 restore 02005790 : #include int pthread_detach( pthread_t thread ) { 2005790: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2005794: 11 00 80 5c sethi %hi(0x2017000), %o0 2005798: 92 10 00 18 mov %i0, %o1 200579c: 90 12 22 b8 or %o0, 0x2b8, %o0 20057a0: 40 00 0b fe call 2008798 <_Objects_Get> 20057a4: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 20057a8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057ac: 80 a0 60 00 cmp %g1, 0 20057b0: 22 80 00 06 be,a 20057c8 20057b4: c2 02 21 74 ld [ %o0 + 0x174 ], %g1 20057b8: 80 a0 60 02 cmp %g1, 2 20057bc: 08 80 00 13 bleu 2005808 20057c0: 90 10 20 03 mov 3, %o0 20057c4: 30 80 00 0f b,a 2005800 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 20057c8: c0 20 60 38 clr [ %g1 + 0x38 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20057cc: 05 00 80 5b sethi %hi(0x2016c00), %g2 20057d0: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 ! 2016fd0 <_Thread_Dispatch_disable_level> 20057d4: 90 10 20 00 clr %o0 20057d8: 82 00 7f ff add %g1, -1, %g1 20057dc: c2 20 a3 d0 st %g1, [ %g2 + 0x3d0 ] 20057e0: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 20057e4: 80 a0 60 00 cmp %g1, 0 20057e8: 12 80 00 08 bne 2005808 20057ec: 01 00 00 00 nop _Thread_Dispatch(); 20057f0: 40 00 10 b0 call 2009ab0 <_Thread_Dispatch> 20057f4: 01 00 00 00 nop 20057f8: 10 80 00 04 b 2005808 20057fc: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005800: 40 00 01 82 call 2005e08 <== NOT EXECUTED 2005804: 01 00 00 00 nop <== NOT EXECUTED } 2005808: 81 c7 e0 08 ret 200580c: 91 e8 00 08 restore %g0, %o0, %o0 0200dd38 : #include void pthread_exit( void *value_ptr ) { 200dd38: 9d e3 bf 98 save %sp, -104, %sp Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); 200dd3c: 25 00 80 62 sethi %hi(0x2018800), %l2 200dd40: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 200dd44: c6 00 60 08 ld [ %g1 + 8 ], %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 200dd48: 03 00 80 62 sethi %hi(0x2018800), %g1 200dd4c: 85 30 e0 16 srl %g3, 0x16, %g2 200dd50: 82 10 62 50 or %g1, 0x250, %g1 200dd54: 84 08 a0 1c and %g2, 0x1c, %g2 200dd58: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200dd5c: 87 30 e0 1b srl %g3, 0x1b, %g3 200dd60: 87 28 e0 02 sll %g3, 2, %g3 200dd64: e2 00 40 03 ld [ %g1 + %g3 ], %l1 /* This should never happen if _Thread_Get() works right */ assert( the_information ); 200dd68: 80 a4 60 00 cmp %l1, 0 200dd6c: 12 80 00 09 bne 200dd90 200dd70: 21 00 80 62 sethi %hi(0x2018800), %l0 200dd74: 11 00 80 5c sethi %hi(0x2017000), %o0 <== NOT EXECUTED 200dd78: 15 00 80 5c sethi %hi(0x2017000), %o2 <== NOT EXECUTED 200dd7c: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED 200dd80: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED 200dd84: 7f ff d0 60 call 2001f04 <__assert> <== NOT EXECUTED 200dd88: 92 10 20 25 mov 0x25, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200dd8c: 21 00 80 62 sethi %hi(0x2018800), %l0 <== NOT EXECUTED 200dd90: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 200dd94: 82 00 60 01 inc %g1 200dd98: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] _Thread_Disable_dispatch(); _Thread_Executing->Wait.return_argument = value_ptr; 200dd9c: d2 04 a3 d0 ld [ %l2 + 0x3d0 ], %o1 _Thread_Close( the_information, _Thread_Executing ); 200dda0: 90 10 00 11 mov %l1, %o0 200dda4: 7f ff ea ff call 20089a0 <_Thread_Close> 200dda8: f0 22 60 28 st %i0, [ %o1 + 0x28 ] RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 200ddac: d2 04 a3 d0 ld [ %l2 + 0x3d0 ], %o1 200ddb0: 11 00 80 63 sethi %hi(0x2018c00), %o0 200ddb4: 7f ff e6 43 call 20076c0 <_Objects_Free> 200ddb8: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 2018dd8 <_POSIX_Threads_Information> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ddbc: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 200ddc0: 82 00 7f ff add %g1, -1, %g1 200ddc4: c2 24 22 f0 st %g1, [ %l0 + 0x2f0 ] 200ddc8: c2 04 22 f0 ld [ %l0 + 0x2f0 ], %g1 200ddcc: 80 a0 60 00 cmp %g1, 0 200ddd0: 12 80 00 04 bne 200dde0 200ddd4: 01 00 00 00 nop _Thread_Dispatch(); 200ddd8: 7f ff eb 81 call 2008bdc <_Thread_Dispatch> 200dddc: 81 e8 00 00 restore 200dde0: 81 c7 e0 08 ret <== NOT EXECUTED 200dde4: 81 e8 00 00 restore <== NOT EXECUTED 02007d18 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 2007d18: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 2007d1c: 80 a6 60 00 cmp %i1, 0 2007d20: 02 80 00 05 be 2007d34 2007d24: 92 10 00 18 mov %i0, %o1 2007d28: 80 a6 a0 00 cmp %i2, 0 2007d2c: 32 80 00 04 bne,a 2007d3c 2007d30: 11 00 80 69 sethi %hi(0x201a400), %o0 2007d34: 10 80 00 27 b 2007dd0 2007d38: 90 10 20 16 mov 0x16, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2007d3c: 94 07 bf f4 add %fp, -12, %o2 2007d40: 40 00 0c 12 call 200ad88 <_Objects_Get> 2007d44: 90 12 23 e8 or %o0, 0x3e8, %o0 return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2007d48: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d4c: 80 a0 60 00 cmp %g1, 0 2007d50: 02 80 00 06 be 2007d68 2007d54: b0 10 00 08 mov %o0, %i0 2007d58: 80 a0 60 02 cmp %g1, 2 2007d5c: 08 80 00 1d bleu 2007dd0 2007d60: 90 10 20 03 mov 3, %o0 2007d64: 30 80 00 19 b,a 2007dc8 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2007d68: d2 02 21 74 ld [ %o0 + 0x174 ], %o1 if ( policy ) *policy = api->schedpolicy; if ( param ) { *param = api->schedparam; 2007d6c: 94 10 20 18 mov 0x18, %o2 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 2007d70: c2 02 60 7c ld [ %o1 + 0x7c ], %g1 if ( param ) { *param = api->schedparam; 2007d74: 90 10 00 1a mov %i2, %o0 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 2007d78: c2 26 40 00 st %g1, [ %i1 ] if ( param ) { *param = api->schedparam; 2007d7c: 40 00 28 a2 call 2012004 2007d80: 92 02 60 80 add %o1, 0x80, %o1 param->sched_priority = 2007d84: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 2007d88: 82 10 20 ff mov 0xff, %g1 2007d8c: 82 20 40 02 sub %g1, %g2, %g1 2007d90: c2 26 80 00 st %g1, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007d94: 05 00 80 69 sethi %hi(0x201a400), %g2 2007d98: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007d9c: 90 10 20 00 clr %o0 2007da0: 82 00 7f ff add %g1, -1, %g1 2007da4: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007da8: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 2007dac: 80 a0 60 00 cmp %g1, 0 2007db0: 12 80 00 08 bne 2007dd0 2007db4: 01 00 00 00 nop _Thread_Dispatch(); 2007db8: 40 00 10 ba call 200c0a0 <_Thread_Dispatch> 2007dbc: 01 00 00 00 nop 2007dc0: 10 80 00 04 b 2007dd0 2007dc4: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007dc8: 40 00 01 8c call 20083f8 <== NOT EXECUTED 2007dcc: 01 00 00 00 nop <== NOT EXECUTED } 2007dd0: 81 c7 e0 08 ret 2007dd4: 91 e8 00 08 restore %g0, %o0, %o0 02005798 : */ void *pthread_getspecific( pthread_key_t key ) { 2005798: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Keys_Control *) 200579c: 11 00 80 5d sethi %hi(0x2017400), %o0 20057a0: 92 10 00 18 mov %i0, %o1 20057a4: 90 12 22 f0 or %o0, 0x2f0, %o0 20057a8: 40 00 0c a4 call 2008a38 <_Objects_Get> 20057ac: 94 07 bf f4 add %fp, -12, %o2 uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 20057b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057b4: 80 a0 60 00 cmp %g1, 0 20057b8: 22 80 00 06 be,a 20057d0 20057bc: 03 00 80 5c sethi %hi(0x2017000), %g1 20057c0: 80 a0 60 02 cmp %g1, 2 20057c4: 08 80 00 18 bleu 2005824 20057c8: b0 10 20 00 clr %i0 20057cc: 30 80 00 18 b,a 200582c <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return NULL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 20057d0: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 20057d4: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 20057d8: 83 30 a0 16 srl %g2, 0x16, %g1 20057dc: 82 08 60 1c and %g1, 0x1c, %g1 20057e0: 82 00 40 08 add %g1, %o0, %g1 20057e4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 20057e8: 03 00 00 3f sethi %hi(0xfc00), %g1 20057ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20057f0: 84 08 80 01 and %g2, %g1, %g2 20057f4: 85 28 a0 02 sll %g2, 2, %g2 20057f8: f0 00 c0 02 ld [ %g3 + %g2 ], %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20057fc: 05 00 80 5c sethi %hi(0x2017000), %g2 2005800: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 2005804: 82 00 7f ff add %g1, -1, %g1 2005808: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 200580c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2005810: 80 a0 60 00 cmp %g1, 0 2005814: 12 80 00 08 bne 2005834 2005818: 01 00 00 00 nop _Thread_Dispatch(); 200581c: 40 00 11 4d call 2009d50 <_Thread_Dispatch> 2005820: 01 00 00 00 nop 2005824: 81 c7 e0 08 ret 2005828: 81 e8 00 00 restore _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); 200582c: 40 00 02 1f call 20060a8 <== NOT EXECUTED 2005830: b0 10 20 00 clr %i0 <== NOT EXECUTED return (void *)NULL; } 2005834: 81 c7 e0 08 ret <== NOT EXECUTED 2005838: 81 e8 00 00 restore <== NOT EXECUTED 0200722c : int pthread_join( pthread_t thread, void **value_ptr ) { 200722c: 9d e3 bf 90 save %sp, -112, %sp 2007230: 11 00 80 66 sethi %hi(0x2019800), %o0 2007234: 92 10 00 18 mov %i0, %o1 2007238: 90 12 21 68 or %o0, 0x168, %o0 200723c: 40 00 0b cf call 200a178 <_Objects_Get> 2007240: 94 07 bf f4 add %fp, -12, %o2 POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2007244: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007248: 80 a0 60 00 cmp %g1, 0 200724c: 22 80 00 06 be,a 2007264 2007250: c4 02 21 74 ld [ %o0 + 0x174 ], %g2 2007254: 80 a0 60 02 cmp %g1, 2 2007258: 08 80 00 25 bleu 20072ec 200725c: 90 10 20 03 mov 3, %o0 2007260: 30 80 00 21 b,a 20072e4 <== NOT EXECUTED case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 2007264: c2 00 a0 38 ld [ %g2 + 0x38 ], %g1 2007268: 80 a0 60 00 cmp %g1, 0 200726c: 12 80 00 06 bne 2007284 2007270: 03 00 80 65 sethi %hi(0x2019400), %g1 _Thread_Enable_dispatch(); 2007274: 7f ff ff e1 call 20071f8 <_Thread_Enable_dispatch> 2007278: 01 00 00 00 nop 200727c: 10 80 00 1c b 20072ec 2007280: 90 10 20 16 mov 0x16, %o0 ! 16 RTEMS_INLINE_ROUTINE boolean _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 2007284: c6 00 63 60 ld [ %g1 + 0x360 ], %g3 return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 2007288: 80 a2 00 03 cmp %o0, %g3 200728c: 12 80 00 06 bne 20072a4 2007290: 82 07 bf f0 add %fp, -16, %g1 _Thread_Enable_dispatch(); 2007294: 7f ff ff d9 call 20071f8 <_Thread_Enable_dispatch> 2007298: 01 00 00 00 nop 200729c: 10 80 00 14 b 20072ec 20072a0: 90 10 20 2d mov 0x2d, %o0 ! 2d _Thread_Executing->Wait.return_argument = &return_pointer; _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 20072a4: 90 00 a0 3c add %g2, 0x3c, %o0 /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 20072a8: c2 20 e0 28 st %g1, [ %g3 + 0x28 ] _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 20072ac: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 20072b0: 82 10 20 01 mov 1, %g1 20072b4: 15 00 80 2f sethi %hi(0x200bc00), %o2 20072b8: 94 12 a3 84 or %o2, 0x384, %o2 ! 200bf84 <_Thread_queue_Timeout> 20072bc: 40 00 12 0c call 200baec <_Thread_queue_Enqueue_with_handler> 20072c0: c2 20 a0 6c st %g1, [ %g2 + 0x6c ] _Thread_Enable_dispatch(); 20072c4: 7f ff ff cd call 20071f8 <_Thread_Enable_dispatch> 20072c8: 01 00 00 00 nop if ( value_ptr ) 20072cc: 80 a6 60 00 cmp %i1, 0 20072d0: 02 80 00 07 be 20072ec 20072d4: 90 10 20 00 clr %o0 *value_ptr = return_pointer; 20072d8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20072dc: 10 80 00 04 b 20072ec 20072e0: c2 26 40 00 st %g1, [ %i1 ] return 0; } return POSIX_BOTTOM_REACHED(); 20072e4: 40 00 01 41 call 20077e8 <== NOT EXECUTED 20072e8: 01 00 00 00 nop <== NOT EXECUTED } 20072ec: 81 c7 e0 08 ret 20072f0: 91 e8 00 08 restore %g0, %o0, %o0 02005530 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 2005530: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005534: 03 00 80 5c sethi %hi(0x2017000), %g1 2005538: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20171f0 <_Thread_Dispatch_disable_level> 200553c: 84 00 a0 01 inc %g2 2005540: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 2005544: 11 00 80 5d sethi %hi(0x2017400), %o0 2005548: 40 00 0b f8 call 2008528 <_Objects_Allocate> 200554c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 2005550: a0 92 20 00 orcc %o0, 0, %l0 2005554: 12 80 00 06 bne 200556c 2005558: 03 00 80 5c sethi %hi(0x2017000), %g1 _Thread_Enable_dispatch(); 200555c: 7f ff ff e8 call 20054fc <_Thread_Enable_dispatch> 2005560: b0 10 20 0b mov 0xb, %i0 2005564: 81 c7 e0 08 ret 2005568: 81 e8 00 00 restore return EAGAIN; } the_key->destructor = destructor; 200556c: f2 24 20 14 st %i1, [ %l0 + 0x14 ] for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 2005570: aa 10 61 50 or %g1, 0x150, %l5 if ( !the_key ) { _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 2005574: a2 10 00 10 mov %l0, %l1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2005578: 03 00 80 5c sethi %hi(0x2017000), %g1 200557c: a6 10 20 01 mov 1, %l3 2005580: a8 10 62 3c or %g1, 0x23c, %l4 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 2005584: a5 2c e0 02 sll %l3, 2, %l2 2005588: c2 04 80 15 ld [ %l2 + %l5 ], %g1 200558c: 80 a0 60 00 cmp %g1, 0 2005590: 02 80 00 29 be 2005634 2005594: 90 10 00 14 mov %l4, %o0 2005598: c2 00 60 04 ld [ %g1 + 4 ], %g1 200559c: 80 a0 60 00 cmp %g1, 0 20055a0: 22 80 00 26 be,a 2005638 20055a4: c0 24 60 1c clr [ %l1 + 0x1c ] <== NOT EXECUTED _Objects_Information_table[ the_api ][ 1 ] ) { bytes_to_allocate = sizeof( void * ) * 20055a8: c2 10 60 10 lduh [ %g1 + 0x10 ], %g1 20055ac: 82 00 60 01 inc %g1 20055b0: b3 28 60 02 sll %g1, 2, %i1 20055b4: 40 00 0a 85 call 2007fc8 <_Heap_Allocate> 20055b8: 92 10 00 19 mov %i1, %o1 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { 20055bc: 82 92 20 00 orcc %o0, 0, %g1 20055c0: 32 80 00 18 bne,a 2005620 20055c4: c2 24 60 1c st %g1, [ %l1 + 0x1c ] 20055c8: 82 04 a0 14 add %l2, 0x14, %g1 <== NOT EXECUTED 20055cc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20055d0: b2 04 00 01 add %l0, %g1, %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20055d4: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED 20055d8: 10 80 00 05 b 20055ec <== NOT EXECUTED 20055dc: a2 10 62 3c or %g1, 0x23c, %l1 ! 201723c <_Workspace_Area> <== NOT EXECUTED 20055e0: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED 20055e4: 40 00 0a a0 call 2008064 <_Heap_Free> <== NOT EXECUTED 20055e8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20055ec: b0 06 20 01 inc %i0 <== NOT EXECUTED for ( --the_api; the_api >= 1; 20055f0: 80 a6 00 13 cmp %i0, %l3 <== NOT EXECUTED 20055f4: 12 bf ff fb bne 20055e0 <== NOT EXECUTED 20055f8: b2 06 7f fc add %i1, -4, %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 20055fc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2005600: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED 2005604: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> <== NOT EXECUTED 2005608: 40 00 0c ca call 2008930 <_Objects_Free> <== NOT EXECUTED 200560c: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 2005610: 7f ff ff bb call 20054fc <_Thread_Enable_dispatch> <== NOT EXECUTED 2005614: 01 00 00 00 nop <== NOT EXECUTED 2005618: 81 c7 e0 08 ret <== NOT EXECUTED 200561c: 81 e8 00 00 restore <== NOT EXECUTED return ENOMEM; } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); 2005620: 94 10 00 19 mov %i1, %o2 2005624: 40 00 29 be call 200fd1c 2005628: 92 10 20 00 clr %o1 * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 200562c: 10 80 00 04 b 200563c 2005630: a6 04 e0 01 inc %l3 } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 2005634: c0 24 60 1c clr [ %l1 + 0x1c ] * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 2005638: a6 04 e0 01 inc %l3 * APIs are optional. Thus there may be no ITRON tasks to have keys * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 200563c: 80 a4 e0 05 cmp %l3, 5 2005640: 12 bf ff d1 bne 2005584 2005644: a2 04 60 04 add %l1, 4, %l1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005648: 03 00 80 5d sethi %hi(0x2017400), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200564c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005650: 88 10 62 f0 or %g1, 0x2f0, %g4 2005654: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 } } the_key->is_active = TRUE; 2005658: 82 10 20 01 mov 1, %g1 200565c: c2 24 20 10 st %g1, [ %l0 + 0x10 ] 2005660: 03 00 00 3f sethi %hi(0xfc00), %g1 2005664: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005668: 82 08 c0 01 and %g3, %g1, %g1 200566c: 80 a0 40 02 cmp %g1, %g2 2005670: 38 80 00 06 bgu,a 2005688 2005674: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2005678: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200567c: 83 28 60 02 sll %g1, 2, %g1 2005680: e0 20 80 01 st %l0, [ %g2 + %g1 ] _Objects_Open( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 2005684: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2005688: c0 24 20 0c clr [ %l0 + 0xc ] 200568c: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005690: 7f ff ff 9b call 20054fc <_Thread_Enable_dispatch> 2005694: b0 10 20 00 clr %i0 return 0; } 2005698: 81 c7 e0 08 ret 200569c: 81 e8 00 00 restore 020056a0 : */ int pthread_key_delete( pthread_key_t key ) { 20056a0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Keys_Control *) 20056a4: 92 10 00 18 mov %i0, %o1 20056a8: 94 07 bf f4 add %fp, -12, %o2 20056ac: 31 00 80 5d sethi %hi(0x2017400), %i0 20056b0: 40 00 0c e2 call 2008a38 <_Objects_Get> 20056b4: 90 16 22 f0 or %i0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 20056b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20056bc: 80 a0 60 00 cmp %g1, 0 20056c0: 02 80 00 06 be 20056d8 20056c4: a0 10 00 08 mov %o0, %l0 20056c8: 80 a0 60 02 cmp %g1, 2 20056cc: 08 80 00 31 bleu 2005790 20056d0: 90 10 20 16 mov 0x16, %o0 20056d4: 30 80 00 2d b,a 2005788 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20056d8: 90 16 22 f0 or %i0, 0x2f0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20056dc: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20056e0: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20056e4: 05 00 00 3f sethi %hi(0xfc00), %g2 20056e8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 20056ec: 82 08 40 02 and %g1, %g2, %g1 20056f0: 80 a0 40 03 cmp %g1, %g3 20056f4: 38 80 00 06 bgu,a 200570c 20056f8: 03 00 80 5c sethi %hi(0x2017000), %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20056fc: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005700: 83 28 60 02 sll %g1, 2, %g1 2005704: c0 20 80 01 clr [ %g2 + %g1 ] 2005708: 03 00 80 5c sethi %hi(0x2017000), %g1 uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200570c: c0 24 20 0c clr [ %l0 + 0xc ] case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; 2005710: c0 24 20 10 clr [ %l0 + 0x10 ] 2005714: a2 10 62 3c or %g1, 0x23c, %l1 2005718: b0 10 20 00 clr %i0 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 200571c: 82 04 00 18 add %l0, %i0, %g1 2005720: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 2005724: 80 a2 60 00 cmp %o1, 0 2005728: 02 80 00 04 be 2005738 200572c: b0 06 20 04 add %i0, 4, %i0 2005730: 40 00 0a 4d call 2008064 <_Heap_Free> 2005734: 90 10 00 11 mov %l1, %o0 _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 2005738: 80 a6 20 10 cmp %i0, 0x10 200573c: 12 bf ff f9 bne 2005720 2005740: 82 04 00 18 add %l0, %i0, %g1 RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 2005744: 92 10 00 10 mov %l0, %o1 2005748: 11 00 80 5d sethi %hi(0x2017400), %o0 200574c: 40 00 0c 79 call 2008930 <_Objects_Free> 2005750: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20176f0 <_POSIX_Keys_Information> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005754: 05 00 80 5c sethi %hi(0x2017000), %g2 2005758: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 200575c: 90 10 20 00 clr %o0 2005760: 82 00 7f ff add %g1, -1, %g1 2005764: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 2005768: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200576c: 80 a0 60 00 cmp %g1, 0 2005770: 12 80 00 08 bne 2005790 2005774: 01 00 00 00 nop _Thread_Dispatch(); 2005778: 40 00 11 76 call 2009d50 <_Thread_Dispatch> 200577c: 01 00 00 00 nop 2005780: 10 80 00 04 b 2005790 2005784: 90 10 20 00 clr %o0 ! 0 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005788: 40 00 02 48 call 20060a8 <== NOT EXECUTED 200578c: 01 00 00 00 nop <== NOT EXECUTED } 2005790: 81 c7 e0 08 ret 2005794: 91 e8 00 08 restore %g0, %o0, %o0 02021424 : int pthread_kill( pthread_t thread, int sig ) { 2021424: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 2021428: 80 a6 60 00 cmp %i1, 0 202142c: 02 80 00 06 be 2021444 2021430: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2021434: a0 06 7f ff add %i1, -1, %l0 2021438: 80 a4 20 1f cmp %l0, 0x1f 202143c: 28 80 00 06 bleu,a 2021454 2021440: 11 00 80 9f sethi %hi(0x2027c00), %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 2021444: 7f ff d5 b2 call 2016b0c <__errno> 2021448: 01 00 00 00 nop 202144c: 10 80 00 0f b 2021488 2021450: 82 10 20 16 mov 0x16, %g1 ! 16 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2021454: 94 07 bf f4 add %fp, -12, %o2 2021458: 7f ff aa f3 call 200c024 <_Objects_Get> 202145c: 90 12 21 84 or %o0, 0x184, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) rtems_set_errno_and_return_minus_one( ENOSYS ); */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2021460: c2 07 bf f4 ld [ %fp + -12 ], %g1 2021464: 80 a0 60 00 cmp %g1, 0 2021468: 02 80 00 0b be 2021494 202146c: b0 10 00 08 mov %o0, %i0 2021470: 80 a0 60 02 cmp %g1, 2 2021474: 18 80 00 29 bgu 2021518 2021478: 01 00 00 00 nop case OBJECTS_ERROR: case OBJECTS_REMOTE: rtems_set_errno_and_return_minus_one( ESRCH ); 202147c: 7f ff d5 a4 call 2016b0c <__errno> 2021480: 01 00 00 00 nop 2021484: 82 10 20 03 mov 3, %g1 ! 3 2021488: c2 22 00 00 st %g1, [ %o0 ] 202148c: 10 80 00 25 b 2021520 2021490: 90 10 3f ff mov -1, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 2021494: 83 2e 60 02 sll %i1, 2, %g1 2021498: 85 2e 60 04 sll %i1, 4, %g2 202149c: 84 20 80 01 sub %g2, %g1, %g2 20214a0: 03 00 80 a0 sethi %hi(0x2028000), %g1 20214a4: 82 10 61 68 or %g1, 0x168, %g1 ! 2028168 <_POSIX_signals_Vectors> 20214a8: 84 00 80 01 add %g2, %g1, %g2 20214ac: c2 00 a0 08 ld [ %g2 + 8 ], %g1 20214b0: 80 a0 60 01 cmp %g1, 1 20214b4: 02 80 00 15 be 2021508 20214b8: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 20214bc: c4 00 e0 c8 ld [ %g3 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20214c0: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 20214c4: b2 10 20 01 mov 1, %i1 20214c8: 83 2e 40 10 sll %i1, %l0, %g1 20214cc: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20214d0: 94 10 20 00 clr %o2 20214d4: 7f ff ff 82 call 20212dc <_POSIX_signals_Unblock_thread> 20214d8: c4 20 e0 c8 st %g2, [ %g3 + 0xc8 ] the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 20214dc: 03 00 80 9e sethi %hi(0x2027800), %g1 20214e0: c2 00 63 18 ld [ %g1 + 0x318 ], %g1 ! 2027b18 <_ISR_Nest_level> 20214e4: 80 a0 60 00 cmp %g1, 0 20214e8: 02 80 00 08 be 2021508 20214ec: f2 26 20 78 st %i1, [ %i0 + 0x78 ] 20214f0: 03 00 80 9e sethi %hi(0x2027800), %g1 20214f4: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2027b30 <_Thread_Executing> 20214f8: 80 a6 00 01 cmp %i0, %g1 20214fc: 12 80 00 03 bne 2021508 2021500: 03 00 80 9e sethi %hi(0x2027800), %g1 _ISR_Signals_to_thread_executing = TRUE; 2021504: f2 20 63 d8 st %i1, [ %g1 + 0x3d8 ] ! 2027bd8 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } _Thread_Enable_dispatch(); 2021508: 7f ff ff ba call 20213f0 <_Thread_Enable_dispatch> 202150c: 01 00 00 00 nop 2021510: 10 80 00 04 b 2021520 2021514: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2021518: 40 00 00 12 call 2021560 <== NOT EXECUTED 202151c: 01 00 00 00 nop <== NOT EXECUTED } 2021520: 81 c7 e0 08 ret 2021524: 91 e8 00 08 restore %g0, %o0, %o0 0200708c : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 200708c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007090: 80 a6 20 00 cmp %i0, 0 2007094: 02 80 00 0d be 20070c8 2007098: 82 10 20 02 mov 2, %g1 200709c: c2 06 00 00 ld [ %i0 ], %g1 20070a0: 80 a0 7f ff cmp %g1, -1 20070a4: 32 80 00 0c bne,a 20070d4 20070a8: d2 06 00 00 ld [ %i0 ], %o1 20070ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20070b0: 40 00 00 7e call 20072a8 <== NOT EXECUTED 20070b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20070b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20070bc: 22 80 00 06 be,a 20070d4 <== NOT EXECUTED 20070c0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 20070c4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20070c8: a0 10 20 00 clr %l0 <== NOT EXECUTED 20070cc: 10 80 00 07 b 20070e8 <== NOT EXECUTED 20070d0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 20070d4: 11 00 80 6a sethi %hi(0x201a800), %o0 20070d8: 94 07 bf f4 add %fp, -12, %o2 20070dc: 40 00 0f 2b call 200ad88 <_Objects_Get> 20070e0: 90 12 21 64 or %o0, 0x164, %o0 20070e4: a0 10 00 08 mov %o0, %l0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20070e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20070ec: 80 a0 60 00 cmp %g1, 0 20070f0: 22 80 00 06 be,a 2007108 20070f4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20070f8: 80 a0 60 02 cmp %g1, 2 20070fc: 08 80 00 23 bleu 2007188 2007100: 90 10 20 16 mov 0x16, %o0 2007104: 30 80 00 1f b,a 2007180 <== NOT EXECUTED /* * XXX: There is an error for the mutex being locked * or being in use by a condition variable. */ if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { 2007108: 80 a0 60 00 cmp %g1, 0 200710c: 12 80 00 06 bne 2007124 2007110: 03 00 80 6a sethi %hi(0x201a800), %g1 _Thread_Enable_dispatch(); 2007114: 7f ff ff d1 call 2007058 <_Thread_Enable_dispatch> 2007118: 01 00 00 00 nop 200711c: 10 80 00 1b b 2007188 2007120: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2007124: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2007128: b0 10 61 64 or %g1, 0x164, %i0 200712c: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2007130: 03 00 00 3f sethi %hi(0xfc00), %g1 2007134: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007138: 82 08 c0 01 and %g3, %g1, %g1 200713c: 80 a0 40 02 cmp %g1, %g2 2007140: 18 80 00 05 bgu 2007154 2007144: 94 10 20 16 mov 0x16, %o2 information->local_table[ index ] = the_object; 2007148: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 200714c: 83 28 60 02 sll %g1, 2, %g1 2007150: c0 20 80 01 clr [ %g2 + %g1 ] return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); _CORE_mutex_Flush( 2007154: 90 04 20 14 add %l0, 0x14, %o0 2007158: 92 10 20 00 clr %o1 200715c: 40 00 0b 20 call 2009ddc <_CORE_mutex_Flush> 2007160: c0 24 20 0c clr [ %l0 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free ( POSIX_Mutex_Control *the_mutex ) { _Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object ); 2007164: 90 10 00 18 mov %i0, %o0 2007168: 40 00 0e c6 call 200ac80 <_Objects_Free> 200716c: 92 10 00 10 mov %l0, %o1 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2007170: 7f ff ff ba call 2007058 <_Thread_Enable_dispatch> 2007174: 01 00 00 00 nop 2007178: 10 80 00 04 b 2007188 200717c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2007180: 40 00 04 9e call 20083f8 <== NOT EXECUTED 2007184: 01 00 00 00 nop <== NOT EXECUTED } 2007188: 81 c7 e0 08 ret 200718c: 91 e8 00 08 restore %g0, %o0, %o0 02007190 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 2007190: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 2007194: 80 a6 60 00 cmp %i1, 0 2007198: 02 80 00 33 be 2007264 200719c: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 20071a0: 02 80 00 0d be 20071d4 20071a4: 82 10 20 02 mov 2, %g1 20071a8: c2 06 00 00 ld [ %i0 ], %g1 20071ac: 80 a0 7f ff cmp %g1, -1 20071b0: 32 80 00 0c bne,a 20071e0 20071b4: d2 06 00 00 ld [ %i0 ], %o1 20071b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20071bc: 40 00 00 3b call 20072a8 <== NOT EXECUTED 20071c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20071c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20071c8: 22 80 00 06 be,a 20071e0 <== NOT EXECUTED 20071cc: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 20071d0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20071d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20071d8: 10 80 00 06 b 20071f0 <== NOT EXECUTED 20071dc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 20071e0: 11 00 80 6a sethi %hi(0x201a800), %o0 20071e4: 94 07 bf f4 add %fp, -12, %o2 20071e8: 40 00 0e e8 call 200ad88 <_Objects_Get> 20071ec: 90 12 21 64 or %o0, 0x164, %o0 return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20071f0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20071f4: 80 a0 60 00 cmp %g1, 0 20071f8: 22 80 00 07 be,a 2007214 20071fc: c4 02 20 60 ld [ %o0 + 0x60 ], %g2 2007200: 80 a0 60 02 cmp %g1, 2 2007204: 18 80 00 14 bgu 2007254 2007208: 90 10 20 16 mov 0x16, %o0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200720c: 81 c7 e0 08 ret 2007210: 91 e8 00 08 restore %g0, %o0, %o0 return POSIX_MP_NOT_IMPLEMENTED(); /* XXX feels questionable */ #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 2007214: 82 10 20 ff mov 0xff, %g1 2007218: 82 20 40 02 sub %g1, %g2, %g1 200721c: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007220: 05 00 80 69 sethi %hi(0x201a400), %g2 2007224: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 2007228: 90 10 20 00 clr %o0 200722c: 82 00 7f ff add %g1, -1, %g1 2007230: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 2007234: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 2007238: 80 a0 60 00 cmp %g1, 0 200723c: 32 80 00 0c bne,a 200726c 2007240: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2007244: 40 00 13 97 call 200c0a0 <_Thread_Dispatch> 2007248: 01 00 00 00 nop 200724c: 10 80 00 07 b 2007268 2007250: 90 10 20 00 clr %o0 ! 0 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007254: 40 00 04 69 call 20083f8 <== NOT EXECUTED 2007258: 01 00 00 00 nop <== NOT EXECUTED } 200725c: 81 c7 e0 08 ret <== NOT EXECUTED 2007260: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007264: 90 10 20 16 mov 0x16, %o0 } 2007268: b0 10 00 08 mov %o0, %i0 200726c: 81 c7 e0 08 ret 2007270: 81 e8 00 00 restore 020072a8 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 20072a8: 9d e3 bf 98 save %sp, -104, %sp #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 20072ac: 03 00 80 61 sethi %hi(0x2018400), %g1 20072b0: 80 a6 60 00 cmp %i1, 0 20072b4: 02 80 00 03 be 20072c0 20072b8: a0 10 62 2c or %g1, 0x22c, %l0 20072bc: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 20072c0: 80 a6 20 00 cmp %i0, 0 20072c4: 22 80 00 2e be,a 200737c 20072c8: b0 10 20 16 mov 0x16, %i0 return EBUSY; } } #endif if ( !the_attr->is_initialized ) 20072cc: c2 04 00 00 ld [ %l0 ], %g1 20072d0: 80 a0 60 00 cmp %g1, 0 20072d4: 22 80 00 2a be,a 200737c 20072d8: b0 10 20 16 mov 0x16, %i0 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 20072dc: c2 04 20 04 ld [ %l0 + 4 ], %g1 20072e0: 80 a0 60 00 cmp %g1, 0 20072e4: 22 80 00 09 be,a 2007308 20072e8: c2 04 20 0c ld [ %l0 + 0xc ], %g1 20072ec: 11 00 80 61 sethi %hi(0x2018400), %o0 <== NOT EXECUTED 20072f0: 15 00 80 61 sethi %hi(0x2018400), %o2 <== NOT EXECUTED 20072f4: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 20072f8: 94 12 a2 88 or %o2, 0x288, %o2 <== NOT EXECUTED 20072fc: 7f ff f2 cd call 2003e30 <__assert> <== NOT EXECUTED 2007300: 92 10 20 64 mov 0x64, %o1 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 2007304: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 2007308: 80 a0 60 01 cmp %g1, 1 200730c: 02 80 00 08 be 200732c 2007310: 80 a0 60 02 cmp %g1, 2 2007314: 02 80 00 08 be 2007334 2007318: 80 a0 60 00 cmp %g1, 0 200731c: 02 80 00 07 be 2007338 2007320: a2 10 20 00 clr %l1 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return 0; 2007324: 81 c7 e0 08 ret 2007328: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 200732c: 10 80 00 03 b 2007338 2007330: a2 10 20 02 mov 2, %l1 2007334: a2 10 20 03 mov 3, %l1 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 2007338: c2 04 20 08 ld [ %l0 + 8 ], %g1 200733c: 82 00 7f ff add %g1, -1, %g1 2007340: 80 a0 60 fd cmp %g1, 0xfd 2007344: 38 80 00 0e bgu,a 200737c 2007348: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200734c: 03 00 80 69 sethi %hi(0x201a400), %g1 2007350: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 2007354: 84 00 a0 01 inc %g2 2007358: c4 20 61 00 st %g2, [ %g1 + 0x100 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 200735c: 11 00 80 6a sethi %hi(0x201a800), %o0 2007360: 40 00 0d 46 call 200a878 <_Objects_Allocate> 2007364: 90 12 21 64 or %o0, 0x164, %o0 ! 201a964 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 2007368: b2 92 20 00 orcc %o0, 0, %i1 200736c: 32 80 00 06 bne,a 2007384 2007370: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Thread_Enable_dispatch(); 2007374: 7f ff ff c0 call 2007274 <_Thread_Enable_dispatch> 2007378: b0 10 20 0b mov 0xb, %i0 200737c: 81 c7 e0 08 ret 2007380: 81 e8 00 00 restore _Thread_Enable_dispatch(); return EAGAIN; } #endif the_mutex->process_shared = the_attr->process_shared; 2007384: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 2007388: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 200738c: 80 a0 60 00 cmp %g1, 0 2007390: 02 80 00 04 be 20073a0 2007394: 82 10 20 01 mov 1, %g1 the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 2007398: 10 80 00 03 b 20073a4 <== NOT EXECUTED 200739c: c0 26 60 54 clr [ %i1 + 0x54 ] <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; 20073a0: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 20073a4: c4 04 20 08 ld [ %l0 + 8 ], %g2 if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 20073a8: 82 10 20 01 mov 1, %g1 20073ac: c2 26 60 58 st %g1, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 20073b0: 82 10 20 ff mov 0xff, %g1 20073b4: 82 20 40 02 sub %g1, %g2, %g1 _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 20073b8: e2 26 60 5c st %l1, [ %i1 + 0x5c ] if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 20073bc: c2 26 60 60 st %g1, [ %i1 + 0x60 ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 20073c0: 90 06 60 14 add %i1, 0x14, %o0 20073c4: 92 06 60 54 add %i1, 0x54, %o1 20073c8: 40 00 0a 89 call 2009dec <_CORE_mutex_Initialize> 20073cc: 94 10 20 01 mov 1, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20073d0: 03 00 80 6a sethi %hi(0x201a800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20073d4: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20073d8: 88 10 61 64 or %g1, 0x164, %g4 20073dc: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 20073e0: 03 00 00 3f sethi %hi(0xfc00), %g1 20073e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20073e8: 82 08 c0 01 and %g3, %g1, %g1 20073ec: 80 a0 40 02 cmp %g1, %g2 20073f0: 38 80 00 06 bgu,a 2007408 20073f4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20073f8: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 20073fc: 83 28 60 02 sll %g1, 2, %g1 2007400: f2 20 80 01 st %i1, [ %g2 + %g1 ] CORE_MUTEX_UNLOCKED ); _Objects_Open( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 2007404: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2007408: c0 26 60 0c clr [ %i1 + 0xc ] 200740c: c2 26 00 00 st %g1, [ %i0 ] 0, /* Name not used */ 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2007410: 7f ff ff 99 call 2007274 <_Thread_Enable_dispatch> 2007414: b0 10 20 00 clr %i0 2007418: 81 c7 e0 08 ret 200741c: 81 e8 00 00 restore return 0; } 2007420: 81 c7 e0 08 ret <== NOT EXECUTED 2007424: 81 e8 00 00 restore <== NOT EXECUTED 020076e0 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 20076e0: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 20076e4: 80 a6 a0 00 cmp %i2, 0 20076e8: 02 80 00 3f be 20077e4 20076ec: 82 06 7f ff add %i1, -1, %g1 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 20076f0: 80 a0 60 fd cmp %g1, 0xfd 20076f4: 18 80 00 3d bgu 20077e8 20076f8: a0 10 20 16 mov 0x16, %l0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 20076fc: 7f ff ff 4b call 2007428 2007700: 90 10 00 18 mov %i0, %o0 if ( status ) 2007704: a0 92 20 00 orcc %o0, 0, %l0 2007708: 12 80 00 38 bne 20077e8 200770c: 80 a6 20 00 cmp %i0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007710: 02 80 00 0d be 2007744 2007714: 82 10 20 02 mov 2, %g1 2007718: c2 06 00 00 ld [ %i0 ], %g1 200771c: 80 a0 7f ff cmp %g1, -1 2007720: 32 80 00 0c bne,a 2007750 2007724: d2 06 00 00 ld [ %i0 ], %o1 2007728: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200772c: 7f ff fe df call 20072a8 <== NOT EXECUTED 2007730: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007738: 22 80 00 06 be,a 2007750 <== NOT EXECUTED 200773c: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2007740: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007744: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007748: 10 80 00 06 b 2007760 <== NOT EXECUTED 200774c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007750: 11 00 80 6a sethi %hi(0x201a800), %o0 2007754: 94 07 bf f4 add %fp, -12, %o2 2007758: 40 00 0d 8c call 200ad88 <_Objects_Get> 200775c: 90 12 21 64 or %o0, 0x164, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007760: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007764: 80 a0 60 00 cmp %g1, 0 2007768: 22 80 00 07 be,a 2007784 200776c: c6 02 20 60 ld [ %o0 + 0x60 ], %g3 2007770: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007774: 18 80 00 18 bgu 20077d4 <== NOT EXECUTED 2007778: 01 00 00 00 nop <== NOT EXECUTED #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200777c: 10 80 00 1b b 20077e8 <== NOT EXECUTED 2007780: a0 10 20 16 mov 0x16, %l0 ! 16 <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 2007784: d2 02 20 08 ld [ %o0 + 8 ], %o1 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007788: 82 10 20 ff mov 0xff, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 200778c: 84 20 40 19 sub %g1, %i1, %g2 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007790: 82 20 40 03 sub %g1, %g3, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 2007794: c4 22 20 60 st %g2, [ %o0 + 0x60 ] return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007798: c2 26 80 00 st %g1, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 200779c: 94 10 20 00 clr %o2 20077a0: 40 00 09 e3 call 2009f2c <_CORE_mutex_Surrender> 20077a4: 90 02 20 14 add %o0, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20077a8: 05 00 80 69 sethi %hi(0x201a400), %g2 20077ac: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 ! 201a500 <_Thread_Dispatch_disable_level> 20077b0: 82 00 7f ff add %g1, -1, %g1 20077b4: c2 20 a1 00 st %g1, [ %g2 + 0x100 ] 20077b8: c2 00 a1 00 ld [ %g2 + 0x100 ], %g1 20077bc: 80 a0 60 00 cmp %g1, 0 20077c0: 12 80 00 0b bne 20077ec 20077c4: b0 10 00 10 mov %l0, %i0 _Thread_Dispatch(); 20077c8: 40 00 12 36 call 200c0a0 <_Thread_Dispatch> 20077cc: 01 00 00 00 nop 20077d0: 30 80 00 07 b,a 20077ec #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20077d4: 40 00 03 09 call 20083f8 <== NOT EXECUTED 20077d8: 01 00 00 00 nop <== NOT EXECUTED 20077dc: 10 80 00 03 b 20077e8 <== NOT EXECUTED 20077e0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20077e4: a0 10 20 16 mov 0x16, %l0 } 20077e8: b0 10 00 10 mov %l0, %i0 20077ec: 81 c7 e0 08 ret 20077f0: 81 e8 00 00 restore 020077f4 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 20077f4: 9d e3 bf 90 save %sp, -112, %sp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 20077f8: 90 10 00 19 mov %i1, %o0 20077fc: 40 00 00 4b call 2007928 <_POSIX_Absolute_timeout_to_ticks> 2007800: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2007804: 80 a2 20 02 cmp %o0, 2 2007808: 28 80 00 07 bleu,a 2007824 200780c: b2 10 20 00 clr %i1 <== NOT EXECUTED 2007810: 80 a2 20 03 cmp %o0, 3 2007814: 22 80 00 04 be,a 2007824 2007818: b2 10 20 01 mov 1, %i1 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 200781c: 10 80 00 03 b 2007828 <== NOT EXECUTED 2007820: d4 07 bf f4 ld [ %fp + -12 ], %o2 <== NOT EXECUTED 2007824: d4 07 bf f4 ld [ %fp + -12 ], %o2 2007828: 90 10 00 18 mov %i0, %o0 200782c: 7f ff ff 05 call 2007440 <_POSIX_Mutex_Lock_support> 2007830: 92 10 00 19 mov %i1, %o1 break; } } return lock_status; } 2007834: 81 c7 e0 08 ret 2007838: 91 e8 00 08 restore %g0, %o0, %o0 02007854 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 2007854: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007858: 80 a6 20 00 cmp %i0, 0 200785c: 02 80 00 0d be 2007890 2007860: 82 10 20 02 mov 2, %g1 2007864: c2 06 00 00 ld [ %i0 ], %g1 2007868: 80 a0 7f ff cmp %g1, -1 200786c: 32 80 00 0c bne,a 200789c 2007870: d2 06 00 00 ld [ %i0 ], %o1 2007874: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007878: 7f ff fe 8c call 20072a8 <== NOT EXECUTED 200787c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007880: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007884: 22 80 00 06 be,a 200789c <== NOT EXECUTED 2007888: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 200788c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2007890: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007894: 10 80 00 06 b 20078ac <== NOT EXECUTED 2007898: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED return (POSIX_Mutex_Control *) 200789c: 11 00 80 6a sethi %hi(0x201a800), %o0 20078a0: 94 07 bf f4 add %fp, -12, %o2 20078a4: 40 00 0d 39 call 200ad88 <_Objects_Get> 20078a8: 90 12 21 64 or %o0, 0x164, %o0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20078ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20078b0: 80 a0 60 00 cmp %g1, 0 20078b4: 22 80 00 06 be,a 20078cc 20078b8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20078bc: 80 a0 60 02 cmp %g1, 2 20078c0: 08 80 00 17 bleu 200791c 20078c4: 90 10 20 16 mov 0x16, %o0 20078c8: 30 80 00 13 b,a 2007914 <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 20078cc: 94 10 20 00 clr %o2 20078d0: 40 00 09 97 call 2009f2c <_CORE_mutex_Surrender> 20078d4: 90 02 20 14 add %o0, 0x14, %o0 20078d8: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20078dc: 03 00 80 69 sethi %hi(0x201a400), %g1 20078e0: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 20078e4: 84 00 bf ff add %g2, -1, %g2 20078e8: c4 20 61 00 st %g2, [ %g1 + 0x100 ] 20078ec: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 20078f0: 80 a0 60 00 cmp %g1, 0 20078f4: 12 80 00 04 bne 2007904 20078f8: 01 00 00 00 nop _Thread_Dispatch(); 20078fc: 40 00 11 e9 call 200c0a0 <_Thread_Dispatch> 2007900: 01 00 00 00 nop #else NULL #endif ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); 2007904: 40 00 1f a1 call 200f788 <_POSIX_Mutex_From_core_mutex_status> 2007908: 90 10 00 18 mov %i0, %o0 break; } return POSIX_BOTTOM_REACHED(); } 200790c: 81 c7 e0 08 ret 2007910: 91 e8 00 08 restore %g0, %o0, %o0 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 2007914: 40 00 02 b9 call 20083f8 <== NOT EXECUTED 2007918: 01 00 00 00 nop <== NOT EXECUTED } 200791c: b0 10 00 08 mov %o0, %i0 2007920: 81 c7 e0 08 ret 2007924: 81 e8 00 00 restore 02005da4 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 2005da4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 2005da8: 80 a6 20 00 cmp %i0, 0 2005dac: 02 80 00 2d be 2005e60 2005db0: 21 00 80 6e sethi %hi(0x201b800), %l0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 2005db4: d2 06 00 00 ld [ %i0 ], %o1 2005db8: 94 07 bf f4 add %fp, -12, %o2 2005dbc: 40 00 0e f5 call 2009990 <_Objects_Get> 2005dc0: 90 14 20 7c or %l0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2005dc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005dc8: 80 a0 60 00 cmp %g1, 0 2005dcc: 02 80 00 07 be 2005de8 2005dd0: b0 10 00 08 mov %o0, %i0 2005dd4: 80 a0 60 02 cmp %g1, 2 2005dd8: 18 80 00 1e bgu 2005e50 2005ddc: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005de0: 81 c7 e0 08 ret 2005de4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: /* * If there is at least one thread waiting, then do not delete it. */ if ( _Thread_queue_First( &the_rwlock->RWLock.Wait_queue ) != NULL ) { 2005de8: 40 00 16 6d call 200b79c <_Thread_queue_First> 2005dec: 90 02 20 10 add %o0, 0x10, %o0 2005df0: 80 a2 20 00 cmp %o0, 0 2005df4: 22 80 00 06 be,a 2005e0c 2005df8: 90 14 20 7c or %l0, 0x7c, %o0 _Thread_Enable_dispatch(); 2005dfc: 7f ff ff dd call 2005d70 <_Thread_Enable_dispatch> 2005e00: 01 00 00 00 nop 2005e04: 10 80 00 18 b 2005e64 2005e08: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005e0c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e10: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005e14: 05 00 00 3f sethi %hi(0xfc00), %g2 2005e18: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005e1c: 82 08 40 02 and %g1, %g2, %g1 2005e20: 80 a0 40 03 cmp %g1, %g3 2005e24: 18 80 00 05 bgu 2005e38 2005e28: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2005e2c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e30: 83 28 60 02 sll %g1, 2, %g1 2005e34: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 2005e38: 40 00 0e 94 call 2009888 <_Objects_Free> 2005e3c: c0 26 20 0c clr [ %i0 + 0xc ] _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 2005e40: 7f ff ff cc call 2005d70 <_Thread_Enable_dispatch> 2005e44: 01 00 00 00 nop 2005e48: 10 80 00 07 b 2005e64 2005e4c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005e50: 40 00 03 73 call 2006c1c <== NOT EXECUTED 2005e54: 01 00 00 00 nop <== NOT EXECUTED } 2005e58: 81 c7 e0 08 ret <== NOT EXECUTED 2005e5c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005e60: 90 10 20 16 mov 0x16, %o0 } 2005e64: b0 10 00 08 mov %o0, %i0 2005e68: 81 c7 e0 08 ret 2005e6c: 81 e8 00 00 restore 02005ea4 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 2005ea4: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 2005ea8: 80 a6 20 00 cmp %i0, 0 2005eac: 02 80 00 32 be 2005f74 2005eb0: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 2005eb4: 80 a6 60 00 cmp %i1, 0 2005eb8: 32 80 00 06 bne,a 2005ed0 2005ebc: c2 04 00 00 ld [ %l0 ], %g1 the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 2005ec0: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 2005ec4: 40 00 03 2c call 2006b74 <== NOT EXECUTED 2005ec8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2005ecc: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 2005ed0: 80 a0 60 00 cmp %g1, 0 2005ed4: 02 80 00 28 be 2005f74 2005ed8: 01 00 00 00 nop return EINVAL; switch ( the_attr->process_shared ) { 2005edc: c2 04 20 04 ld [ %l0 + 4 ], %g1 2005ee0: 80 a0 60 00 cmp %g1, 0 2005ee4: 12 80 00 24 bne 2005f74 2005ee8: 05 00 80 6d sethi %hi(0x201b400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005eec: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 201b5e0 <_Thread_Dispatch_disable_level> 2005ef0: 82 00 60 01 inc %g1 2005ef4: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] * This function allocates a RWLock control block from * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) 2005ef8: 33 00 80 6e sethi %hi(0x201b800), %i1 2005efc: 40 00 0d 61 call 2009480 <_Objects_Allocate> 2005f00: 90 16 60 7c or %i1, 0x7c, %o0 ! 201b87c <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 2005f04: a0 92 20 00 orcc %o0, 0, %l0 2005f08: 12 80 00 06 bne 2005f20 2005f0c: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 2005f10: 7f ff ff d8 call 2005e70 <_Thread_Enable_dispatch> 2005f14: b0 10 20 0b mov 0xb, %i0 2005f18: 81 c7 e0 08 ret 2005f1c: 81 e8 00 00 restore return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 2005f20: 40 00 0a 94 call 2008970 <_CORE_RWLock_Initialize> 2005f24: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005f28: 90 16 60 7c or %i1, 0x7c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005f2c: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005f30: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005f34: 05 00 00 3f sethi %hi(0xfc00), %g2 2005f38: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005f3c: 82 08 40 02 and %g1, %g2, %g1 2005f40: 80 a0 40 03 cmp %g1, %g3 2005f44: 38 80 00 06 bgu,a 2005f5c 2005f48: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2005f4c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005f50: 83 28 60 02 sll %g1, 2, %g1 2005f54: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 2005f58: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2005f5c: c0 24 20 0c clr [ %l0 + 0xc ] 2005f60: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005f64: 7f ff ff c3 call 2005e70 <_Thread_Enable_dispatch> 2005f68: b0 10 20 00 clr %i0 2005f6c: 81 c7 e0 08 ret 2005f70: 81 e8 00 00 restore return 0; } 2005f74: 81 c7 e0 08 ret 2005f78: 91 e8 20 16 restore %g0, 0x16, %o0 02005f7c : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 2005f7c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2005f80: 80 a6 20 00 cmp %i0, 0 2005f84: 02 80 00 28 be 2006024 2005f88: 11 00 80 6e sethi %hi(0x201b800), %o0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 2005f8c: d2 06 00 00 ld [ %i0 ], %o1 2005f90: 94 07 bf f4 add %fp, -12, %o2 2005f94: 40 00 0e 7f call 2009990 <_Objects_Get> 2005f98: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2005f9c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fa0: 80 a0 60 00 cmp %g1, 0 2005fa4: 22 80 00 07 be,a 2005fc0 2005fa8: d2 06 00 00 ld [ %i0 ], %o1 2005fac: 80 a0 60 02 cmp %g1, 2 2005fb0: 18 80 00 19 bgu 2006014 2005fb4: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2005fb8: 81 c7 e0 08 ret 2005fbc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2005fc0: 90 02 20 10 add %o0, 0x10, %o0 2005fc4: 94 10 20 01 mov 1, %o2 2005fc8: 96 10 20 00 clr %o3 2005fcc: 40 00 0a 74 call 200899c <_CORE_RWLock_Obtain_for_reading> 2005fd0: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005fd4: 03 00 80 6d sethi %hi(0x201b400), %g1 2005fd8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2005fdc: 84 00 bf ff add %g2, -1, %g2 2005fe0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2005fe4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2005fe8: 80 a0 60 00 cmp %g1, 0 2005fec: 12 80 00 05 bne 2006000 2005ff0: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 2005ff4: 40 00 13 2d call 200aca8 <_Thread_Dispatch> 2005ff8: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2005ffc: 03 00 80 6d sethi %hi(0x201b400), %g1 2006000: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006004: 40 00 00 9a call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006008: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 200600c: 81 c7 e0 08 ret 2006010: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006014: 40 00 03 02 call 2006c1c <== NOT EXECUTED 2006018: 01 00 00 00 nop <== NOT EXECUTED } 200601c: 81 c7 e0 08 ret <== NOT EXECUTED 2006020: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006024: 90 10 20 16 mov 0x16, %o0 } 2006028: b0 10 00 08 mov %o0, %i0 200602c: 81 c7 e0 08 ret 2006030: 81 e8 00 00 restore 02006034 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2006034: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; boolean do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 2006038: 80 a6 20 00 cmp %i0, 0 200603c: 02 80 00 41 be 2006140 2006040: 90 10 00 19 mov %i1, %o0 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2006044: 40 00 21 84 call 200e654 <_POSIX_Absolute_timeout_to_ticks> 2006048: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 200604c: 80 a2 20 02 cmp %o0, 2 2006050: 08 80 00 07 bleu 200606c 2006054: b2 10 00 08 mov %o0, %i1 2006058: 80 a2 20 03 cmp %o0, 3 200605c: 22 80 00 05 be,a 2006070 2006060: a0 10 20 01 mov 1, %l0 2006064: 10 80 00 04 b 2006074 <== NOT EXECUTED 2006068: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 200606c: a0 10 20 00 clr %l0 2006070: d2 06 00 00 ld [ %i0 ], %o1 2006074: 11 00 80 6e sethi %hi(0x201b800), %o0 2006078: 94 07 bf f4 add %fp, -12, %o2 200607c: 40 00 0e 45 call 2009990 <_Objects_Get> 2006080: 90 12 20 7c or %o0, 0x7c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006084: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006088: 80 a0 60 00 cmp %g1, 0 200608c: 22 80 00 07 be,a 20060a8 2006090: d2 06 00 00 ld [ %i0 ], %o1 2006094: 80 a0 60 02 cmp %g1, 2 2006098: 18 80 00 26 bgu 2006130 200609c: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20060a0: 81 c7 e0 08 ret 20060a4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 20060a8: d6 07 bf f0 ld [ %fp + -16 ], %o3 20060ac: 90 02 20 10 add %o0, 0x10, %o0 20060b0: 94 10 00 10 mov %l0, %o2 20060b4: 40 00 0a 3a call 200899c <_CORE_RWLock_Obtain_for_reading> 20060b8: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20060bc: 03 00 80 6d sethi %hi(0x201b400), %g1 20060c0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20060c4: 84 00 bf ff add %g2, -1, %g2 20060c8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20060cc: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20060d0: 80 a0 60 00 cmp %g1, 0 20060d4: 12 80 00 05 bne 20060e8 20060d8: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 20060dc: 40 00 12 f3 call 200aca8 <_Thread_Dispatch> 20060e0: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 20060e4: 80 a4 20 00 cmp %l0, 0 20060e8: 12 80 00 0c bne 2006118 20060ec: 03 00 80 6d sethi %hi(0x201b400), %g1 20060f0: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 20060f4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 20060f8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20060fc: 12 80 00 07 bne 2006118 <== NOT EXECUTED 2006100: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006104: 02 80 00 10 be 2006144 <== NOT EXECUTED 2006108: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 200610c: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 2006110: 08 80 00 0d bleu 2006144 <== NOT EXECUTED 2006114: 90 10 20 74 mov 0x74, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006118: 03 00 80 6d sethi %hi(0x201b400), %g1 200611c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006120: 40 00 00 53 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006124: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006128: 81 c7 e0 08 ret 200612c: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006130: 40 00 02 bb call 2006c1c <== NOT EXECUTED 2006134: 01 00 00 00 nop <== NOT EXECUTED } 2006138: 81 c7 e0 08 ret <== NOT EXECUTED 200613c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006140: 90 10 20 16 mov 0x16, %o0 } 2006144: b0 10 00 08 mov %o0, %i0 2006148: 81 c7 e0 08 ret 200614c: 81 e8 00 00 restore 02006150 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2006150: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; Watchdog_Interval ticks; boolean do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 2006154: 80 a6 20 00 cmp %i0, 0 2006158: 02 80 00 41 be 200625c 200615c: 90 10 00 19 mov %i1, %o0 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 2006160: 40 00 21 3d call 200e654 <_POSIX_Absolute_timeout_to_ticks> 2006164: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 2006168: 80 a2 20 02 cmp %o0, 2 200616c: 08 80 00 07 bleu 2006188 2006170: b2 10 00 08 mov %o0, %i1 2006174: 80 a2 20 03 cmp %o0, 3 2006178: 22 80 00 05 be,a 200618c 200617c: a0 10 20 01 mov 1, %l0 2006180: 10 80 00 04 b 2006190 <== NOT EXECUTED 2006184: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 2006188: a0 10 20 00 clr %l0 200618c: d2 06 00 00 ld [ %i0 ], %o1 2006190: 11 00 80 6e sethi %hi(0x201b800), %o0 2006194: 94 07 bf f4 add %fp, -12, %o2 2006198: 40 00 0d fe call 2009990 <_Objects_Get> 200619c: 90 12 20 7c or %o0, 0x7c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20061a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20061a4: 80 a0 60 00 cmp %g1, 0 20061a8: 22 80 00 07 be,a 20061c4 20061ac: d2 06 00 00 ld [ %i0 ], %o1 20061b0: 80 a0 60 02 cmp %g1, 2 20061b4: 18 80 00 26 bgu 200624c 20061b8: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20061bc: 81 c7 e0 08 ret 20061c0: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20061c4: d6 07 bf f0 ld [ %fp + -16 ], %o3 20061c8: 90 02 20 10 add %o0, 0x10, %o0 20061cc: 94 10 00 10 mov %l0, %o2 20061d0: 40 00 0a 27 call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20061d4: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20061d8: 03 00 80 6d sethi %hi(0x201b400), %g1 20061dc: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20061e0: 84 00 bf ff add %g2, -1, %g2 20061e4: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20061e8: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20061ec: 80 a0 60 00 cmp %g1, 0 20061f0: 12 80 00 05 bne 2006204 20061f4: 80 a4 20 00 cmp %l0, 0 _Thread_Dispatch(); 20061f8: 40 00 12 ac call 200aca8 <_Thread_Dispatch> 20061fc: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 2006200: 80 a4 20 00 cmp %l0, 0 2006204: 12 80 00 0c bne 2006234 2006208: 03 00 80 6d sethi %hi(0x201b400), %g1 200620c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> <== NOT EXECUTED 2006210: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 <== NOT EXECUTED 2006214: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006218: 12 80 00 07 bne 2006234 <== NOT EXECUTED 200621c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006220: 02 80 00 10 be 2006260 <== NOT EXECUTED 2006224: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2006228: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED 200622c: 08 80 00 0d bleu 2006260 <== NOT EXECUTED 2006230: 90 10 20 74 mov 0x74, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006234: 03 00 80 6d sethi %hi(0x201b400), %g1 2006238: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 200623c: 40 00 00 0c call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006240: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006244: 81 c7 e0 08 ret 2006248: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 200624c: 40 00 02 74 call 2006c1c <== NOT EXECUTED 2006250: 01 00 00 00 nop <== NOT EXECUTED } 2006254: 81 c7 e0 08 ret <== NOT EXECUTED 2006258: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 200625c: 90 10 20 16 mov 0x16, %o0 } 2006260: b0 10 00 08 mov %o0, %i0 2006264: 81 c7 e0 08 ret 2006268: 81 e8 00 00 restore 02006294 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 2006294: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006298: 80 a6 20 00 cmp %i0, 0 200629c: 02 80 00 28 be 200633c 20062a0: 11 00 80 6e sethi %hi(0x201b800), %o0 20062a4: d2 06 00 00 ld [ %i0 ], %o1 20062a8: 94 07 bf f4 add %fp, -12, %o2 20062ac: 40 00 0d b9 call 2009990 <_Objects_Get> 20062b0: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20062b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062b8: 80 a0 60 00 cmp %g1, 0 20062bc: 22 80 00 07 be,a 20062d8 20062c0: d2 06 00 00 ld [ %i0 ], %o1 20062c4: 80 a0 60 02 cmp %g1, 2 20062c8: 18 80 00 19 bgu 200632c 20062cc: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20062d0: 81 c7 e0 08 ret 20062d4: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 20062d8: 90 02 20 10 add %o0, 0x10, %o0 20062dc: 94 10 20 00 clr %o2 20062e0: 96 10 20 00 clr %o3 20062e4: 40 00 09 ae call 200899c <_CORE_RWLock_Obtain_for_reading> 20062e8: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20062ec: 03 00 80 6d sethi %hi(0x201b400), %g1 20062f0: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20062f4: 84 00 bf ff add %g2, -1, %g2 20062f8: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20062fc: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006300: 80 a0 60 00 cmp %g1, 0 2006304: 12 80 00 05 bne 2006318 2006308: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 200630c: 40 00 12 67 call 200aca8 <_Thread_Dispatch> 2006310: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006314: 03 00 80 6d sethi %hi(0x201b400), %g1 2006318: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 200631c: 7f ff ff d4 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006320: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006324: 81 c7 e0 08 ret 2006328: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 200632c: 40 00 02 3c call 2006c1c <== NOT EXECUTED 2006330: 01 00 00 00 nop <== NOT EXECUTED } 2006334: 81 c7 e0 08 ret <== NOT EXECUTED 2006338: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 200633c: 90 10 20 16 mov 0x16, %o0 } 2006340: b0 10 00 08 mov %o0, %i0 2006344: 81 c7 e0 08 ret 2006348: 81 e8 00 00 restore 0200634c : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 200634c: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006350: 80 a6 20 00 cmp %i0, 0 2006354: 02 80 00 28 be 20063f4 2006358: 11 00 80 6e sethi %hi(0x201b800), %o0 200635c: d2 06 00 00 ld [ %i0 ], %o1 2006360: 94 07 bf f4 add %fp, -12, %o2 2006364: 40 00 0d 8b call 2009990 <_Objects_Get> 2006368: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 200636c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006370: 80 a0 60 00 cmp %g1, 0 2006374: 22 80 00 07 be,a 2006390 2006378: d2 06 00 00 ld [ %i0 ], %o1 200637c: 80 a0 60 02 cmp %g1, 2 2006380: 18 80 00 19 bgu 20063e4 2006384: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006388: 81 c7 e0 08 ret 200638c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2006390: 90 02 20 10 add %o0, 0x10, %o0 2006394: 94 10 20 00 clr %o2 2006398: 96 10 20 00 clr %o3 200639c: 40 00 09 b4 call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20063a0: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20063a4: 03 00 80 6d sethi %hi(0x201b400), %g1 20063a8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 20063ac: 84 00 bf ff add %g2, -1, %g2 20063b0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20063b4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20063b8: 80 a0 60 00 cmp %g1, 0 20063bc: 12 80 00 05 bne 20063d0 20063c0: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 20063c4: 40 00 12 39 call 200aca8 <_Thread_Dispatch> 20063c8: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 20063cc: 03 00 80 6d sethi %hi(0x201b400), %g1 20063d0: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 20063d4: 7f ff ff a6 call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 20063d8: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20063dc: 81 c7 e0 08 ret 20063e0: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 20063e4: 40 00 02 0e call 2006c1c <== NOT EXECUTED 20063e8: 01 00 00 00 nop <== NOT EXECUTED } 20063ec: 81 c7 e0 08 ret <== NOT EXECUTED 20063f0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 20063f4: 90 10 20 16 mov 0x16, %o0 } 20063f8: b0 10 00 08 mov %o0, %i0 20063fc: 81 c7 e0 08 ret 2006400: 81 e8 00 00 restore 02006404 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 2006404: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 2006408: 80 a6 20 00 cmp %i0, 0 200640c: 02 80 00 23 be 2006498 2006410: 11 00 80 6e sethi %hi(0x201b800), %o0 2006414: d2 06 00 00 ld [ %i0 ], %o1 2006418: 94 07 bf f4 add %fp, -12, %o2 200641c: 40 00 0d 5d call 2009990 <_Objects_Get> 2006420: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006424: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006428: 80 a0 60 00 cmp %g1, 0 200642c: 02 80 00 06 be 2006444 2006430: 80 a0 60 02 cmp %g1, 2 2006434: 18 80 00 15 bgu 2006488 2006438: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 200643c: 81 c7 e0 08 ret 2006440: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 2006444: 40 00 09 ac call 2008af4 <_CORE_RWLock_Release> 2006448: 90 02 20 10 add %o0, 0x10, %o0 200644c: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006450: 03 00 80 6d sethi %hi(0x201b400), %g1 2006454: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2006458: 84 00 bf ff add %g2, -1, %g2 200645c: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2006460: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006464: 80 a0 60 00 cmp %g1, 0 2006468: 12 80 00 04 bne 2006478 200646c: 01 00 00 00 nop _Thread_Dispatch(); 2006470: 40 00 12 0e call 200aca8 <_Thread_Dispatch> 2006474: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 2006478: 7f ff ff 7d call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 200647c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2006480: 81 c7 e0 08 ret 2006484: 91 e8 00 08 restore %g0, %o0, %o0 status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 2006488: 40 00 01 e5 call 2006c1c <== NOT EXECUTED 200648c: 01 00 00 00 nop <== NOT EXECUTED } 2006490: 81 c7 e0 08 ret <== NOT EXECUTED 2006494: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 2006498: 90 10 20 16 mov 0x16, %o0 } 200649c: b0 10 00 08 mov %o0, %i0 20064a0: 81 c7 e0 08 ret 20064a4: 81 e8 00 00 restore 020064a8 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 20064a8: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 20064ac: 80 a6 20 00 cmp %i0, 0 20064b0: 02 80 00 28 be 2006550 20064b4: 11 00 80 6e sethi %hi(0x201b800), %o0 20064b8: d2 06 00 00 ld [ %i0 ], %o1 20064bc: 94 07 bf f4 add %fp, -12, %o2 20064c0: 40 00 0d 34 call 2009990 <_Objects_Get> 20064c4: 90 12 20 7c or %o0, 0x7c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20064c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064cc: 80 a0 60 00 cmp %g1, 0 20064d0: 22 80 00 07 be,a 20064ec 20064d4: d2 06 00 00 ld [ %i0 ], %o1 20064d8: 80 a0 60 02 cmp %g1, 2 20064dc: 18 80 00 19 bgu 2006540 20064e0: 90 10 20 16 mov 0x16, %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20064e4: 81 c7 e0 08 ret 20064e8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20064ec: 90 02 20 10 add %o0, 0x10, %o0 20064f0: 94 10 20 01 mov 1, %o2 20064f4: 96 10 20 00 clr %o3 20064f8: 40 00 09 5d call 2008a6c <_CORE_RWLock_Obtain_for_writing> 20064fc: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006500: 03 00 80 6d sethi %hi(0x201b400), %g1 2006504: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 201b5e0 <_Thread_Dispatch_disable_level> 2006508: 84 00 bf ff add %g2, -1, %g2 200650c: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2006510: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 2006514: 80 a0 60 00 cmp %g1, 0 2006518: 12 80 00 05 bne 200652c 200651c: 03 00 80 6d sethi %hi(0x201b400), %g1 _Thread_Dispatch(); 2006520: 40 00 11 e2 call 200aca8 <_Thread_Dispatch> 2006524: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006528: 03 00 80 6d sethi %hi(0x201b400), %g1 200652c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 201b6c0 <_Thread_Executing> 2006530: 7f ff ff 4f call 200626c <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006534: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006538: 81 c7 e0 08 ret 200653c: 91 e8 00 08 restore %g0, %o0, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006540: 40 00 01 b7 call 2006c1c <== NOT EXECUTED 2006544: 01 00 00 00 nop <== NOT EXECUTED } 2006548: 81 c7 e0 08 ret <== NOT EXECUTED 200654c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006550: 90 10 20 16 mov 0x16, %o0 } 2006554: b0 10 00 08 mov %o0, %i0 2006558: 81 c7 e0 08 ret 200655c: 81 e8 00 00 restore 02005758 : int pthread_setcancelstate( int state, int *oldstate ) { 2005758: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 200575c: 03 00 80 5c sethi %hi(0x2017000), %g1 2005760: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 2005764: 88 10 00 18 mov %i0, %g4 * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005768: 80 a0 60 00 cmp %g1, 0 200576c: 12 80 00 28 bne 200580c 2005770: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 2005774: 80 a6 60 00 cmp %i1, 0 2005778: 02 80 00 27 be 2005814 200577c: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 2005780: 38 80 00 23 bgu,a 200580c 2005784: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005788: 07 00 80 5c sethi %hi(0x2017000), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 200578c: 1b 00 80 5c sethi %hi(0x2017000), %o5 2005790: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 2005794: c4 03 63 00 ld [ %o5 + 0x300 ], %g2 2005798: 82 00 60 01 inc %g1 200579c: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 20057a0: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 20057a4: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20057a8: 80 a1 20 00 cmp %g4, 0 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 20057ac: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 20057b0: 12 80 00 0c bne 20057e0 20057b4: c8 20 a0 cc st %g4, [ %g2 + 0xcc ] 20057b8: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 20057bc: 80 a0 60 01 cmp %g1, 1 20057c0: 12 80 00 08 bne 20057e0 20057c4: 01 00 00 00 nop 20057c8: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== NOT EXECUTED 20057cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20057d0: 02 80 00 04 be 20057e0 <== NOT EXECUTED 20057d4: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 20057d8: 7f ff fe 09 call 2004ffc <_POSIX_Threads_cancel_run> <== NOT EXECUTED 20057dc: d0 03 63 00 ld [ %o5 + 0x300 ], %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20057e0: 03 00 80 5c sethi %hi(0x2017000), %g1 20057e4: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 20057e8: b0 10 20 00 clr %i0 20057ec: 84 00 bf ff add %g2, -1, %g2 20057f0: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20057f4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20057f8: 80 a0 60 00 cmp %g1, 0 20057fc: 12 80 00 07 bne 2005818 2005800: 01 00 00 00 nop _Thread_Dispatch(); 2005804: 40 00 0f 97 call 2009660 <_Thread_Dispatch> 2005808: 01 00 00 00 nop 200580c: 81 c7 e0 08 ret 2005810: 81 e8 00 00 restore 2005814: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 2005818: 81 c7 e0 08 ret <== NOT EXECUTED 200581c: 81 e8 00 00 restore <== NOT EXECUTED 02005820 : int pthread_setcanceltype( int type, int *oldtype ) { 2005820: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005824: 03 00 80 5c sethi %hi(0x2017000), %g1 2005828: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 200582c: 88 10 00 18 mov %i0, %g4 * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005830: 80 a0 60 00 cmp %g1, 0 2005834: 12 80 00 28 bne 20058d4 2005838: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 200583c: 80 a6 60 00 cmp %i1, 0 2005840: 02 80 00 27 be 20058dc 2005844: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 2005848: 38 80 00 23 bgu,a 20058d4 200584c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005850: 07 00 80 5c sethi %hi(0x2017000), %g3 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005854: 1b 00 80 5c sethi %hi(0x2017000), %o5 2005858: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 200585c: c4 03 63 00 ld [ %o5 + 0x300 ], %g2 2005860: 82 00 60 01 inc %g1 2005864: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005868: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 200586c: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 2005870: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005874: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005878: 80 a0 60 00 cmp %g1, 0 200587c: 12 80 00 0b bne 20058a8 2005880: c8 20 a0 d0 st %g4, [ %g2 + 0xd0 ] 2005884: 80 a1 20 01 cmp %g4, 1 2005888: 12 80 00 08 bne 20058a8 200588c: 01 00 00 00 nop 2005890: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005894: 80 a0 60 00 cmp %g1, 0 2005898: 02 80 00 04 be 20058a8 200589c: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 20058a0: 7f ff fd d7 call 2004ffc <_POSIX_Threads_cancel_run> <== NOT EXECUTED 20058a4: d0 03 63 00 ld [ %o5 + 0x300 ], %o0 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20058a8: 03 00 80 5c sethi %hi(0x2017000), %g1 20058ac: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 20058b0: b0 10 20 00 clr %i0 20058b4: 84 00 bf ff add %g2, -1, %g2 20058b8: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 20058bc: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 20058c0: 80 a0 60 00 cmp %g1, 0 20058c4: 12 80 00 07 bne 20058e0 20058c8: 01 00 00 00 nop _Thread_Dispatch(); 20058cc: 40 00 0f 65 call 2009660 <_Thread_Dispatch> 20058d0: 01 00 00 00 nop 20058d4: 81 c7 e0 08 ret 20058d8: 81 e8 00 00 restore 20058dc: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } 20058e0: 81 c7 e0 08 ret <== NOT EXECUTED 20058e4: 81 e8 00 00 restore <== NOT EXECUTED 020081d8 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 20081d8: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 20081dc: 80 a6 a0 00 cmp %i2, 0 20081e0: 02 80 00 70 be 20083a0 20081e4: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 20081e8: c2 06 80 00 ld [ %i2 ], %g1 20081ec: 82 00 7f ff add %g1, -1, %g1 20081f0: 80 a0 60 fd cmp %g1, 0xfd 20081f4: 18 80 00 6b bgu 20083a0 20081f8: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 20081fc: 02 80 00 10 be 200823c 2008200: a2 10 20 00 clr %l1 2008204: 14 80 00 08 bg 2008224 2008208: 80 a6 60 02 cmp %i1, 2 200820c: 80 a6 60 00 cmp %i1, 0 2008210: a2 10 20 01 mov 1, %l1 2008214: 02 80 00 1b be 2008280 2008218: a4 10 20 00 clr %l2 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200821c: 81 c7 e0 08 ret 2008220: 91 e8 00 08 restore %g0, %o0, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2008224: 02 80 00 05 be 2008238 2008228: 80 a6 60 03 cmp %i1, 3 200822c: 32 80 00 5d bne,a 20083a0 2008230: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2008234: 30 80 00 04 b,a 2008244 2008238: a2 10 20 02 mov 2, %l1 200823c: 10 80 00 11 b 2008280 2008240: a4 10 20 00 clr %l2 case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < 2008244: 40 00 14 24 call 200d2d4 <_Timespec_To_ticks> 2008248: 90 06 a0 08 add %i2, 8, %o0 200824c: a0 10 00 08 mov %o0, %l0 2008250: 40 00 14 21 call 200d2d4 <_Timespec_To_ticks> 2008254: 90 06 a0 10 add %i2, 0x10, %o0 2008258: 80 a4 00 08 cmp %l0, %o0 200825c: 2a 80 00 51 bcs,a 20083a0 2008260: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 2008264: c2 06 a0 04 ld [ %i2 + 4 ], %g1 2008268: 82 00 7f ff add %g1, -1, %g1 200826c: 80 a0 60 fd cmp %g1, 0xfd 2008270: 18 80 00 4b bgu 200839c 2008274: 03 00 80 20 sethi %hi(0x2008000), %g1 2008278: a2 10 20 03 mov 3, %l1 200827c: a4 10 60 c8 or %g1, 0xc8, %l2 2008280: 92 10 00 18 mov %i0, %o1 2008284: 11 00 80 69 sethi %hi(0x201a400), %o0 2008288: 94 07 bf f4 add %fp, -12, %o2 200828c: 40 00 0a bf call 200ad88 <_Objects_Get> 2008290: 90 12 23 e8 or %o0, 0x3e8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008294: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008298: 80 a0 60 00 cmp %g1, 0 200829c: 02 80 00 06 be 20082b4 20082a0: b0 10 00 08 mov %o0, %i0 20082a4: 80 a0 60 02 cmp %g1, 2 20082a8: 08 80 00 3e bleu 20083a0 20082ac: 90 10 20 03 mov 3, %o0 20082b0: 30 80 00 37 b,a 200838c <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 20082b4: e0 02 21 74 ld [ %o0 + 0x174 ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 20082b8: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 20082bc: 80 a0 60 03 cmp %g1, 3 20082c0: 32 80 00 05 bne,a 20082d4 20082c4: f2 24 20 7c st %i1, [ %l0 + 0x7c ] (void) _Watchdog_Remove( &api->Sporadic_timer ); 20082c8: 40 00 15 54 call 200d818 <_Watchdog_Remove> 20082cc: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 20082d0: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 20082d4: 92 10 00 1a mov %i2, %o1 20082d8: 90 04 20 80 add %l0, 0x80, %o0 20082dc: 40 00 27 4a call 2012004 20082e0: 94 10 20 18 mov 0x18, %o2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20082e4: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; 20082e8: e2 26 20 88 st %l1, [ %i0 + 0x88 ] the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20082ec: 80 a0 60 00 cmp %g1, 0 20082f0: 06 80 00 1a bl 2008358 20082f4: e4 26 20 8c st %l2, [ %i0 + 0x8c ] 20082f8: 80 a0 60 02 cmp %g1, 2 20082fc: 24 80 00 07 ble,a 2008318 2008300: c4 04 20 80 ld [ %l0 + 0x80 ], %g2 2008304: 80 a0 60 03 cmp %g1, 3 2008308: 12 80 00 14 bne 2008358 200830c: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 2008310: 10 80 00 0c b 2008340 2008314: c2 04 20 80 ld [ %l0 + 0x80 ], %g1 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 2008318: 03 00 80 69 sethi %hi(0x201a400), %g1 200831c: c2 00 60 58 ld [ %g1 + 0x58 ], %g1 ! 201a458 <_Thread_Ticks_per_timeslice> the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 2008320: 90 10 00 18 mov %i0, %o0 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 2008324: c2 26 20 84 st %g1, [ %i0 + 0x84 ] 2008328: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 200832c: 94 10 20 01 mov 1, %o2 2008330: 92 22 40 02 sub %o1, %g2, %o1 2008334: 40 00 0e 1e call 200bbac <_Thread_Change_priority> 2008338: d2 26 20 18 st %o1, [ %i0 + 0x18 ] 200833c: 30 80 00 07 b,a 2008358 ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; _Watchdog_Remove( &api->Sporadic_timer ); 2008340: 90 04 20 9c add %l0, 0x9c, %o0 2008344: 40 00 15 35 call 200d818 <_Watchdog_Remove> 2008348: c2 24 20 98 st %g1, [ %l0 + 0x98 ] _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 200834c: 92 10 00 18 mov %i0, %o1 2008350: 7f ff ff 72 call 2008118 <_POSIX_Threads_Sporadic_budget_TSR> 2008354: 90 10 20 00 clr %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008358: 03 00 80 69 sethi %hi(0x201a400), %g1 200835c: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201a500 <_Thread_Dispatch_disable_level> 2008360: 90 10 20 00 clr %o0 2008364: 84 00 bf ff add %g2, -1, %g2 2008368: c4 20 61 00 st %g2, [ %g1 + 0x100 ] 200836c: c2 00 61 00 ld [ %g1 + 0x100 ], %g1 2008370: 80 a0 60 00 cmp %g1, 0 2008374: 32 80 00 0c bne,a 20083a4 2008378: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 200837c: 40 00 0f 49 call 200c0a0 <_Thread_Dispatch> 2008380: 01 00 00 00 nop 2008384: 10 80 00 07 b 20083a0 2008388: 90 10 20 00 clr %o0 ! 0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200838c: 40 00 00 1b call 20083f8 <== NOT EXECUTED 2008390: 01 00 00 00 nop <== NOT EXECUTED } 2008394: 81 c7 e0 08 ret <== NOT EXECUTED 2008398: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200839c: 90 10 20 16 mov 0x16, %o0 } 20083a0: b0 10 00 08 mov %o0, %i0 20083a4: 81 c7 e0 08 ret 20083a8: 81 e8 00 00 restore 0200583c : int pthread_setspecific( pthread_key_t key, const void *value ) { 200583c: 9d e3 bf 90 save %sp, -112, %sp 2005840: 11 00 80 5d sethi %hi(0x2017400), %o0 2005844: 92 10 00 18 mov %i0, %o1 2005848: 90 12 22 f0 or %o0, 0x2f0, %o0 200584c: 40 00 0c 7b call 2008a38 <_Objects_Get> 2005850: 94 07 bf f4 add %fp, -12, %o2 uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 2005854: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005858: 80 a0 60 00 cmp %g1, 0 200585c: 22 80 00 06 be,a 2005874 2005860: 03 00 80 5c sethi %hi(0x2017000), %g1 2005864: 80 a0 60 02 cmp %g1, 2 2005868: 08 80 00 1d bleu 20058dc 200586c: 90 10 20 16 mov 0x16, %o0 2005870: 30 80 00 19 b,a 20058d4 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 2005874: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 2005878: c4 00 60 08 ld [ %g1 + 8 ], %g2 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 200587c: 83 30 a0 16 srl %g2, 0x16, %g1 2005880: 82 08 60 1c and %g1, 0x1c, %g1 2005884: 82 00 40 08 add %g1, %o0, %g1 2005888: c6 00 60 18 ld [ %g1 + 0x18 ], %g3 200588c: 03 00 00 3f sethi %hi(0xfc00), %g1 2005890: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005894: 84 08 80 01 and %g2, %g1, %g2 2005898: 85 28 a0 02 sll %g2, 2, %g2 200589c: f2 20 c0 02 st %i1, [ %g3 + %g2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20058a0: 05 00 80 5c sethi %hi(0x2017000), %g2 20058a4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20171f0 <_Thread_Dispatch_disable_level> 20058a8: 90 10 20 00 clr %o0 20058ac: 82 00 7f ff add %g1, -1, %g1 20058b0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 20058b4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 20058b8: 80 a0 60 00 cmp %g1, 0 20058bc: 12 80 00 08 bne 20058dc 20058c0: 01 00 00 00 nop _Thread_Dispatch(); 20058c4: 40 00 11 23 call 2009d50 <_Thread_Dispatch> 20058c8: 01 00 00 00 nop 20058cc: 10 80 00 04 b 20058dc 20058d0: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20058d4: 40 00 01 f5 call 20060a8 <== NOT EXECUTED 20058d8: 01 00 00 00 nop <== NOT EXECUTED } 20058dc: 81 c7 e0 08 ret 20058e0: 91 e8 00 08 restore %g0, %o0, %o0 020054e8 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 20054e8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 20054ec: 80 a6 20 00 cmp %i0, 0 20054f0: 02 80 00 2c be 20055a0 20054f4: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 20054f8: d2 06 00 00 ld [ %i0 ], %o1 20054fc: 31 00 80 52 sethi %hi(0x2014800), %i0 2005500: 40 00 0b d9 call 2008464 <_Objects_Get> 2005504: 90 16 21 14 or %i0, 0x114, %o0 ! 2014914 <_POSIX_Spinlock_Information> return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005508: c2 07 bf f4 ld [ %fp + -12 ], %g1 200550c: 80 a0 60 00 cmp %g1, 0 2005510: 02 80 00 07 be 200552c 2005514: 88 10 00 08 mov %o0, %g4 2005518: 80 a0 60 02 cmp %g1, 2 200551c: 18 80 00 1d bgu 2005590 2005520: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005524: 81 c7 e0 08 ret 2005528: 91 e8 00 08 restore %g0, %o0, %o0 RTEMS_INLINE_ROUTINE boolean _CORE_spinlock_Is_busy( CORE_spinlock_Control *the_spinlock ) { return (the_spinlock->users != 0); 200552c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { 2005530: 80 a0 60 00 cmp %g1, 0 2005534: 22 80 00 06 be,a 200554c 2005538: 90 16 21 14 or %i0, 0x114, %o0 _Thread_Enable_dispatch(); 200553c: 7f ff ff de call 20054b4 <_Thread_Enable_dispatch> 2005540: 01 00 00 00 nop 2005544: 10 80 00 18 b 20055a4 2005548: 90 10 20 10 mov 0x10, %o0 ! 10 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200554c: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005550: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005554: 05 00 00 3f sethi %hi(0xfc00), %g2 2005558: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200555c: 82 08 40 02 and %g1, %g2, %g1 2005560: 80 a0 40 03 cmp %g1, %g3 2005564: 18 80 00 05 bgu 2005578 2005568: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200556c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005570: 83 28 60 02 sll %g1, 2, %g1 2005574: c0 20 80 01 clr [ %g2 + %g1 ] */ RTEMS_INLINE_ROUTINE void _POSIX_Spinlock_Free ( POSIX_Spinlock_Control *the_spinlock ) { _Objects_Free( &_POSIX_Spinlock_Information, &the_spinlock->Object ); 2005578: 40 00 0b 79 call 200835c <_Objects_Free> 200557c: c0 21 20 0c clr [ %g4 + 0xc ] _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 2005580: 7f ff ff cd call 20054b4 <_Thread_Enable_dispatch> 2005584: 01 00 00 00 nop 2005588: 10 80 00 07 b 20055a4 200558c: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 2005590: 40 00 00 db call 20058fc <== NOT EXECUTED 2005594: 01 00 00 00 nop <== NOT EXECUTED } 2005598: 81 c7 e0 08 ret <== NOT EXECUTED 200559c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20055a0: 90 10 20 16 mov 0x16, %o0 } 20055a4: b0 10 00 08 mov %o0, %i0 20055a8: 81 c7 e0 08 ret 20055ac: 81 e8 00 00 restore 020055e4 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 20055e4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 20055e8: 80 a6 20 00 cmp %i0, 0 20055ec: 02 80 00 26 be 2005684 20055f0: 80 a6 60 00 cmp %i1, 0 return EINVAL; switch ( pshared ) { 20055f4: 12 80 00 24 bne 2005684 20055f8: 05 00 80 51 sethi %hi(0x2014400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20055fc: c2 00 a1 e0 ld [ %g2 + 0x1e0 ], %g1 ! 20145e0 <_Thread_Dispatch_disable_level> 2005600: 82 00 60 01 inc %g1 2005604: c2 20 a1 e0 st %g1, [ %g2 + 0x1e0 ] * This function allocates a spinlock control block from * the inactive chain of free spinlock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Allocate( void ) { return (POSIX_Spinlock_Control *) 2005608: 21 00 80 52 sethi %hi(0x2014800), %l0 200560c: 40 00 0a 52 call 2007f54 <_Objects_Allocate> 2005610: 90 14 21 14 or %l0, 0x114, %o0 ! 2014914 <_POSIX_Spinlock_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 2005614: b2 92 20 00 orcc %o0, 0, %i1 2005618: 12 80 00 06 bne 2005630 200561c: 90 06 60 10 add %i1, 0x10, %o0 _Thread_Enable_dispatch(); 2005620: 7f ff ff e4 call 20055b0 <_Thread_Enable_dispatch> 2005624: b0 10 20 0b mov 0xb, %i0 2005628: 81 c7 e0 08 ret 200562c: 81 e8 00 00 restore return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 2005630: 40 00 08 30 call 20076f0 <_CORE_spinlock_Initialize> 2005634: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005638: 90 14 21 14 or %l0, 0x114, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200563c: c2 06 60 08 ld [ %i1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005640: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005644: 05 00 00 3f sethi %hi(0xfc00), %g2 2005648: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200564c: 82 08 40 02 and %g1, %g2, %g1 2005650: 80 a0 40 03 cmp %g1, %g3 2005654: 38 80 00 06 bgu,a 200566c 2005658: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200565c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005660: 83 28 60 02 sll %g1, 2, %g1 2005664: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 2005668: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200566c: c0 26 60 0c clr [ %i1 + 0xc ] 2005670: c2 26 00 00 st %g1, [ %i0 ] _Thread_Enable_dispatch(); 2005674: 7f ff ff cf call 20055b0 <_Thread_Enable_dispatch> 2005678: b0 10 20 00 clr %i0 200567c: 81 c7 e0 08 ret 2005680: 81 e8 00 00 restore return 0; } 2005684: 81 c7 e0 08 ret 2005688: 91 e8 20 16 restore %g0, 0x16, %o0 0200568c : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 200568c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005690: 80 a6 20 00 cmp %i0, 0 2005694: 02 80 00 25 be 2005728 2005698: 11 00 80 52 sethi %hi(0x2014800), %o0 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 200569c: d2 06 00 00 ld [ %i0 ], %o1 20056a0: 94 07 bf f4 add %fp, -12, %o2 20056a4: 40 00 0b 70 call 2008464 <_Objects_Get> 20056a8: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 20056ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20056b0: 80 a0 60 00 cmp %g1, 0 20056b4: 02 80 00 07 be 20056d0 20056b8: 92 10 20 01 mov 1, %o1 20056bc: 80 a0 60 02 cmp %g1, 2 20056c0: 18 80 00 16 bgu 2005718 20056c4: 90 10 20 16 mov 0x16, %o0 status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 20056c8: 81 c7 e0 08 ret 20056cc: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 20056d0: 94 10 20 00 clr %o2 20056d4: 40 00 08 2c call 2007784 <_CORE_spinlock_Wait> 20056d8: 90 02 20 10 add %o0, 0x10, %o0 20056dc: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20056e0: 03 00 80 51 sethi %hi(0x2014400), %g1 20056e4: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 20056e8: 84 00 bf ff add %g2, -1, %g2 20056ec: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20056f0: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20056f4: 80 a0 60 00 cmp %g1, 0 20056f8: 12 80 00 04 bne 2005708 20056fc: 01 00 00 00 nop _Thread_Dispatch(); 2005700: 40 00 10 1f call 200977c <_Thread_Dispatch> 2005704: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005708: 40 00 00 0c call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 200570c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005710: 81 c7 e0 08 ret 2005714: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 2005718: 40 00 00 79 call 20058fc <== NOT EXECUTED 200571c: 01 00 00 00 nop <== NOT EXECUTED } 2005720: 81 c7 e0 08 ret <== NOT EXECUTED 2005724: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 2005728: 90 10 20 16 mov 0x16, %o0 } 200572c: b0 10 00 08 mov %o0, %i0 2005730: 81 c7 e0 08 ret 2005734: 81 e8 00 00 restore 02005760 : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 2005760: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005764: 80 a6 20 00 cmp %i0, 0 2005768: 02 80 00 25 be 20057fc 200576c: 11 00 80 52 sethi %hi(0x2014800), %o0 2005770: d2 06 00 00 ld [ %i0 ], %o1 2005774: 94 07 bf f4 add %fp, -12, %o2 2005778: 40 00 0b 3b call 2008464 <_Objects_Get> 200577c: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005780: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005784: 80 a0 60 00 cmp %g1, 0 2005788: 02 80 00 07 be 20057a4 200578c: 92 10 20 00 clr %o1 2005790: 80 a0 60 02 cmp %g1, 2 2005794: 18 80 00 16 bgu 20057ec 2005798: 90 10 20 16 mov 0x16, %o0 status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 200579c: 81 c7 e0 08 ret 20057a0: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 20057a4: 94 10 20 00 clr %o2 20057a8: 40 00 07 f7 call 2007784 <_CORE_spinlock_Wait> 20057ac: 90 02 20 10 add %o0, 0x10, %o0 20057b0: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20057b4: 03 00 80 51 sethi %hi(0x2014400), %g1 20057b8: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 20057bc: 84 00 bf ff add %g2, -1, %g2 20057c0: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 20057c4: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 20057c8: 80 a0 60 00 cmp %g1, 0 20057cc: 12 80 00 04 bne 20057dc 20057d0: 01 00 00 00 nop _Thread_Dispatch(); 20057d4: 40 00 0f ea call 200977c <_Thread_Dispatch> 20057d8: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 20057dc: 7f ff ff d7 call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 20057e0: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 20057e4: 81 c7 e0 08 ret 20057e8: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 20057ec: 40 00 00 44 call 20058fc <== NOT EXECUTED 20057f0: 01 00 00 00 nop <== NOT EXECUTED } 20057f4: 81 c7 e0 08 ret <== NOT EXECUTED 20057f8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 20057fc: 90 10 20 16 mov 0x16, %o0 } 2005800: b0 10 00 08 mov %o0, %i0 2005804: 81 c7 e0 08 ret 2005808: 81 e8 00 00 restore 0200580c : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 200580c: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005810: 80 a6 20 00 cmp %i0, 0 2005814: 02 80 00 23 be 20058a0 2005818: 11 00 80 52 sethi %hi(0x2014800), %o0 200581c: d2 06 00 00 ld [ %i0 ], %o1 2005820: 94 07 bf f4 add %fp, -12, %o2 2005824: 40 00 0b 10 call 2008464 <_Objects_Get> 2005828: 90 12 21 14 or %o0, 0x114, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 200582c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005830: 80 a0 60 00 cmp %g1, 0 2005834: 02 80 00 06 be 200584c 2005838: 80 a0 60 02 cmp %g1, 2 200583c: 18 80 00 15 bgu 2005890 2005840: 90 10 20 16 mov 0x16, %o0 status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); } 2005844: 81 c7 e0 08 ret 2005848: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 200584c: 40 00 07 b0 call 200770c <_CORE_spinlock_Release> 2005850: 90 02 20 10 add %o0, 0x10, %o0 2005854: b0 10 00 08 mov %o0, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005858: 03 00 80 51 sethi %hi(0x2014400), %g1 200585c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20145e0 <_Thread_Dispatch_disable_level> 2005860: 84 00 bf ff add %g2, -1, %g2 2005864: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2005868: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 200586c: 80 a0 60 00 cmp %g1, 0 2005870: 12 80 00 04 bne 2005880 2005874: 01 00 00 00 nop _Thread_Dispatch(); 2005878: 40 00 0f c1 call 200977c <_Thread_Dispatch> 200587c: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005880: 7f ff ff ae call 2005738 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 2005884: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005888: 81 c7 e0 08 ret 200588c: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 2005890: 40 00 00 1b call 20058fc <== NOT EXECUTED 2005894: 01 00 00 00 nop <== NOT EXECUTED } 2005898: 81 c7 e0 08 ret <== NOT EXECUTED 200589c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 20058a0: 90 10 20 16 mov 0x16, %o0 } 20058a4: b0 10 00 08 mov %o0, %i0 20058a8: 81 c7 e0 08 ret 20058ac: 81 e8 00 00 restore 0200590c : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 200590c: 9d e3 bf 98 save %sp, -104, %sp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 2005910: 03 00 80 5c sethi %hi(0x2017000), %g1 2005914: c2 00 62 e8 ld [ %g1 + 0x2e8 ], %g1 ! 20172e8 <_ISR_Nest_level> 2005918: 80 a0 60 00 cmp %g1, 0 200591c: 12 80 00 1c bne 200598c 2005920: 07 00 80 5c sethi %hi(0x2017000), %g3 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005924: 09 00 80 5c sethi %hi(0x2017000), %g4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005928: c2 00 e2 20 ld [ %g3 + 0x220 ], %g1 200592c: c4 01 23 00 ld [ %g4 + 0x300 ], %g2 2005930: 82 00 60 01 inc %g1 2005934: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005938: c2 20 e2 20 st %g1, [ %g3 + 0x220 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 200593c: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005940: 80 a0 60 00 cmp %g1, 0 2005944: 12 80 00 08 bne 2005964 2005948: 01 00 00 00 nop 200594c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005950: 80 a0 60 00 cmp %g1, 0 2005954: 02 80 00 04 be 2005964 2005958: 01 00 00 00 nop thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 200595c: 7f ff fd a8 call 2004ffc <_POSIX_Threads_cancel_run> 2005960: d0 01 23 00 ld [ %g4 + 0x300 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005964: 03 00 80 5c sethi %hi(0x2017000), %g1 2005968: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2017220 <_Thread_Dispatch_disable_level> 200596c: 84 00 bf ff add %g2, -1, %g2 2005970: c4 20 62 20 st %g2, [ %g1 + 0x220 ] 2005974: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 2005978: 80 a0 60 00 cmp %g1, 0 200597c: 12 80 00 04 bne 200598c 2005980: 01 00 00 00 nop _Thread_Dispatch(); 2005984: 40 00 0f 37 call 2009660 <_Thread_Dispatch> 2005988: 81 e8 00 00 restore 200598c: 81 c7 e0 08 ret <== NOT EXECUTED 2005990: 81 e8 00 00 restore <== NOT EXECUTED 02016224 : ssize_t read( int fd, void *buffer, size_t count ) { 2016224: 9d e3 bf 98 save %sp, -104, %sp ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2016228: 03 00 80 5d sethi %hi(0x2017400), %g1 201622c: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 201779c ssize_t read( int fd, void *buffer, size_t count ) { 2016230: 92 10 00 19 mov %i1, %o1 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2016234: 80 a6 00 01 cmp %i0, %g1 2016238: 1a 80 00 0e bcc 2016270 201623c: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 2016240: 03 00 80 62 sethi %hi(0x2018800), %g1 2016244: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 2016248: 85 2e 20 02 sll %i0, 2, %g2 201624c: 83 2e 20 04 sll %i0, 4, %g1 2016250: 82 20 40 02 sub %g1, %g2, %g1 2016254: 82 00 40 18 add %g1, %i0, %g1 2016258: 83 28 60 02 sll %g1, 2, %g1 201625c: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 2016260: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2016264: 80 88 61 00 btst 0x100, %g1 2016268: 12 80 00 06 bne 2016280 201626c: 80 a6 60 00 cmp %i1, 0 2016270: 7f ff e0 5c call 200e3e0 <__errno> <== NOT EXECUTED 2016274: 01 00 00 00 nop <== NOT EXECUTED 2016278: 10 80 00 14 b 20162c8 <== NOT EXECUTED 201627c: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 2016280: 02 80 00 07 be 201629c 2016284: 80 a6 a0 00 cmp %i2, 0 rtems_libio_check_count( count ); 2016288: 02 80 00 1b be 20162f4 201628c: 90 10 20 00 clr %o0 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 2016290: 80 88 60 02 btst 2, %g1 2016294: 32 80 00 06 bne,a 20162ac 2016298: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 201629c: 7f ff e0 51 call 200e3e0 <__errno> <== NOT EXECUTED 20162a0: 01 00 00 00 nop <== NOT EXECUTED 20162a4: 10 80 00 09 b 20162c8 <== NOT EXECUTED 20162a8: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 20162ac: c2 00 60 08 ld [ %g1 + 8 ], %g1 20162b0: 80 a0 60 00 cmp %g1, 0 20162b4: 12 80 00 08 bne 20162d4 20162b8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 20162bc: 7f ff e0 49 call 200e3e0 <__errno> <== NOT EXECUTED 20162c0: 01 00 00 00 nop <== NOT EXECUTED 20162c4: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 20162c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20162cc: 10 80 00 0a b 20162f4 <== NOT EXECUTED 20162d0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rc = (*iop->handlers->read_h)( iop, buffer, count ); 20162d4: 9f c0 40 00 call %g1 20162d8: 90 10 00 18 mov %i0, %o0 if ( rc > 0 ) 20162dc: 80 a2 20 00 cmp %o0, 0 20162e0: 04 80 00 05 ble 20162f4 20162e4: 01 00 00 00 nop iop->offset += rc; 20162e8: c2 06 20 08 ld [ %i0 + 8 ], %g1 20162ec: 82 00 40 08 add %g1, %o0, %g1 20162f0: c2 26 20 08 st %g1, [ %i0 + 8 ] return rc; } 20162f4: 81 c7 e0 08 ret 20162f8: 91 e8 00 08 restore %g0, %o0, %o0 0201689c : /* * get next entry in a directory. */ struct dirent * readdir(dirp) register DIR *dirp; { 201689c: 9d e3 bf 98 save %sp, -104, %sp register struct dirent *dp; if ( !dirp ) 20168a0: a0 96 20 00 orcc %i0, 0, %l0 20168a4: 02 80 00 2a be 201694c 20168a8: b0 10 20 00 clr %i0 return NULL; for (;;) { if (dirp->dd_loc == 0) { 20168ac: c2 04 20 04 ld [ %l0 + 4 ], %g1 20168b0: 80 a0 60 00 cmp %g1, 0 20168b4: 32 80 00 0a bne,a 20168dc 20168b8: c6 04 20 04 ld [ %l0 + 4 ], %g3 dirp->dd_size = getdents (dirp->dd_fd, 20168bc: d0 04 00 00 ld [ %l0 ], %o0 20168c0: d2 04 20 0c ld [ %l0 + 0xc ], %o1 20168c4: 40 00 24 4d call 201f9f8 20168c8: d4 04 20 10 ld [ %l0 + 0x10 ], %o2 dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 20168cc: 80 a2 20 00 cmp %o0, 0 20168d0: 04 80 00 1e ble 2016948 20168d4: d0 24 20 08 st %o0, [ %l0 + 8 ] return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 20168d8: c6 04 20 04 ld [ %l0 + 4 ], %g3 20168dc: c2 04 20 08 ld [ %l0 + 8 ], %g1 20168e0: 80 a0 c0 01 cmp %g3, %g1 20168e4: 26 80 00 04 bl,a 20168f4 20168e8: da 04 20 0c ld [ %l0 + 0xc ], %o5 dirp->dd_loc = 0; 20168ec: 10 bf ff f0 b 20168ac 20168f0: c0 24 20 04 clr [ %l0 + 4 ] continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 20168f4: b0 00 c0 0d add %g3, %o5, %i0 if ((intptr_t)dp & 03) /* bogus pointer check */ 20168f8: 80 8e 20 03 btst 3, %i0 20168fc: 32 80 00 14 bne,a 201694c 2016900: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 2016904: c4 16 20 08 lduh [ %i0 + 8 ], %g2 2016908: 80 a0 a0 00 cmp %g2, 0 201690c: 02 80 00 0f be 2016948 2016910: 88 00 80 03 add %g2, %g3, %g4 2016914: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2016918: 82 00 60 01 inc %g1 201691c: 82 20 40 03 sub %g1, %g3, %g1 2016920: 80 a0 80 01 cmp %g2, %g1 2016924: 34 80 00 0a bg,a 201694c 2016928: b0 10 20 00 clr %i0 <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 201692c: c8 24 20 04 st %g4, [ %l0 + 4 ] if (dp->d_ino == 0) 2016930: c2 00 c0 0d ld [ %g3 + %o5 ], %g1 2016934: 80 a0 60 00 cmp %g1, 0 2016938: 12 80 00 05 bne 201694c 201693c: 01 00 00 00 nop if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { 2016940: 10 bf ff dc b 20168b0 <== NOT EXECUTED 2016944: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; if (dp->d_ino == 0) 2016948: b0 10 20 00 clr %i0 continue; return (dp); } } 201694c: 81 c7 e0 08 ret 2016950: 81 e8 00 00 restore 020059f4 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 20059f4: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t loc; int result; if (!buf) 20059f8: 80 a6 60 00 cmp %i1, 0 20059fc: 12 80 00 06 bne 2005a14 2005a00: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EFAULT ); 2005a04: 40 00 32 e6 call 201259c <__errno> <== NOT EXECUTED 2005a08: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005a0c: 10 80 00 30 b 2005acc <== NOT EXECUTED 2005a10: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, FALSE ); 2005a14: a0 07 bf e8 add %fp, -24, %l0 2005a18: 92 10 20 00 clr %o1 2005a1c: 94 10 00 10 mov %l0, %o2 2005a20: 96 10 20 00 clr %o3 2005a24: 7f ff fa 29 call 20042c8 2005a28: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 2005a2c: 80 a2 20 00 cmp %o0, 0 2005a30: 12 80 00 28 bne 2005ad0 2005a34: c4 07 bf f0 ld [ %fp + -16 ], %g2 return -1; if ( !loc.ops->node_type_h ){ 2005a38: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2005a3c: 80 a0 60 00 cmp %g1, 0 2005a40: 12 80 00 04 bne 2005a50 2005a44: 01 00 00 00 nop rtems_filesystem_freenode( &loc ); 2005a48: 10 80 00 19 b 2005aac <== NOT EXECUTED 2005a4c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 2005a50: 9f c0 40 00 call %g1 2005a54: 90 10 00 10 mov %l0, %o0 2005a58: 80 a2 20 04 cmp %o0, 4 2005a5c: 02 80 00 0f be 2005a98 2005a60: c2 07 bf f0 ld [ %fp + -16 ], %g1 rtems_filesystem_freenode( &loc ); 2005a64: 80 a0 60 00 cmp %g1, 0 2005a68: 02 80 00 08 be 2005a88 2005a6c: 01 00 00 00 nop 2005a70: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2005a74: 80 a0 60 00 cmp %g1, 0 2005a78: 02 80 00 04 be 2005a88 2005a7c: 01 00 00 00 nop 2005a80: 9f c0 40 00 call %g1 2005a84: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 2005a88: 40 00 32 c5 call 201259c <__errno> 2005a8c: b0 10 3f ff mov -1, %i0 2005a90: 10 80 00 0f b 2005acc 2005a94: 82 10 20 16 mov 0x16, %g1 } if ( !loc.ops->readlink_h ){ 2005a98: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 2005a9c: 80 a0 a0 00 cmp %g2, 0 2005aa0: 12 80 00 0e bne 2005ad8 2005aa4: 92 10 00 19 mov %i1, %o1 rtems_filesystem_freenode( &loc ); 2005aa8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2005aac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005ab0: 02 80 00 04 be 2005ac0 <== NOT EXECUTED 2005ab4: 01 00 00 00 nop <== NOT EXECUTED 2005ab8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005abc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2005ac0: 40 00 32 b7 call 201259c <__errno> <== NOT EXECUTED 2005ac4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005ac8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2005acc: c2 22 00 00 st %g1, [ %o0 ] 2005ad0: 81 c7 e0 08 ret 2005ad4: 81 e8 00 00 restore } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 2005ad8: 94 10 00 1a mov %i2, %o2 2005adc: 9f c0 80 00 call %g2 2005ae0: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2005ae4: c2 07 bf f0 ld [ %fp + -16 ], %g1 2005ae8: 80 a0 60 00 cmp %g1, 0 2005aec: 02 bf ff f9 be 2005ad0 2005af0: b0 10 00 08 mov %o0, %i0 2005af4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2005af8: 80 a0 60 00 cmp %g1, 0 2005afc: 02 80 00 04 be 2005b0c 2005b00: 01 00 00 00 nop 2005b04: 9f c0 40 00 call %g1 2005b08: 90 10 00 10 mov %l0, %o0 return result; } 2005b0c: 81 c7 e0 08 ret 2005b10: 81 e8 00 00 restore 020023c8 : void *realloc( void *ptr, size_t size ) { 20023c8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 20023cc: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 20023d0: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> <== NOT EXECUTED 20023d4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 20023d8: 12 80 00 0c bne 2002408 <== NOT EXECUTED 20023dc: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED if (_Thread_Dispatch_disable_level > 0) 20023e0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20023e4: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20023e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20023ec: 32 80 00 12 bne,a 2002434 <== NOT EXECUTED 20023f0: b0 10 20 00 clr %i0 <== NOT EXECUTED return (void *) 0; if (_ISR_Nest_level > 0) 20023f4: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 20023f8: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 2018bb8 <_ISR_Nest_level> <== NOT EXECUTED 20023fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2002400: 12 80 00 34 bne 20024d0 <== NOT EXECUTED 2002404: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 2002408: 12 80 00 06 bne 2002420 <== NOT EXECUTED 200240c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED return malloc( size ); 2002410: 7f ff ff a3 call 200229c <== NOT EXECUTED 2002414: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2002418: 81 c7 e0 08 ret <== NOT EXECUTED 200241c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if ( !size ) { 2002420: 12 80 00 07 bne 200243c <== NOT EXECUTED 2002424: 23 00 80 62 sethi %hi(0x2018800), %l1 <== NOT EXECUTED free( ptr ); 2002428: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200242c: 7f ff ff 74 call 20021fc <== NOT EXECUTED 2002430: b0 10 20 00 clr %i0 <== NOT EXECUTED 2002434: 81 c7 e0 08 ret <== NOT EXECUTED 2002438: 81 e8 00 00 restore <== NOT EXECUTED memcpy(np,ptr,size); free(ptr); return np; } #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, size ) ) { 200243c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002440: 90 14 61 2c or %l1, 0x12c, %o0 <== NOT EXECUTED 2002444: 40 00 18 20 call 20084c4 <_Protected_heap_Resize_block> <== NOT EXECUTED 2002448: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 200244c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002450: 12 80 00 21 bne 20024d4 <== NOT EXECUTED 2002454: 01 00 00 00 nop <== NOT EXECUTED return ptr; } new_area = malloc( size ); 2002458: 7f ff ff 91 call 200229c <== NOT EXECUTED 200245c: 90 10 00 19 mov %i1, %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. */ if ( !new_area ) { 2002460: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED 2002464: 02 80 00 1b be 20024d0 <== NOT EXECUTED 2002468: 90 14 61 2c or %l1, 0x12c, %o0 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 200246c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002470: 40 00 17 83 call 200827c <_Protected_heap_Get_block_size> <== NOT EXECUTED 2002474: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2002478: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200247c: 12 80 00 08 bne 200249c <== NOT EXECUTED 2002480: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED errno = EINVAL; 2002484: 40 00 2f d7 call 200e3e0 <__errno> <== NOT EXECUTED 2002488: b0 10 20 00 clr %i0 <== NOT EXECUTED 200248c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2002490: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2002494: 81 c7 e0 08 ret <== NOT EXECUTED 2002498: 81 e8 00 00 restore <== NOT EXECUTED return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 200249c: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 20024a0: 08 80 00 03 bleu 20024ac <== NOT EXECUTED 20024a4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 20024a8: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 20024ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20024b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20024b4: 40 00 31 a0 call 200eb34 <== NOT EXECUTED 20024b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED free( ptr ); 20024bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20024c0: 7f ff ff 4f call 20021fc <== NOT EXECUTED 20024c4: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED 20024c8: 81 c7 e0 08 ret <== NOT EXECUTED 20024cc: 81 e8 00 00 restore <== NOT EXECUTED return new_area; 20024d0: b0 10 20 00 clr %i0 <== NOT EXECUTED } 20024d4: 81 c7 e0 08 ret <== NOT EXECUTED 20024d8: 81 e8 00 00 restore <== NOT EXECUTED 02016954 : #include int rmdir( const char *pathname ) { 2016954: 9d e3 bf 88 save %sp, -120, %sp /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( pathname, 0, &loc, FALSE ); 2016958: 92 10 20 00 clr %o1 201695c: 90 10 00 18 mov %i0, %o0 2016960: a0 07 bf e8 add %fp, -24, %l0 2016964: 96 10 20 00 clr %o3 2016968: 7f ff b4 cb call 2003c94 201696c: 94 10 00 10 mov %l0, %o2 if ( result != 0 ) 2016970: 80 a2 20 00 cmp %o0, 0 2016974: 32 80 00 11 bne,a 20169b8 2016978: b0 10 3f ff mov -1, %i0 return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 201697c: 90 10 20 02 mov 2, %o0 2016980: 7f ff b4 98 call 2003be0 2016984: 92 10 00 10 mov %l0, %o1 if (result != 0) { 2016988: 80 a2 20 00 cmp %o0, 0 201698c: 02 80 00 0d be 20169c0 2016990: c2 07 bf f0 ld [ %fp + -16 ], %g1 rtems_filesystem_freenode( &loc ); 2016994: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016998: 02 80 00 08 be 20169b8 <== NOT EXECUTED 201699c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20169a0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20169a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20169a8: 02 80 00 04 be 20169b8 <== NOT EXECUTED 20169ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20169b0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20169b4: 01 00 00 00 nop <== NOT EXECUTED 20169b8: 81 c7 e0 08 ret 20169bc: 81 e8 00 00 restore /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 20169c0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 20169c4: 80 a0 a0 00 cmp %g2, 0 20169c8: 22 80 00 1e be,a 2016a40 20169cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 20169d0: 9f c0 80 00 call %g2 20169d4: 90 10 00 10 mov %l0, %o0 20169d8: 80 a2 20 01 cmp %o0, 1 20169dc: 02 80 00 10 be 2016a1c 20169e0: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_filesystem_freenode( &loc ); 20169e4: c2 07 bf f0 ld [ %fp + -16 ], %g1 20169e8: 80 a0 60 00 cmp %g1, 0 20169ec: 02 80 00 08 be 2016a0c 20169f0: 01 00 00 00 nop 20169f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20169f8: 80 a0 60 00 cmp %g1, 0 20169fc: 02 80 00 04 be 2016a0c 2016a00: 01 00 00 00 nop 2016a04: 9f c0 40 00 call %g1 2016a08: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 2016a0c: 40 00 2c dc call 2021d7c <__errno> 2016a10: b0 10 3f ff mov -1, %i0 2016a14: 10 80 00 13 b 2016a60 2016a18: 82 10 20 14 mov 0x14, %g1 /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 2016a1c: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 2016a20: 80 a0 60 00 cmp %g1, 0 2016a24: 12 80 00 12 bne 2016a6c 2016a28: 01 00 00 00 nop rtems_filesystem_freenode( &loc ); 2016a2c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2016a30: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016a34: 02 80 00 08 be 2016a54 <== NOT EXECUTED 2016a38: 01 00 00 00 nop <== NOT EXECUTED 2016a3c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2016a40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016a44: 02 80 00 04 be 2016a54 <== NOT EXECUTED 2016a48: 01 00 00 00 nop <== NOT EXECUTED 2016a4c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2016a50: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2016a54: 40 00 2c ca call 2021d7c <__errno> <== NOT EXECUTED 2016a58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2016a5c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2016a60: c2 22 00 00 st %g1, [ %o0 ] 2016a64: 81 c7 e0 08 ret 2016a68: 81 e8 00 00 restore } result = (*loc.handlers->rmnod_h)( &loc ); 2016a6c: 9f c0 40 00 call %g1 2016a70: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2016a74: c2 07 bf f0 ld [ %fp + -16 ], %g1 2016a78: 80 a0 60 00 cmp %g1, 0 2016a7c: 02 bf ff cf be 20169b8 2016a80: b0 10 00 08 mov %o0, %i0 2016a84: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2016a88: 80 a0 60 00 cmp %g1, 0 2016a8c: 02 80 00 06 be 2016aa4 2016a90: 01 00 00 00 nop 2016a94: 9f c0 40 00 call %g1 2016a98: 90 10 00 10 mov %l0, %o0 2016a9c: 81 c7 e0 08 ret 2016aa0: 81 e8 00 00 restore return result; } 2016aa4: 81 c7 e0 08 ret <== NOT EXECUTED 2016aa8: 81 e8 00 00 restore <== NOT EXECUTED 0201607c : sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value); #else static char bad_buffer[32] = ""; #endif return bad_buffer; } 201607c: 11 00 80 9a sethi %hi(0x2026800), %o0 <== NOT EXECUTED 2016080: 81 c3 e0 08 retl <== NOT EXECUTED 2016084: 90 12 21 18 or %o0, 0x118, %o0 ! 2026918 <== NOT EXECUTED 02011b84 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 2011b84: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 2011b88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2011b8c: 40 00 00 09 call 2011bb0 <== NOT EXECUTED 2011b90: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (nap) 2011b94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2011b98: 32 80 00 04 bne,a 2011ba8 <== NOT EXECUTED 2011b9c: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED return nap->name; return rtems_assoc_name_bad(local_value); 2011ba0: 40 00 11 37 call 201607c <== NOT EXECUTED 2011ba4: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED } 2011ba8: 81 c7 e0 08 ret <== NOT EXECUTED 2011bac: 81 e8 00 00 restore <== NOT EXECUTED 0200e320 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 200e320: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 200e324: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED 200e328: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200e32c: 02 80 00 0e be 200e364 <== NOT EXECUTED 200e330: 84 10 20 00 clr %g2 <== NOT EXECUTED 200e334: 13 00 80 5b sethi %hi(0x2016c00), %o1 <== NOT EXECUTED 200e338: 40 00 04 b8 call 200f618 <== NOT EXECUTED 200e33c: 92 12 63 a0 or %o1, 0x3a0, %o1 ! 2016fa0 <_POSIX_Threads_Default_attributes+0x120> <== NOT EXECUTED 200e340: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200e344: 02 80 00 07 be 200e360 <== NOT EXECUTED 200e348: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED default_ap = ap++; 200e34c: 10 80 00 06 b 200e364 <== NOT EXECUTED 200e350: 84 10 20 00 clr %g2 <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->local_value == local_value) 200e354: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 200e358: 02 80 00 08 be 200e378 <== NOT EXECUTED 200e35c: 01 00 00 00 nop <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200e360: b0 06 20 0c add %i0, 0xc, %i0 <== NOT EXECUTED 200e364: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 200e368: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e36c: 32 bf ff fa bne,a 200e354 <== NOT EXECUTED 200e370: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 200e374: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 200e378: 81 c7 e0 08 ret <== NOT EXECUTED 200e37c: 81 e8 00 00 restore <== NOT EXECUTED 0200da3c : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 200da3c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 200da40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200da44: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200da48: 40 00 02 36 call 200e320 <== NOT EXECUTED 200da4c: b0 10 20 00 clr %i0 <== NOT EXECUTED if (nap) 200da50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200da54: 32 80 00 02 bne,a 200da5c <== NOT EXECUTED 200da58: f0 02 20 08 ld [ %o0 + 8 ], %i0 <== NOT EXECUTED return nap->remote_value; return 0; } 200da5c: 81 c7 e0 08 ret <== NOT EXECUTED 200da60: 81 e8 00 00 restore <== NOT EXECUTED 02005d58 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 2005d58: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 2005d5c: a2 96 20 00 orcc %i0, 0, %l1 2005d60: 02 80 00 1b be 2005dcc 2005d64: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005d68: 80 a6 e0 00 cmp %i3, 0 2005d6c: 02 80 00 18 be 2005dcc 2005d70: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 2005d74: 80 8e 60 10 btst 0x10, %i1 2005d78: 02 80 00 06 be 2005d90 2005d7c: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 2005d80: 02 80 00 13 be 2005dcc 2005d84: b0 10 20 0a mov 0xa, %i0 if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2005d88: 10 80 00 04 b 2005d98 2005d8c: c0 27 bf f0 clr [ %fp + -16 ] if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 2005d90: 82 10 20 01 mov 1, %g1 2005d94: c2 27 bf f0 st %g1, [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005d98: 05 00 80 74 sethi %hi(0x201d000), %g2 2005d9c: c2 00 a1 10 ld [ %g2 + 0x110 ], %g1 ! 201d110 <_Thread_Dispatch_disable_level> the_attributes.maximum_count = maximum_waiters; 2005da0: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005da4: 82 00 60 01 inc %g1 2005da8: c2 20 a1 10 st %g1, [ %g2 + 0x110 ] * 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 ); 2005dac: 21 00 80 73 sethi %hi(0x201cc00), %l0 2005db0: 40 00 09 fb call 200859c <_Objects_Allocate> 2005db4: 90 14 23 70 or %l0, 0x370, %o0 ! 201cf70 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 2005db8: b4 92 20 00 orcc %o0, 0, %i2 2005dbc: 12 80 00 06 bne 2005dd4 2005dc0: 90 06 a0 14 add %i2, 0x14, %o0 _Thread_Enable_dispatch(); 2005dc4: 7f ff ff d8 call 2005d24 <_Thread_Enable_dispatch> 2005dc8: b0 10 20 05 mov 5, %i0 2005dcc: 81 c7 e0 08 ret 2005dd0: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 2005dd4: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005dd8: 40 00 07 3d call 2007acc <_CORE_barrier_Initialize> 2005ddc: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005de0: 90 14 23 70 or %l0, 0x370, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 2005de4: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005de8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005dec: 03 00 00 3f sethi %hi(0xfc00), %g1 2005df0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005df4: 82 08 c0 01 and %g3, %g1, %g1 2005df8: 80 a0 40 02 cmp %g1, %g2 2005dfc: 38 80 00 06 bgu,a 2005e14 2005e00: e2 26 a0 0c st %l1, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005e04: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e08: 83 28 60 02 sll %g1, 2, %g1 2005e0c: f4 20 80 01 st %i2, [ %g2 + %g1 ] if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2005e10: e2 26 a0 0c st %l1, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 2005e14: c6 26 c0 00 st %g3, [ %i3 ] _Thread_Enable_dispatch(); 2005e18: 7f ff ff c3 call 2005d24 <_Thread_Enable_dispatch> 2005e1c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2005e20: 81 c7 e0 08 ret 2005e24: 81 e8 00 00 restore 02005e28 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 2005e28: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005e2c: 21 00 80 73 sethi %hi(0x201cc00), %l0 2005e30: 92 10 00 18 mov %i0, %o1 2005e34: 94 07 bf f4 add %fp, -12, %o2 2005e38: 40 00 0b 1d call 2008aac <_Objects_Get> 2005e3c: 90 14 23 70 or %l0, 0x370, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005e40: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005e44: 80 a0 60 00 cmp %g1, 0 2005e48: 02 80 00 07 be 2005e64 2005e4c: b0 10 00 08 mov %o0, %i0 2005e50: 80 a0 60 02 cmp %g1, 2 2005e54: 08 80 00 22 bleu 2005edc 2005e58: b0 10 20 04 mov 4, %i0 2005e5c: 81 c7 e0 08 ret <== NOT EXECUTED 2005e60: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 2005e64: 90 02 20 14 add %o0, 0x14, %o0 2005e68: 92 10 20 00 clr %o1 2005e6c: 40 00 12 8b call 200a898 <_Thread_queue_Flush> 2005e70: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e74: 90 14 23 70 or %l0, 0x370, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005e78: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e7c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005e80: 05 00 00 3f sethi %hi(0xfc00), %g2 2005e84: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005e88: 82 08 40 02 and %g1, %g2, %g1 2005e8c: 80 a0 40 03 cmp %g1, %g3 2005e90: 38 80 00 06 bgu,a 2005ea8 2005e94: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005e98: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005e9c: 83 28 60 02 sll %g1, 2, %g1 2005ea0: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 2005ea4: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 2005ea8: 40 00 0a bf call 20089a4 <_Objects_Free> 2005eac: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005eb0: 03 00 80 74 sethi %hi(0x201d000), %g1 2005eb4: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2005eb8: b0 10 20 00 clr %i0 2005ebc: 84 00 bf ff add %g2, -1, %g2 2005ec0: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 2005ec4: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2005ec8: 80 a0 60 00 cmp %g1, 0 2005ecc: 12 80 00 04 bne 2005edc 2005ed0: 01 00 00 00 nop _Thread_Dispatch(); 2005ed4: 40 00 0f fb call 2009ec0 <_Thread_Dispatch> 2005ed8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005edc: 81 c7 e0 08 ret 2005ee0: 81 e8 00 00 restore 02005f1c : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 2005f1c: 9d e3 bf 90 save %sp, -112, %sp 2005f20: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 2005f24: 80 a6 60 00 cmp %i1, 0 2005f28: 02 80 00 1f be 2005fa4 2005f2c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 2005f30: 11 00 80 73 sethi %hi(0x201cc00), %o0 2005f34: 92 10 00 10 mov %l0, %o1 2005f38: 90 12 23 70 or %o0, 0x370, %o0 2005f3c: 40 00 0a dc call 2008aac <_Objects_Get> 2005f40: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005f44: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005f48: 80 a0 60 00 cmp %g1, 0 2005f4c: 02 80 00 07 be 2005f68 2005f50: 92 10 00 10 mov %l0, %o1 2005f54: 80 a0 60 02 cmp %g1, 2 2005f58: 08 80 00 13 bleu 2005fa4 2005f5c: b0 10 20 04 mov 4, %i0 2005f60: 81 c7 e0 08 ret <== NOT EXECUTED 2005f64: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 2005f68: 94 10 20 00 clr %o2 2005f6c: 40 00 06 e4 call 2007afc <_CORE_barrier_Release> 2005f70: 90 02 20 14 add %o0, 0x14, %o0 2005f74: d0 26 40 00 st %o0, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005f78: 03 00 80 74 sethi %hi(0x201d000), %g1 2005f7c: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2005f80: b0 10 20 00 clr %i0 2005f84: 84 00 bf ff add %g2, -1, %g2 2005f88: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 2005f8c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2005f90: 80 a0 60 00 cmp %g1, 0 2005f94: 12 80 00 04 bne 2005fa4 2005f98: 01 00 00 00 nop _Thread_Dispatch(); 2005f9c: 40 00 0f c9 call 2009ec0 <_Thread_Dispatch> 2005fa0: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005fa4: 81 c7 e0 08 ret 2005fa8: 81 e8 00 00 restore 02005fac : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 2005fac: 9d e3 bf 90 save %sp, -112, %sp 2005fb0: 11 00 80 73 sethi %hi(0x201cc00), %o0 2005fb4: 92 10 00 18 mov %i0, %o1 2005fb8: 90 12 23 70 or %o0, 0x370, %o0 2005fbc: 40 00 0a bc call 2008aac <_Objects_Get> 2005fc0: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2005fc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fc8: 80 a0 60 00 cmp %g1, 0 2005fcc: 02 80 00 07 be 2005fe8 2005fd0: 96 10 00 19 mov %i1, %o3 2005fd4: 80 a0 60 02 cmp %g1, 2 2005fd8: 08 80 00 17 bleu 2006034 2005fdc: 90 10 20 04 mov 4, %o0 2005fe0: 10 80 00 15 b 2006034 <== NOT EXECUTED 2005fe4: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 2005fe8: 90 02 20 14 add %o0, 0x14, %o0 2005fec: 92 10 00 18 mov %i0, %o1 2005ff0: 94 10 20 01 mov 1, %o2 2005ff4: 40 00 06 cd call 2007b28 <_CORE_barrier_Wait> 2005ff8: 98 10 20 00 clr %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005ffc: 03 00 80 74 sethi %hi(0x201d000), %g1 2006000: c4 00 61 10 ld [ %g1 + 0x110 ], %g2 ! 201d110 <_Thread_Dispatch_disable_level> 2006004: 84 00 bf ff add %g2, -1, %g2 2006008: c4 20 61 10 st %g2, [ %g1 + 0x110 ] 200600c: c2 00 61 10 ld [ %g1 + 0x110 ], %g1 2006010: 80 a0 60 00 cmp %g1, 0 2006014: 12 80 00 05 bne 2006028 2006018: 03 00 80 74 sethi %hi(0x201d000), %g1 _Thread_Dispatch(); 200601c: 40 00 0f a9 call 2009ec0 <_Thread_Dispatch> 2006020: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 2006024: 03 00 80 74 sethi %hi(0x201d000), %g1 2006028: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 201d1f0 <_Thread_Executing> 200602c: 40 00 1e 71 call 200d9f0 <_Barrier_Translate_core_barrier_return_code> 2006030: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006034: 81 c7 e0 08 ret 2006038: 91 e8 00 08 restore %g0, %o0, %o0 02004e80 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 2004e80: 9d e3 bf 68 save %sp, -152, %sp 2004e84: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 2004e88: 80 a6 60 00 cmp %i1, 0 2004e8c: 02 80 00 47 be 2004fa8 2004e90: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 2004e94: 80 a0 60 04 cmp %g1, 4 2004e98: 18 80 00 44 bgu 2004fa8 2004e9c: b0 10 20 19 mov 0x19, %i0 2004ea0: 83 28 60 02 sll %g1, 2, %g1 2004ea4: 05 00 80 13 sethi %hi(0x2004c00), %g2 2004ea8: 84 10 a2 2c or %g2, 0x22c, %g2 ! 2004e2c 2004eac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2004eb0: 81 c0 40 00 jmp %g1 2004eb4: 01 00 00 00 nop case RTEMS_CLOCK_GET_TOD: { struct tm time; struct timeval now; rtems_time_of_day *tmbuf = (rtems_time_of_day *)time_buffer; if ( !_TOD_Is_set ) 2004eb8: 03 00 80 62 sethi %hi(0x2018800), %g1 2004ebc: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> 2004ec0: 80 a0 60 00 cmp %g1, 0 2004ec4: 22 80 00 39 be,a 2004fa8 2004ec8: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; /* Obtain the current time */ _TOD_Get_timeval( &now ); 2004ecc: a0 07 bf f0 add %fp, -16, %l0 2004ed0: 7f ff ff dc call 2004e40 <_TOD_Get_timeval> 2004ed4: 90 10 00 10 mov %l0, %o0 /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 2004ed8: 92 07 bf cc add %fp, -52, %o1 2004edc: 40 00 27 11 call 200eb20 2004ee0: 90 10 00 10 mov %l0, %o0 tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004ee4: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004ee8: d2 00 60 cc ld [ %g1 + 0xcc ], %o1 ! 2018ccc <_TOD_Microseconds_per_tick> gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 2004eec: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004ef0: d0 07 bf f4 ld [ %fp + -12 ], %o0 gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 2004ef4: c2 26 60 08 st %g1, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 2004ef8: c2 07 bf d4 ld [ %fp + -44 ], %g1 2004efc: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 2004f00: c2 07 bf d0 ld [ %fp + -48 ], %g1 2004f04: c2 26 60 10 st %g1, [ %i1 + 0x10 ] tmbuf->second = time.tm_sec; 2004f08: c2 07 bf cc ld [ %fp + -52 ], %g1 2004f0c: c2 26 60 14 st %g1, [ %i1 + 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; 2004f10: c2 07 bf e0 ld [ %fp + -32 ], %g1 2004f14: 82 00 67 6c add %g1, 0x76c, %g1 2004f18: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 2004f1c: c2 07 bf dc ld [ %fp + -36 ], %g1 2004f20: 82 00 60 01 inc %g1 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2004f24: 40 00 40 cc call 2015254 <.udiv> 2004f28: c2 26 60 04 st %g1, [ %i1 + 4 ] 2004f2c: 10 80 00 1c b 2004f9c 2004f30: d0 26 60 18 st %o0, [ %i1 + 0x18 ] return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 2004f34: 03 00 80 62 sethi %hi(0x2018800), %g1 2004f38: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> 2004f3c: 80 a0 60 00 cmp %g1, 0 2004f40: 02 80 00 19 be 2004fa4 2004f44: 03 00 80 62 sethi %hi(0x2018800), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 2004f48: 10 80 00 04 b 2004f58 2004f4c: c2 00 63 ac ld [ %g1 + 0x3ac ], %g1 ! 2018bac <_TOD_Now> } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 2004f50: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004f54: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2018c74 <_Watchdog_Ticks_since_boot> 2004f58: c2 26 40 00 st %g1, [ %i1 ] 2004f5c: 81 c7 e0 08 ret 2004f60: 91 e8 20 00 restore %g0, 0, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 2004f64: 03 00 80 63 sethi %hi(0x2018c00), %g1 2004f68: d2 00 60 cc ld [ %g1 + 0xcc ], %o1 ! 2018ccc <_TOD_Microseconds_per_tick> 2004f6c: 11 00 03 d0 sethi %hi(0xf4000), %o0 2004f70: 40 00 40 b9 call 2015254 <.udiv> 2004f74: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 2004f78: 10 80 00 09 b 2004f9c 2004f7c: d0 26 40 00 st %o0, [ %i1 ] } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 2004f80: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2004f84: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2018b2c <_TOD_Is_set> <== NOT EXECUTED 2004f88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004f8c: 22 80 00 07 be,a 2004fa8 <== NOT EXECUTED 2004f90: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); 2004f94: 7f ff ff ab call 2004e40 <_TOD_Get_timeval> <== NOT EXECUTED 2004f98: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2004f9c: 81 c7 e0 08 ret 2004fa0: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; 2004fa4: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 2004fa8: 81 c7 e0 08 ret 2004fac: 81 e8 00 00 restore 02004fd0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 2004fd0: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 2004fd4: 40 00 07 3f call 2006cd0 <_TOD_Tickle_ticks> 2004fd8: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 2004fdc: 11 00 80 62 sethi %hi(0x2018800), %o0 2004fe0: 40 00 14 92 call 200a228 <_Watchdog_Tickle> 2004fe4: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2018bf0 <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 2004fe8: 40 00 12 e9 call 2009b8c <_Thread_Tickle_timeslice> 2004fec: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 2004ff0: 03 00 80 62 sethi %hi(0x2018800), %g1 2004ff4: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 ! 2018be0 <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 2004ff8: 80 a0 60 00 cmp %g1, 0 2004ffc: 02 80 00 08 be 200501c 2005000: 03 00 80 62 sethi %hi(0x2018800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 2005004: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005008: 80 a0 60 00 cmp %g1, 0 200500c: 12 80 00 04 bne 200501c 2005010: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 2005014: 40 00 0e f2 call 2008bdc <_Thread_Dispatch> <== NOT EXECUTED 2005018: 01 00 00 00 nop <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 200501c: 81 c7 e0 08 ret 2005020: 91 e8 20 00 restore %g0, 0, %o0 02002aec : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 2002aec: 9d e3 bf 68 save %sp, -152, %sp struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 2002af0: 80 a6 60 00 cmp %i1, 0 2002af4: 02 80 00 62 be 2002c7c 2002af8: a0 07 bf e0 add %fp, -32, %l0 * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); 2002afc: 40 00 16 93 call 2008548 <_TOD_Get_uptime> 2002b00: 90 10 00 10 mov %l0, %o0 _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 2002b04: 92 10 00 10 mov %l0, %o1 2002b08: a2 07 bf d8 add %fp, -40, %l1 2002b0c: 11 00 80 97 sethi %hi(0x2025c00), %o0 2002b10: 94 10 00 11 mov %l1, %o2 2002b14: 40 00 24 74 call 200bce4 <_Timespec_Subtract> 2002b18: 90 12 21 94 or %o0, 0x194, %o0 } } } #endif (*print)( context, "CPU Usage by thread\n" 2002b1c: 90 10 00 18 mov %i0, %o0 2002b20: 13 00 80 6a sethi %hi(0x201a800), %o1 2002b24: 9f c6 40 00 call %i1 2002b28: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 201aae8 2002b2c: 03 00 80 95 sethi %hi(0x2025400), %g1 the_thread = (Thread_Control *)information->local_table[ i ]; if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002b30: ac 07 bf eb add %fp, -21, %l6 } } } #endif (*print)( context, "CPU Usage by thread\n" 2002b34: a6 10 62 64 or %g1, 0x264, %l3 /* * 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 ) { 2002b38: 37 00 80 95 sethi %hi(0x2025400), %i3 struct timespec used; _Timespec_Subtract( 2002b3c: 03 00 80 95 sethi %hi(0x2025400), %g1 &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002b40: aa 07 bf d0 add %fp, -48, %l5 * since the last context switch. */ ran = the_thread->cpu_time_used; if ( _Thread_Executing->Object.id == the_thread->Object.id ) { struct timespec used; _Timespec_Subtract( 2002b44: b4 10 63 e8 or %g1, 0x3e8, %i2 &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002b48: b8 07 bf f4 add %fp, -12, %i4 2002b4c: ba 07 bf f0 add %fp, -16, %i5 * since the last context switch. */ ran = the_thread->cpu_time_used; if ( _Thread_Executing->Object.id == the_thread->Object.id ) { struct timespec used; _Timespec_Subtract( 2002b50: a8 07 bf c8 add %fp, -56, %l4 " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2002b54: ae 04 e0 10 add %l3, 0x10, %l7 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2002b58: c2 04 c0 00 ld [ %l3 ], %g1 2002b5c: 80 a0 60 00 cmp %g1, 0 2002b60: 22 80 00 3b be,a 2002c4c 2002b64: a6 04 e0 04 add %l3, 4, %l3 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2002b68: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 2002b6c: 80 a4 60 00 cmp %l1, 0 2002b70: 12 80 00 30 bne 2002c30 2002b74: a4 10 20 01 mov 1, %l2 for ( i=1 ; i <= information->maximum ; i++ ) { 2002b78: 10 80 00 35 b 2002c4c <== NOT EXECUTED 2002b7c: a6 04 e0 04 add %l3, 4, %l3 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 2002b80: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 2002b84: e0 00 40 02 ld [ %g1 + %g2 ], %l0 if ( !the_thread ) 2002b88: 80 a4 20 00 cmp %l0, 0 2002b8c: 02 80 00 29 be 2002c30 2002b90: a4 04 a0 01 inc %l2 continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002b94: 40 00 0f a4 call 2006a24 2002b98: d0 04 20 08 ld [ %l0 + 8 ], %o0 (*print)( context, "0x%08" PRIx32 " %4s ", the_thread->Object.id, name ); 2002b9c: d4 04 20 08 ld [ %l0 + 8 ], %o2 2002ba0: 90 10 00 18 mov %i0, %o0 2002ba4: 13 00 80 6a sethi %hi(0x201a800), %o1 2002ba8: 96 10 00 16 mov %l6, %o3 2002bac: 9f c6 40 00 call %i1 2002bb0: 92 12 63 28 or %o1, 0x328, %o1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 2002bb4: c4 1c 20 90 ldd [ %l0 + 0x90 ], %g2 if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 2002bb8: c2 06 e3 e0 ld [ %i3 + 0x3e0 ], %g1 #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; 2002bbc: c4 3f bf d0 std %g2, [ %fp + -48 ] if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 2002bc0: c4 00 60 08 ld [ %g1 + 8 ], %g2 2002bc4: c2 04 20 08 ld [ %l0 + 8 ], %g1 2002bc8: 80 a0 80 01 cmp %g2, %g1 2002bcc: 12 80 00 0a bne 2002bf4 2002bd0: 94 10 00 1c mov %i4, %o2 struct timespec used; _Timespec_Subtract( 2002bd4: 90 10 00 1a mov %i2, %o0 2002bd8: 92 07 bf e0 add %fp, -32, %o1 2002bdc: 40 00 24 42 call 200bce4 <_Timespec_Subtract> 2002be0: 94 10 00 14 mov %l4, %o2 &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 2002be4: 90 10 00 15 mov %l5, %o0 2002be8: 40 00 23 97 call 200ba44 <_Timespec_Add_to> 2002bec: 92 10 00 14 mov %l4, %o1 }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002bf0: 94 10 00 1c mov %i4, %o2 2002bf4: 96 10 00 1d mov %i5, %o3 2002bf8: 90 10 00 15 mov %l5, %o0 2002bfc: 40 00 23 aa call 200baa4 <_Timespec_Divide> 2002c00: 92 07 bf d8 add %fp, -40, %o1 /* * Print the information */ (*print)( context, 2002c04: d0 07 bf d4 ld [ %fp + -44 ], %o0 2002c08: 40 00 57 ab call 2018ab4 <.udiv> 2002c0c: 92 10 23 e8 mov 0x3e8, %o1 2002c10: d4 07 bf d0 ld [ %fp + -48 ], %o2 2002c14: d8 07 bf f4 ld [ %fp + -12 ], %o4 2002c18: da 07 bf f0 ld [ %fp + -16 ], %o5 2002c1c: 96 10 00 08 mov %o0, %o3 2002c20: 13 00 80 6a sethi %hi(0x201a800), %o1 2002c24: 90 10 00 18 mov %i0, %o0 2002c28: 9f c6 40 00 call %i1 2002c2c: 92 12 63 40 or %o1, 0x340, %o1 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2002c30: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 the_thread = (Thread_Control *)information->local_table[ i ]; if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002c34: 94 10 00 16 mov %l6, %o2 2002c38: 92 10 20 05 mov 5, %o1 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2002c3c: 80 a4 80 01 cmp %l2, %g1 2002c40: 08 bf ff d0 bleu 2002b80 2002c44: 85 2c a0 02 sll %l2, 2, %g2 2002c48: a6 04 e0 04 add %l3, 4, %l3 " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2002c4c: 80 a4 c0 17 cmp %l3, %l7 2002c50: 32 bf ff c3 bne,a 2002b5c 2002c54: c2 04 c0 00 ld [ %l3 ], %g1 } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 2002c58: d0 07 bf dc ld [ %fp + -36 ], %o0 2002c5c: 40 00 57 96 call 2018ab4 <.udiv> 2002c60: 92 10 23 e8 mov 0x3e8, %o1 2002c64: d4 07 bf d8 ld [ %fp + -40 ], %o2 2002c68: 96 10 00 08 mov %o0, %o3 2002c6c: 13 00 80 6a sethi %hi(0x201a800), %o1 2002c70: 90 10 00 18 mov %i0, %o0 2002c74: 9f c6 40 00 call %i1 2002c78: 92 12 63 58 or %o1, 0x358, %o1 2002c7c: 81 c7 e0 08 ret 2002c80: 81 e8 00 00 restore 0200d57c : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 200d57c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code))) 200d580: 11 00 80 60 sethi %hi(0x2018000), %o0 <== NOT EXECUTED 200d584: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200d588: 40 00 01 2d call 200da3c <== NOT EXECUTED 200d58c: 90 12 20 2c or %o0, 0x2c, %o0 <== NOT EXECUTED 200d590: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 200d594: 02 80 00 05 be 200d5a8 <== NOT EXECUTED 200d598: 01 00 00 00 nop <== NOT EXECUTED { errno = rc; 200d59c: 40 00 03 91 call 200e3e0 <__errno> <== NOT EXECUTED 200d5a0: 01 00 00 00 nop <== NOT EXECUTED 200d5a4: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED return -1; } return -1; } 200d5a8: 81 c7 e0 08 ret <== NOT EXECUTED 200d5ac: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED 020061e0 : int rtems_error( int error_flag, const char *printf_format, ... ) { 20061e0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED va_list arglist; int chars_written; va_start(arglist, printf_format); 20061e4: 94 07 a0 4c add %fp, 0x4c, %o2 <== NOT EXECUTED int rtems_error( int error_flag, const char *printf_format, ... ) { 20061e8: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 20061ec: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED 20061f0: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED 20061f4: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED va_list arglist; int chars_written; va_start(arglist, printf_format); chars_written = rtems_verror(error_flag, printf_format, arglist); 20061f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20061fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2006200: 7f ff ff 7f call 2005ffc <== NOT EXECUTED 2006204: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED va_end(arglist); return chars_written; } 2006208: 81 c7 e0 08 ret <== NOT EXECUTED 200620c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 02005234 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 2005234: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2005238: 92 96 20 00 orcc %i0, 0, %o1 200523c: 12 80 00 0a bne 2005264 2005240: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005244: 03 00 80 62 sethi %hi(0x2018800), %g1 2005248: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 200524c: 84 00 a0 01 inc %g2 2005250: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 2005254: 03 00 80 62 sethi %hi(0x2018800), %g1 2005258: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> 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; 200525c: 10 80 00 18 b 20052bc 2005260: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005264: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2005268: 80 a0 a0 04 cmp %g2, 4 200526c: 18 80 00 0e bgu 20052a4 2005270: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005274: 83 32 60 1b srl %o1, 0x1b, %g1 2005278: 80 a0 60 01 cmp %g1, 1 200527c: 12 80 00 0a bne 20052a4 2005280: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005284: 83 28 a0 02 sll %g2, 2, %g1 2005288: 05 00 80 62 sethi %hi(0x2018800), %g2 200528c: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2005290: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005294: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2005298: 80 a2 20 00 cmp %o0, 0 200529c: 12 80 00 05 bne 20052b0 20052a0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20052a4: b0 10 20 00 clr %i0 20052a8: 10 80 00 05 b 20052bc 20052ac: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20052b0: 40 00 09 46 call 20077c8 <_Objects_Get> 20052b4: 94 07 bf f4 add %fp, -12, %o2 20052b8: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20052bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20052c0: 80 a0 60 00 cmp %g1, 0 20052c4: 02 80 00 06 be 20052dc 20052c8: 80 a0 60 02 cmp %g1, 2 20052cc: 08 80 00 18 bleu 200532c 20052d0: b0 10 20 04 mov 4, %i0 20052d4: 81 c7 e0 08 ret <== NOT EXECUTED 20052d8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 20052dc: 7f ff f2 a0 call 2001d5c 20052e0: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 *the_event_set |= the_new_events; 20052e4: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20052e8: 82 10 40 19 or %g1, %i1, %g1 20052ec: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 20052f0: 7f ff f2 9f call 2001d6c 20052f4: 01 00 00 00 nop case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 20052f8: 40 00 00 15 call 200534c <_Event_Surrender> 20052fc: 90 10 00 18 mov %i0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005300: 05 00 80 62 sethi %hi(0x2018800), %g2 2005304: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 2005308: b0 10 20 00 clr %i0 200530c: 82 00 7f ff add %g1, -1, %g1 2005310: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005314: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005318: 80 a0 60 00 cmp %g1, 0 200531c: 12 80 00 04 bne 200532c 2005320: 01 00 00 00 nop _Thread_Dispatch(); 2005324: 40 00 0e 2e call 2008bdc <_Thread_Dispatch> 2005328: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200532c: 81 c7 e0 08 ret 2005330: 81 e8 00 00 restore 0200ac40 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 200ac40: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 200ac44: a4 96 20 00 orcc %i0, 0, %l2 200ac48: 02 80 00 0e be 200ac80 200ac4c: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200ac50: 05 00 80 9e sethi %hi(0x2027800), %g2 200ac54: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 200ac58: 82 00 60 01 inc %g1 200ac5c: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 200ac60: 23 00 80 9f sethi %hi(0x2027c00), %l1 200ac64: 40 00 03 ac call 200bb14 <_Objects_Allocate> 200ac68: 90 14 60 ec or %l1, 0xec, %o0 ! 2027cec <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 200ac6c: a0 92 20 00 orcc %o0, 0, %l0 200ac70: 12 80 00 06 bne 200ac88 200ac74: 90 04 20 10 add %l0, 0x10, %o0 _Thread_Enable_dispatch(); 200ac78: 7f ff ff e5 call 200ac0c <_Thread_Enable_dispatch> <== NOT EXECUTED 200ac7c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200ac80: 81 c7 e0 08 ret <== NOT EXECUTED 200ac84: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 200ac88: 40 00 0e 6d call 200e63c <_User_extensions_Add_set> 200ac8c: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac90: 90 14 60 ec or %l1, 0xec, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ac94: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ac98: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ac9c: 05 00 00 3f sethi %hi(0xfc00), %g2 200aca0: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200aca4: 82 08 40 02 and %g1, %g2, %g1 200aca8: 80 a0 40 03 cmp %g1, %g3 200acac: 38 80 00 06 bgu,a 200acc4 200acb0: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200acb4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200acb8: 83 28 60 02 sll %g1, 2, %g1 200acbc: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 200acc0: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200acc4: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200acc8: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 200accc: 7f ff ff d0 call 200ac0c <_Thread_Enable_dispatch> 200acd0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200acd4: 81 c7 e0 08 ret 200acd8: 81 e8 00 00 restore 0200acdc : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 200acdc: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get ( Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) 200ace0: 21 00 80 9f sethi %hi(0x2027c00), %l0 <== NOT EXECUTED 200ace4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200ace8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200acec: 40 00 04 ce call 200c024 <_Objects_Get> <== NOT EXECUTED 200acf0: 90 14 20 ec or %l0, 0xec, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200acf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200acf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200acfc: 02 80 00 07 be 200ad18 <== NOT EXECUTED 200ad00: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200ad04: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ad08: 08 80 00 20 bleu 200ad88 <== NOT EXECUTED 200ad0c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 200ad10: 81 c7 e0 08 ret <== NOT EXECUTED 200ad14: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never return this */ return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 200ad18: 40 00 0e 83 call 200e724 <_User_extensions_Remove_set> <== NOT EXECUTED 200ad1c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ad20: 90 14 20 ec or %l0, 0xec, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200ad24: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ad28: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 200ad2c: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200ad30: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200ad34: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200ad38: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200ad3c: 38 80 00 06 bgu,a 200ad54 <== NOT EXECUTED 200ad40: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200ad44: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 200ad48: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200ad4c: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200ad50: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 200ad54: 40 00 04 72 call 200bf1c <_Objects_Free> <== NOT EXECUTED 200ad58: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ad5c: 03 00 80 9e sethi %hi(0x2027800), %g1 <== NOT EXECUTED 200ad60: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200ad64: b0 10 20 00 clr %i0 <== NOT EXECUTED 200ad68: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200ad6c: c4 20 62 50 st %g2, [ %g1 + 0x250 ] <== NOT EXECUTED 200ad70: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 <== NOT EXECUTED 200ad74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ad78: 12 80 00 04 bne 200ad88 <== NOT EXECUTED 200ad7c: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 200ad80: 40 00 09 ae call 200d438 <_Thread_Dispatch> <== NOT EXECUTED 200ad84: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ad88: 81 c7 e0 08 ret <== NOT EXECUTED 200ad8c: 81 e8 00 00 restore <== NOT EXECUTED 02001f30 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 2001f30: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 2001f34: 80 a6 60 00 cmp %i1, 0 2001f38: 32 80 00 06 bne,a 2001f50 2001f3c: c2 06 60 08 ld [ %i1 + 8 ], %g1 rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 2001f40: 40 00 31 28 call 200e3e0 <__errno> <== NOT EXECUTED 2001f44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2001f48: 10 80 00 09 b 2001f6c <== NOT EXECUTED 2001f4c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 2001f50: c2 00 40 00 ld [ %g1 ], %g1 2001f54: 80 a0 60 00 cmp %g1, 0 2001f58: 12 80 00 08 bne 2001f78 2001f5c: a0 07 bf e8 add %fp, -24, %l0 rtems_set_errno_and_return_minus_one( ENOTSUP ); 2001f60: 40 00 31 20 call 200e3e0 <__errno> <== NOT EXECUTED 2001f64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2001f68: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2001f6c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2001f70: 81 c7 e0 08 ret <== NOT EXECUTED 2001f74: 81 e8 00 00 restore <== NOT EXECUTED parent = *pathloc; 2001f78: 92 10 00 19 mov %i1, %o1 2001f7c: 94 10 20 10 mov 0x10, %o2 2001f80: 40 00 32 ed call 200eb34 2001f84: 90 10 00 10 mov %l0, %o0 result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 2001f88: c2 06 60 08 ld [ %i1 + 8 ], %g1 2001f8c: 92 10 00 18 mov %i0, %o1 2001f90: c2 00 40 00 ld [ %g1 ], %g1 2001f94: 11 00 80 5a sethi %hi(0x2016800), %o0 2001f98: 94 10 00 10 mov %l0, %o2 2001f9c: 9f c0 40 00 call %g1 2001fa0: 90 12 23 b8 or %o0, 0x3b8, %o0 if (result != 0){ 2001fa4: b0 92 20 00 orcc %o0, 0, %i0 2001fa8: 02 80 00 04 be 2001fb8 2001fac: c2 07 bf f0 ld [ %fp + -16 ], %g1 2001fb0: 81 c7 e0 08 ret <== NOT EXECUTED 2001fb4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); 2001fb8: 80 a0 60 00 cmp %g1, 0 2001fbc: 02 80 00 08 be 2001fdc 2001fc0: 01 00 00 00 nop 2001fc4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2001fc8: 80 a0 60 00 cmp %g1, 0 2001fcc: 02 80 00 04 be 2001fdc 2001fd0: 01 00 00 00 nop 2001fd4: 9f c0 40 00 call %g1 2001fd8: 90 10 00 10 mov %l0, %o0 return result; } 2001fdc: 81 c7 e0 08 ret 2001fe0: 81 e8 00 00 restore 02001fe4 : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 2001fe4: 9d e3 bf 98 save %sp, -104, %sp /* * Verify Input parameters. */ if ( !pathname ) 2001fe8: 80 a6 20 00 cmp %i0, 0 2001fec: 12 80 00 06 bne 2002004 2001ff0: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EFAULT ); 2001ff4: 40 00 30 fb call 200e3e0 <__errno> 2001ff8: b0 10 3f ff mov -1, %i0 2001ffc: 10 80 00 43 b 2002108 2002000: 82 10 20 0e mov 0xe, %g1 if ( !pathloc ) 2002004: 32 80 00 06 bne,a 200201c 2002008: c2 4e 00 00 ldsb [ %i0 ], %g1 rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 200200c: 40 00 30 f5 call 200e3e0 <__errno> <== NOT EXECUTED 2002010: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002014: 10 80 00 3d b 2002108 <== NOT EXECUTED 2002018: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 200201c: 80 a0 60 2f cmp %g1, 0x2f 2002020: 02 80 00 06 be 2002038 2002024: 80 a0 60 5c cmp %g1, 0x5c 2002028: 02 80 00 04 be 2002038 200202c: 80 a0 60 00 cmp %g1, 0 2002030: 12 80 00 0a bne 2002058 2002034: 03 00 80 5f sethi %hi(0x2017c00), %g1 2002038: 03 00 80 5f sethi %hi(0x2017c00), %g1 200203c: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 ! 2017db8 2002040: 90 10 00 1a mov %i2, %o0 2002044: 92 02 60 14 add %o1, 0x14, %o1 2002048: 40 00 32 bb call 200eb34 200204c: 94 10 20 10 mov 0x10, %o2 2002050: 10 80 00 08 b 2002070 2002054: 84 10 20 01 mov 1, %g2 2002058: d2 00 61 b8 ld [ %g1 + 0x1b8 ], %o1 200205c: 90 10 00 1a mov %i2, %o0 2002060: 92 02 60 04 add %o1, 4, %o1 2002064: 40 00 32 b4 call 200eb34 2002068: 94 10 20 10 mov 0x10, %o2 200206c: 84 10 20 00 clr %g2 if ( !pathloc->ops->evalpath_h ) 2002070: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2002074: c2 00 40 00 ld [ %g1 ], %g1 2002078: 80 a0 60 00 cmp %g1, 0 200207c: 02 80 00 20 be 20020fc 2002080: 90 06 00 02 add %i0, %g2, %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 2002084: 92 10 00 19 mov %i1, %o1 2002088: 9f c0 40 00 call %g1 200208c: 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 ) { 2002090: b0 92 20 00 orcc %o0, 0, %i0 2002094: 12 80 00 1e bne 200210c 2002098: 80 a6 e0 00 cmp %i3, 0 200209c: 02 80 00 21 be 2002120 20020a0: 01 00 00 00 nop if ( !pathloc->ops->node_type_h ){ 20020a4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 20020a8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 20020ac: 80 a0 a0 00 cmp %g2, 0 20020b0: 22 80 00 0e be,a 20020e8 20020b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( pathloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 20020b8: 9f c0 80 00 call %g2 20020bc: 90 10 00 1a mov %i2, %o0 if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 20020c0: 90 02 3f fd add %o0, -3, %o0 20020c4: 80 a2 20 01 cmp %o0, 1 20020c8: 18 80 00 16 bgu 2002120 20020cc: 01 00 00 00 nop ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 20020d0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 20020d4: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 20020d8: 80 a0 a0 00 cmp %g2, 0 20020dc: 12 80 00 0e bne 2002114 20020e0: 90 10 00 1a mov %i2, %o0 rtems_filesystem_freenode( pathloc ); 20020e4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20020e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20020ec: 02 80 00 04 be 20020fc <== NOT EXECUTED 20020f0: 01 00 00 00 nop <== NOT EXECUTED 20020f4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20020f8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 20020fc: 40 00 30 b9 call 200e3e0 <__errno> <== NOT EXECUTED 2002100: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002104: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2002108: c2 22 00 00 st %g1, [ %o0 ] 200210c: 81 c7 e0 08 ret 2002110: 81 e8 00 00 restore * 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 ); 2002114: 9f c0 80 00 call %g2 2002118: 92 10 00 19 mov %i1, %o1 200211c: b0 10 00 08 mov %o0, %i0 } } return result; } 2002120: 81 c7 e0 08 ret 2002124: 81 e8 00 00 restore 0200b6d8 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 200b6d8: 9d e3 bf 80 save %sp, -128, %sp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 200b6dc: 25 00 80 5f sethi %hi(0x2017c00), %l2 200b6e0: c4 04 a1 b8 ld [ %l2 + 0x1b8 ], %g2 ! 2017db8 200b6e4: 82 10 20 12 mov 0x12, %g1 init_fs_mount_table(); 200b6e8: 40 00 01 91 call 200bd2c 200b6ec: c2 30 a0 24 sth %g1, [ %g2 + 0x24 ] /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 200b6f0: 03 00 80 5d sethi %hi(0x2017400), %g1 200b6f4: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 20177b8 200b6f8: 80 a0 60 00 cmp %g1, 0 200b6fc: 12 80 00 06 bne 200b714 200b700: 03 00 80 5d sethi %hi(0x2017400), %g1 rtems_fatal_error_occurred( 0xABCD0001 ); 200b704: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED 200b708: 7f ff eb 98 call 2006568 <== NOT EXECUTED 200b70c: 90 12 20 01 or %o0, 1, %o0 ! abcd0001 <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 200b710: 03 00 80 5d sethi %hi(0x2017400), %g1 <== NOT EXECUTED 200b714: c2 00 63 b4 ld [ %g1 + 0x3b4 ], %g1 ! 20177b4 status = mount( 200b718: 90 07 bf f4 add %fp, -12, %o0 200b71c: d8 00 60 0c ld [ %g1 + 0xc ], %o4 200b720: d2 00 40 00 ld [ %g1 ], %o1 200b724: d4 00 60 04 ld [ %g1 + 4 ], %o2 200b728: 40 00 01 89 call 200bd4c 200b72c: d6 00 60 08 ld [ %g1 + 8 ], %o3 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 200b730: 80 a2 3f ff cmp %o0, -1 200b734: 32 80 00 06 bne,a 200b74c 200b738: d0 04 a1 b8 ld [ %l2 + 0x1b8 ], %o0 rtems_fatal_error_occurred( 0xABCD0002 ); 200b73c: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED 200b740: 7f ff eb 8a call 2006568 <== NOT EXECUTED 200b744: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 200b748: d0 04 a1 b8 ld [ %l2 + 0x1b8 ], %o0 <== NOT EXECUTED * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200b74c: d2 07 bf f4 ld [ %fp + -12 ], %o1 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 200b750: c0 32 20 26 clrh [ %o0 + 0x26 ] * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200b754: 92 02 60 18 add %o1, 0x18, %o1 200b758: 94 10 20 10 mov 0x10, %o2 200b75c: 40 00 0c f6 call 200eb34 200b760: 90 02 20 14 add %o0, 0x14, %o0 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200b764: a0 07 bf e4 add %fp, -28, %l0 200b768: 96 10 20 00 clr %o3 200b76c: 23 00 80 5b sethi %hi(0x2016c00), %l1 200b770: 92 10 20 00 clr %o1 200b774: 94 10 00 10 mov %l0, %o2 200b778: 7f ff da 1b call 2001fe4 200b77c: 90 14 62 30 or %l1, 0x230, %o0 rtems_filesystem_root = loc; 200b780: d0 04 a1 b8 ld [ %l2 + 0x1b8 ], %o0 200b784: 92 10 00 10 mov %l0, %o1 200b788: 94 10 20 10 mov 0x10, %o2 200b78c: 40 00 0c ea call 200eb34 200b790: 90 02 20 14 add %o0, 0x14, %o0 /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200b794: 96 10 20 00 clr %o3 200b798: 92 10 20 00 clr %o1 200b79c: 94 10 00 10 mov %l0, %o2 200b7a0: 7f ff da 11 call 2001fe4 200b7a4: 90 14 62 30 or %l1, 0x230, %o0 rtems_filesystem_current = loc; 200b7a8: d0 04 a1 b8 ld [ %l2 + 0x1b8 ], %o0 200b7ac: 92 10 00 10 mov %l0, %o1 200b7b0: 94 10 20 10 mov 0x10, %o2 200b7b4: 40 00 0c e0 call 200eb34 200b7b8: 90 02 20 04 add %o0, 4, %o0 * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 200b7bc: 92 10 21 ff mov 0x1ff, %o1 200b7c0: 11 00 80 5b sethi %hi(0x2016c00), %o0 200b7c4: 40 00 01 50 call 200bd04 200b7c8: 90 12 22 38 or %o0, 0x238, %o0 ! 2016e38 <_CPU_Trap_slot_template+0x80> if ( status != 0 ) 200b7cc: 80 a2 20 00 cmp %o0, 0 200b7d0: 02 80 00 04 be 200b7e0 200b7d4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 rtems_fatal_error_occurred( 0xABCD0003 ); 200b7d8: 7f ff eb 64 call 2006568 <== NOT EXECUTED 200b7dc: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <== NOT EXECUTED 200b7e0: 81 c7 e0 08 ret 200b7e4: 81 e8 00 00 restore 02006c38 : ); rtems_boolean rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 2006c38: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2006c3c: c4 02 40 00 ld [ %o1 ], %g2 <== NOT EXECUTED 2006c40: 82 18 40 02 xor %g1, %g2, %g1 <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 2006c44: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2006c48: 81 c3 e0 08 retl <== NOT EXECUTED 2006c4c: 90 60 3f ff subx %g0, -1, %o0 <== NOT EXECUTED 02006584 : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 2006584: 11 00 80 5d sethi %hi(0x2017400), %o0 <== NOT EXECUTED 2006588: 81 c3 e0 08 retl <== NOT EXECUTED 200658c: 90 12 23 38 or %o0, 0x338, %o0 ! 2017738 <_RTEMS_version> <== NOT EXECUTED 02006324 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 2006324: 9d e3 bf 80 save %sp, -128, %sp * Dispatching and interrupts are disabled until the end of the * initialization sequence. This prevents an inadvertent context * switch before the executive is initialized. */ _ISR_Disable( bsp_level ); 2006328: 7f ff ee 8d call 2001d5c 200632c: 01 00 00 00 nop 2006330: a4 10 00 08 mov %o0, %l2 if ( configuration_table == NULL ) 2006334: 80 a6 20 00 cmp %i0, 0 2006338: 12 80 00 07 bne 2006354 200633c: 03 00 80 63 sethi %hi(0x2018c00), %g1 _Internal_error_Occurred( 2006340: 90 10 20 00 clr %o0 <== NOT EXECUTED 2006344: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006348: 40 00 03 af call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 200634c: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 2006350: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2006354: c0 20 60 d0 clr [ %g1 + 0xd0 ] ! 2018cd0 <_System_state_Current> _System_state_Is_multiprocessing = is_multiprocessing; 2006358: 03 00 80 62 sethi %hi(0x2018800), %g1 /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 200635c: 94 10 20 28 mov 0x28, %o2 2006360: 92 10 00 19 mov %i1, %o1 2006364: c0 20 63 fc clr [ %g1 + 0x3fc ] 2006368: 11 00 80 62 sethi %hi(0x2018800), %o0 200636c: 40 00 21 f2 call 200eb34 2006370: 90 12 23 04 or %o0, 0x304, %o0 ! 2018b04 <_CPU_Table> /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 2006374: 03 00 80 62 sethi %hi(0x2018800), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 2006378: 90 10 00 19 mov %i1, %o0 200637c: 13 00 80 22 sethi %hi(0x2008800), %o1 2006380: 92 12 63 dc or %o1, 0x3dc, %o1 ! 2008bdc <_Thread_Dispatch> 2006384: 40 00 11 93 call 200a9d0 <_CPU_Initialize> 2006388: f0 20 63 b4 st %i0, [ %g1 + 0x3b4 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 200638c: 40 00 19 ca call 200cab4 <_Debug_Manager_initialization> 2006390: 01 00 00 00 nop _API_extensions_Initialization(); 2006394: 40 00 00 f2 call 200675c <_API_extensions_Initialization> 2006398: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 200639c: d2 06 20 04 ld [ %i0 + 4 ], %o1 20063a0: d0 06 00 00 ld [ %i0 ], %o0 * This routine initializes the thread dispatching subsystem. */ RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; 20063a4: 84 10 20 01 mov 1, %g2 20063a8: 03 00 80 62 sethi %hi(0x2018800), %g1 20063ac: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] ! 2018af0 <_Thread_Dispatch_disable_level> 20063b0: 40 00 0f d3 call 200a2fc <_Workspace_Handler_initialization> 20063b4: 23 00 80 63 sethi %hi(0x2018c00), %l1 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 20063b8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 20063bc: 40 00 0e 73 call 2009d88 <_User_extensions_Handler_initialization> 20063c0: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 20063c4: 40 00 03 a0 call 2007244 <_ISR_Handler_initialization> 20063c8: a0 07 bf e8 add %fp, -24, %l0 _Objects_Handler_initialization( 20063cc: 90 10 20 01 mov 1, %o0 20063d0: 92 10 20 01 mov 1, %o1 20063d4: 40 00 05 96 call 2007a2c <_Objects_Handler_initialization> 20063d8: 94 10 20 00 clr %o2 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20063dc: 05 00 80 62 sethi %hi(0x2018800), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063e0: c0 23 a0 5c clr [ %sp + 0x5c ] multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20063e4: 03 00 80 62 sethi %hi(0x2018800), %g1 20063e8: 82 10 63 30 or %g1, 0x330, %g1 ! 2018b30 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063ec: 96 10 20 01 mov 1, %o3 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20063f0: c2 20 a2 54 st %g1, [ %g2 + 0x254 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20063f4: 98 10 20 74 mov 0x74, %o4 20063f8: 9a 10 20 00 clr %o5 20063fc: 90 14 60 00 mov %l1, %o0 2006400: 92 10 20 01 mov 1, %o1 2006404: 40 00 05 16 call 200785c <_Objects_Initialize_information> 2006408: 94 10 20 02 mov 2, %o2 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 200640c: 94 10 20 10 mov 0x10, %o2 2006410: 13 00 80 5b sethi %hi(0x2016c00), %o1 2006414: 90 10 00 10 mov %l0, %o0 2006418: 40 00 21 c7 call 200eb34 200641c: 92 12 61 a0 or %o1, 0x1a0, %o1 2006420: 40 00 03 a6 call 20072b8 <_Objects_Allocate> 2006424: 90 14 60 00 mov %l1, %o0 2006428: 03 00 80 62 sethi %hi(0x2018800), %g1 200642c: 84 10 00 08 mov %o0, %g2 2006430: 92 10 00 10 mov %l0, %o1 2006434: c4 20 63 c8 st %g2, [ %g1 + 0x3c8 ] 2006438: 90 02 20 10 add %o0, 0x10, %o0 200643c: 40 00 01 2a call 20068e4 <_CORE_mutex_Initialize> 2006440: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006444: 03 00 80 62 sethi %hi(0x2018800), %g1 2006448: 84 10 20 00 clr %g2 200644c: c0 30 63 c4 clrh [ %g1 + 0x3c4 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006450: 03 00 80 63 sethi %hi(0x2018c00), %g1 2006454: 82 10 60 50 or %g1, 0x50, %g1 ! 2018c50 <_Priority_Bit_map> 2006458: c0 30 80 01 clrh [ %g2 + %g1 ] 200645c: 84 00 a0 02 add %g2, 2, %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 2006460: 80 a0 a0 20 cmp %g2, 0x20 2006464: 32 bf ff fe bne,a 200645c 2006468: c0 30 80 01 clrh [ %g2 + %g1 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 200646c: 40 00 0f 32 call 200a134 <_Watchdog_Handler_initialization> 2006470: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 2006474: 40 00 02 08 call 2006c94 <_TOD_Handler_initialization> 2006478: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 200647c: d2 06 20 08 ld [ %i0 + 8 ], %o1 2006480: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 2006484: 40 00 0a c3 call 2008f90 <_Thread_Handler_initialization> 2006488: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 200648c: 40 00 00 95 call 20066e0 <_RTEMS_API_Initialize> 2006490: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 2006494: 40 00 00 28 call 2006534 <_Extension_Manager_initialization> 2006498: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 200649c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20064a0: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 20064a4: 40 00 00 49 call 20065c8 <_IO_Manager_initialization> 20064a8: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 configuration_table->number_of_device_drivers, configuration_table->maximum_drivers ); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize( configuration_table ); 20064ac: 40 00 00 68 call 200664c <_POSIX_API_Initialize> 20064b0: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 20064b4: 84 10 20 01 mov 1, %g2 20064b8: 03 00 80 63 sethi %hi(0x2018c00), %g1 * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); 20064bc: 40 00 09 6c call 2008a6c <_Thread_Create_idle> 20064c0: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] ! 2018cd0 <_System_state_Current> /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 20064c4: d0 06 40 00 ld [ %i1 ], %o0 20064c8: 80 a2 20 00 cmp %o0, 0 20064cc: 02 80 00 04 be 20064dc 20064d0: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 20064d4: 9f c2 00 00 call %o0 20064d8: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 20064dc: 40 00 00 bf call 20067d8 <_API_extensions_Run_predriver> 20064e0: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 20064e4: 03 00 80 62 sethi %hi(0x2018800), %g1 20064e8: a0 10 63 04 or %g1, 0x304, %l0 ! 2018b04 <_CPU_Table> 20064ec: c2 04 20 04 ld [ %l0 + 4 ], %g1 20064f0: 80 a0 60 00 cmp %g1, 0 20064f4: 02 80 00 04 be 2006504 20064f8: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 20064fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006500: 01 00 00 00 nop <== NOT EXECUTED * Initialize all the device drivers and initialize the MPCI layer. * * NOTE: The MPCI may be build upon a device driver. */ _IO_Initialize_all_drivers(); 2006504: 40 00 00 23 call 2006590 <_IO_Initialize_all_drivers> 2006508: 01 00 00 00 nop * Run the APIs and BSPs postdriver hooks. * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); 200650c: 40 00 00 9b call 2006778 <_API_extensions_Run_postdriver> 2006510: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 2006514: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006518: 80 a0 60 00 cmp %g1, 0 200651c: 02 80 00 04 be 200652c 2006520: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 2006524: 9f c0 40 00 call %g1 2006528: 01 00 00 00 nop return bsp_level; } 200652c: 81 c7 e0 08 ret 2006530: 91 e8 00 12 restore %g0, %l2, %o0 02001dc8 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 2001dc8: 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 ); 2001dcc: 92 10 20 00 clr %o1 <== NOT EXECUTED 2001dd0: a4 07 bf e8 add %fp, -24, %l2 <== NOT EXECUTED 2001dd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2001dd8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 2001ddc: 40 00 00 82 call 2001fe4 <== NOT EXECUTED 2001de0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED the_jnode = loc.node_access; if ( !loc.ops->node_type_h ) { 2001de4: 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 ); 2001de8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED the_jnode = loc.node_access; if ( !loc.ops->node_type_h ) { 2001dec: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 <== NOT EXECUTED 2001df0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001df4: 12 80 00 0e bne 2001e2c <== NOT EXECUTED 2001df8: e2 07 bf e8 ld [ %fp + -24 ], %l1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2001dfc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2001e00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001e04: 02 80 00 04 be 2001e14 <== NOT EXECUTED 2001e08: 01 00 00 00 nop <== NOT EXECUTED 2001e0c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001e10: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2001e14: 40 00 31 73 call 200e3e0 <__errno> <== NOT EXECUTED 2001e18: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2001e1c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2001e20: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2001e24: 81 c7 e0 08 ret <== NOT EXECUTED 2001e28: 81 e8 00 00 restore <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); 2001e2c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001e30: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 2001e34: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2001e38: 12 80 00 05 bne 2001e4c <== NOT EXECUTED 2001e3c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2001e40: 80 a2 20 02 cmp %o0, 2 <== NOT EXECUTED 2001e44: 22 80 00 0d be,a 2001e78 <== NOT EXECUTED 2001e48: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2001e4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001e50: 02 80 00 1c be 2001ec0 <== NOT EXECUTED 2001e54: 01 00 00 00 nop <== NOT EXECUTED 2001e58: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2001e5c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001e60: 02 80 00 18 be 2001ec0 <== NOT EXECUTED 2001e64: 01 00 00 00 nop <== NOT EXECUTED 2001e68: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001e6c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED device_info->device_name = (char *) name; device_info->device_name_length = strlen( name ); device_info->major = the_jnode->info.device.major; device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); 2001e70: 81 c7 e0 08 ret <== NOT EXECUTED 2001e74: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; device_info->device_name_length = strlen( name ); 2001e78: 40 00 36 38 call 200f758 <== NOT EXECUTED 2001e7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2001e80: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 2001e84: c2 04 60 4c ld [ %l1 + 0x4c ], %g1 <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); 2001e88: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; device_info->device_name_length = strlen( name ); device_info->major = the_jnode->info.device.major; 2001e8c: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 2001e90: c2 04 60 50 ld [ %l1 + 0x50 ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2001e94: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2001e98: 02 80 00 0c be 2001ec8 <== NOT EXECUTED 2001e9c: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED 2001ea0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2001ea4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001ea8: 02 80 00 08 be 2001ec8 <== NOT EXECUTED 2001eac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2001eb0: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001eb4: b0 10 20 00 clr %i0 <== NOT EXECUTED 2001eb8: 81 c7 e0 08 ret <== NOT EXECUTED 2001ebc: 81 e8 00 00 restore <== NOT EXECUTED 2001ec0: 81 c7 e0 08 ret <== NOT EXECUTED 2001ec4: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED 2001ec8: b0 10 20 00 clr %i0 <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 2001ecc: 81 c7 e0 08 ret <== NOT EXECUTED 2001ed0: 81 e8 00 00 restore <== NOT EXECUTED 02007624 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2007624: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2007628: 92 96 60 00 orcc %i1, 0, %o1 200762c: 02 80 00 40 be 200772c 2007630: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2007634: 02 80 00 41 be 2007738 2007638: 82 10 20 09 mov 9, %g1 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 200763c: c2 02 40 00 ld [ %o1 ], %g1 2007640: 80 a0 60 00 cmp %g1, 0 2007644: 12 80 00 07 bne 2007660 2007648: 03 00 80 74 sethi %hi(0x201d000), %g1 200764c: c2 02 60 04 ld [ %o1 + 4 ], %g1 2007650: 80 a0 60 00 cmp %g1, 0 2007654: 22 80 00 39 be,a 2007738 2007658: 82 10 20 09 mov 9, %g1 *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 200765c: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) return RTEMS_INVALID_ADDRESS; *registered_major = 0; 2007660: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007664: c8 00 60 2c ld [ %g1 + 0x2c ], %g4 2007668: 80 a6 00 04 cmp %i0, %g4 200766c: 1a 80 00 33 bcc 2007738 2007670: 82 10 20 0a mov 0xa, %g1 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2007674: 80 a6 20 00 cmp %i0, 0 2007678: 12 80 00 18 bne 20076d8 200767c: 03 00 80 74 sethi %hi(0x201d000), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007680: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 ! 201d030 <_IO_Driver_address_table> 2007684: 85 29 20 03 sll %g4, 3, %g2 2007688: 83 29 20 05 sll %g4, 5, %g1 200768c: b0 01 3f ff add %g4, -1, %i0 2007690: 82 20 40 02 sub %g1, %g2, %g1 2007694: 82 00 7f e8 add %g1, -24, %g1 2007698: 10 80 00 0b b 20076c4 200769c: 84 00 40 03 add %g1, %g3, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 20076a0: 80 a0 60 00 cmp %g1, 0 20076a4: 32 80 00 07 bne,a 20076c0 20076a8: b0 06 3f ff add %i0, -1, %i0 20076ac: c2 00 a0 04 ld [ %g2 + 4 ], %g1 20076b0: 80 a0 60 00 cmp %g1, 0 20076b4: 02 80 00 09 be 20076d8 20076b8: 03 00 80 74 sethi %hi(0x201d000), %g1 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 20076bc: b0 06 3f ff add %i0, -1, %i0 <== NOT EXECUTED 20076c0: 84 00 bf e8 add %g2, -24, %g2 20076c4: 80 a6 20 00 cmp %i0, 0 20076c8: 32 bf ff f6 bne,a 20076a0 20076cc: c2 00 80 00 ld [ %g2 ], %g1 20076d0: 10 80 00 1a b 2007738 20076d4: 82 10 20 05 mov 5, %g1 if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 20076d8: c6 00 60 30 ld [ %g1 + 0x30 ], %g3 20076dc: 85 2e 20 03 sll %i0, 3, %g2 20076e0: 83 2e 20 05 sll %i0, 5, %g1 20076e4: 82 20 40 02 sub %g1, %g2, %g1 20076e8: c4 00 40 03 ld [ %g1 + %g3 ], %g2 20076ec: 80 a0 a0 00 cmp %g2, 0 20076f0: 12 80 00 11 bne 2007734 20076f4: 90 00 40 03 add %g1, %g3, %o0 20076f8: c2 02 20 04 ld [ %o0 + 4 ], %g1 20076fc: 80 a0 60 00 cmp %g1, 0 2007700: 32 80 00 0e bne,a 2007738 2007704: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007708: 40 00 20 cc call 200fa38 200770c: 94 10 20 18 mov 0x18, %o2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007710: 90 10 00 18 mov %i0, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 2007714: f0 26 80 00 st %i0, [ %i2 ] rtems_io_initialize( major, 0, NULL ); 2007718: 92 10 20 00 clr %o1 200771c: 7f ff ff 52 call 2007464 2007720: 94 10 20 00 clr %o2 2007724: 10 80 00 05 b 2007738 2007728: 82 10 20 00 clr %g1 return RTEMS_SUCCESSFUL; 200772c: 10 80 00 03 b 2007738 2007730: 82 10 20 09 mov 9, %g1 2007734: 82 10 20 0c mov 0xc, %g1 } 2007738: 81 c7 e0 08 ret 200773c: 91 e8 00 01 restore %g0, %g1, %o0 02008c88 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 2008c88: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 2008c8c: 80 a6 20 00 cmp %i0, 0 2008c90: 02 80 00 1d be 2008d04 2008c94: 03 00 80 95 sethi %hi(0x2025400), %g1 return; 2008c98: a4 10 62 64 or %g1, 0x264, %l2 ! 2025664 <_Objects_Information_table+0x4> for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008c9c: a6 04 a0 10 add %l2, 0x10, %l3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2008ca0: c2 04 80 00 ld [ %l2 ], %g1 2008ca4: 80 a0 60 00 cmp %g1, 0 2008ca8: 22 80 00 14 be,a 2008cf8 2008cac: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2008cb0: e0 00 60 04 ld [ %g1 + 4 ], %l0 if ( information ) { 2008cb4: 80 a4 20 00 cmp %l0, 0 2008cb8: 12 80 00 0b bne 2008ce4 2008cbc: a2 10 20 01 mov 1, %l1 for ( i=1 ; i <= information->maximum ; i++ ) { 2008cc0: 10 80 00 0e b 2008cf8 <== NOT EXECUTED 2008cc4: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 2008cc8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2008ccc: d0 00 40 08 ld [ %g1 + %o0 ], %o0 if ( !the_thread ) 2008cd0: 80 a2 20 00 cmp %o0, 0 2008cd4: 02 80 00 04 be 2008ce4 2008cd8: a2 04 60 01 inc %l1 continue; (*routine)(the_thread); 2008cdc: 9f c6 00 00 call %i0 2008ce0: 01 00 00 00 nop api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2008ce4: c2 14 20 10 lduh [ %l0 + 0x10 ], %g1 2008ce8: 80 a4 40 01 cmp %l1, %g1 2008cec: 08 bf ff f7 bleu 2008cc8 2008cf0: 91 2c 60 02 sll %l1, 2, %o0 2008cf4: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2008cf8: 80 a4 80 13 cmp %l2, %l3 2008cfc: 32 bf ff ea bne,a 2008ca4 2008d00: c2 04 80 00 ld [ %l2 ], %g1 2008d04: 81 c7 e0 08 ret 2008d08: 81 e8 00 00 restore 0200bbf8 : * 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 ) { 200bbf8: 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 ); 200bbfc: 03 00 80 62 sethi %hi(0x2018800), %g1 200bc00: d0 00 61 28 ld [ %g1 + 0x128 ], %o0 ! 2018928 200bc04: 92 10 20 00 clr %o1 200bc08: 7f ff e7 5a call 2005970 200bc0c: 94 10 20 00 clr %o2 if (rtems_libio_iop_freelist) { 200bc10: 23 00 80 62 sethi %hi(0x2018800), %l1 200bc14: c4 04 61 24 ld [ %l1 + 0x124 ], %g2 ! 2018924 200bc18: 80 a0 a0 00 cmp %g2, 0 200bc1c: 02 80 00 28 be 200bcbc 200bc20: b0 10 20 00 clr %i0 rc = rtems_semaphore_create( 200bc24: 03 00 80 62 sethi %hi(0x2018800), %g1 200bc28: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 200bc2c: 92 10 20 01 mov 1, %o1 200bc30: 86 20 80 03 sub %g2, %g3, %g3 200bc34: 87 38 e0 02 sra %g3, 2, %g3 200bc38: 83 28 e0 02 sll %g3, 2, %g1 200bc3c: 85 28 e0 06 sll %g3, 6, %g2 200bc40: 84 20 80 01 sub %g2, %g1, %g2 200bc44: 83 28 a0 06 sll %g2, 6, %g1 200bc48: 82 20 40 02 sub %g1, %g2, %g1 200bc4c: 85 28 60 0c sll %g1, 0xc, %g2 200bc50: 82 00 40 02 add %g1, %g2, %g1 200bc54: 82 00 40 03 add %g1, %g3, %g1 200bc58: 83 28 60 04 sll %g1, 4, %g1 200bc5c: 82 20 40 03 sub %g1, %g3, %g1 200bc60: 83 28 60 02 sll %g1, 2, %g1 200bc64: 86 20 c0 01 sub %g3, %g1, %g3 200bc68: 94 10 20 54 mov 0x54, %o2 200bc6c: 96 10 20 00 clr %o3 200bc70: 11 13 10 92 sethi %hi(0x4c424800), %o0 200bc74: 98 07 bf f4 add %fp, -12, %o4 200bc78: 90 12 21 00 or %o0, 0x100, %o0 200bc7c: 7f ff e6 63 call 2005608 200bc80: 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) 200bc84: 80 a2 20 00 cmp %o0, 0 200bc88: 32 80 00 0d bne,a 200bcbc 200bc8c: b0 10 20 00 clr %i0 <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 200bc90: f0 04 61 24 ld [ %l1 + 0x124 ], %i0 next = iop->data1; (void) memset( iop, 0, sizeof(rtems_libio_t) ); 200bc94: 92 10 20 00 clr %o1 &sema ); if (rc != RTEMS_SUCCESSFUL) goto failed; iop = rtems_libio_iop_freelist; next = iop->data1; 200bc98: e0 06 20 28 ld [ %i0 + 0x28 ], %l0 (void) memset( iop, 0, sizeof(rtems_libio_t) ); 200bc9c: 90 10 00 18 mov %i0, %o0 200bca0: 40 00 0b d2 call 200ebe8 200bca4: 94 10 20 34 mov 0x34, %o2 iop->flags = LIBIO_FLAGS_OPEN; iop->sem = sema; 200bca8: c2 07 bf f4 ld [ %fp + -12 ], %g1 rtems_libio_iop_freelist = next; 200bcac: e0 24 61 24 st %l0, [ %l1 + 0x124 ] 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; 200bcb0: c2 26 20 20 st %g1, [ %i0 + 0x20 ] if (rc != RTEMS_SUCCESSFUL) goto failed; iop = rtems_libio_iop_freelist; next = iop->data1; (void) memset( iop, 0, sizeof(rtems_libio_t) ); iop->flags = LIBIO_FLAGS_OPEN; 200bcb4: 82 10 21 00 mov 0x100, %g1 200bcb8: c2 26 20 0c st %g1, [ %i0 + 0xc ] failed: iop = 0; done: rtems_semaphore_release( rtems_libio_semaphore ); 200bcbc: 03 00 80 62 sethi %hi(0x2018800), %g1 200bcc0: 7f ff e7 f3 call 2005c8c 200bcc4: d0 00 61 28 ld [ %g1 + 0x128 ], %o0 ! 2018928 return iop; } 200bcc8: 81 c7 e0 08 ret 200bccc: 81 e8 00 00 restore 02002128 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 2002128: 9d e3 bf 98 save %sp, -104, %sp rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 200212c: 23 00 80 5d sethi %hi(0x2017400), %l1 2002130: d0 04 63 9c ld [ %l1 + 0x39c ], %o0 ! 201779c 2002134: 80 a2 20 00 cmp %o0, 0 2002138: 22 80 00 1e be,a 20021b0 200213c: 11 13 10 92 sethi %hi(0x4c424800), %o0 <== NOT EXECUTED { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 2002140: 92 10 20 34 mov 0x34, %o1 2002144: 40 00 00 ec call 20024f4 2002148: 21 00 80 62 sethi %hi(0x2018800), %l0 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 200214c: 80 a2 20 00 cmp %o0, 0 2002150: 12 80 00 04 bne 2002160 2002154: d0 24 21 20 st %o0, [ %l0 + 0x120 ] rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 2002158: 40 00 11 04 call 2006568 <== NOT EXECUTED 200215c: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED iop = rtems_libio_iop_freelist = rtems_libio_iops; 2002160: c8 04 21 20 ld [ %l0 + 0x120 ], %g4 for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 2002164: c6 04 63 9c ld [ %l1 + 0x39c ], %g3 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; 2002168: 03 00 80 62 sethi %hi(0x2018800), %g1 for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 200216c: 84 10 20 00 clr %g2 rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 2002170: c8 20 61 24 st %g4, [ %g1 + 0x124 ] for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 2002174: 10 80 00 03 b 2002180 2002178: 82 10 00 04 mov %g4, %g1 iop->data1 = iop + 1; 200217c: c2 20 7f f4 st %g1, [ %g1 + -12 ] 2002180: 84 00 a0 01 inc %g2 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++) 2002184: 80 a0 80 03 cmp %g2, %g3 2002188: 12 bf ff fd bne 200217c 200218c: 82 00 60 34 add %g1, 0x34, %g1 iop->data1 = iop + 1; iop->data1 = NULL; 2002190: 85 28 e0 02 sll %g3, 2, %g2 2002194: 83 28 e0 04 sll %g3, 4, %g1 2002198: 82 20 40 02 sub %g1, %g2, %g1 200219c: 82 00 40 03 add %g1, %g3, %g1 20021a0: 83 28 60 02 sll %g1, 2, %g1 20021a4: 82 00 40 04 add %g1, %g4, %g1 20021a8: c0 20 7f f4 clr [ %g1 + -12 ] /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 20021ac: 11 13 10 92 sethi %hi(0x4c424800), %o0 20021b0: 92 10 20 01 mov 1, %o1 20021b4: 90 12 21 4f or %o0, 0x14f, %o0 20021b8: 94 10 20 54 mov 0x54, %o2 20021bc: 96 10 20 00 clr %o3 20021c0: 19 00 80 62 sethi %hi(0x2018800), %o4 20021c4: 40 00 0d 11 call 2005608 20021c8: 98 13 21 28 or %o4, 0x128, %o4 ! 2018928 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 20021cc: 80 a2 20 00 cmp %o0, 0 20021d0: 02 80 00 04 be 20021e0 20021d4: 01 00 00 00 nop rtems_fatal_error_occurred( rc ); 20021d8: 40 00 10 e4 call 2006568 <== NOT EXECUTED 20021dc: 01 00 00 00 nop <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 20021e0: 40 00 25 3e call 200b6d8 20021e4: 81 e8 00 00 restore 20021e8: 01 00 00 00 nop 0201677c : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 201677c: 9d e3 bf 80 save %sp, -128, %sp rtems_status_code sc; rtems_id task_id; rtems_filesystem_location_info_t loc; sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 2016780: 90 10 20 00 clr %o0 2016784: 92 10 20 00 clr %o1 2016788: 40 00 03 ae call 2017640 201678c: 94 07 bf f4 add %fp, -12, %o2 if (sc != RTEMS_SUCCESSFUL) return sc; 2016790: b0 92 20 00 orcc %o0, 0, %i0 2016794: 12 80 00 19 bne 20167f8 2016798: 25 00 80 dd sethi %hi(0x2037400), %l2 /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 201679c: c4 04 a3 10 ld [ %l2 + 0x310 ], %g2 ! 2037710 20167a0: 03 00 80 e8 sethi %hi(0x203a000), %g1 20167a4: 82 10 61 94 or %g1, 0x194, %g1 ! 203a194 20167a8: 80 a0 80 01 cmp %g2, %g1 20167ac: 12 80 00 15 bne 2016800 20167b0: a2 14 a3 10 or %l2, 0x310, %l1 rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 20167b4: 7f ff b6 bf call 20042b0 20167b8: 90 10 20 40 mov 0x40, %o0 if (!tmp) 20167bc: a0 92 20 00 orcc %o0, 0, %l0 20167c0: 12 80 00 04 bne 20167d0 20167c4: 92 10 00 11 mov %l1, %o1 20167c8: 81 c7 e0 08 ret <== NOT EXECUTED 20167cc: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT tmp->refcnt = 1; #endif sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env); 20167d0: 90 10 20 00 clr %o0 20167d4: 15 00 80 59 sethi %hi(0x2016400), %o2 20167d8: 40 00 04 b2 call 2017aa0 20167dc: 94 12 a2 58 or %o2, 0x258, %o2 ! 2016658 if (sc != RTEMS_SUCCESSFUL) { 20167e0: a2 92 20 00 orcc %o0, 0, %l1 20167e4: 22 80 00 07 be,a 2016800 20167e8: e0 24 a3 10 st %l0, [ %l2 + 0x310 ] /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 20167ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20167f0: 7f ff b6 88 call 2004210 <== NOT EXECUTED 20167f4: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED 20167f8: 81 c7 e0 08 ret <== NOT EXECUTED 20167fc: 81 e8 00 00 restore <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 2016800: 23 00 80 dd sethi %hi(0x2037400), %l1 2016804: d0 04 63 10 ld [ %l1 + 0x310 ], %o0 ! 2037710 2016808: 94 10 20 40 mov 0x40, %o2 201680c: 13 00 80 e8 sethi %hi(0x203a000), %o1 2016810: 40 00 34 0f call 202384c 2016814: 92 12 61 94 or %o1, 0x194, %o1 ! 203a194 rtems_current_user_env->task_id=task_id; /* mark the local values*/ /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2016818: 03 00 80 e6 sethi %hi(0x2039800), %g1 } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ 201681c: d0 04 63 10 ld [ %l1 + 0x310 ], %o0 /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2016820: d2 00 61 a4 ld [ %g1 + 0x1a4 ], %o1 } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ 2016824: c2 07 bf f4 ld [ %fp + -12 ], %g1 /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2016828: 92 02 60 18 add %o1, 0x18, %o1 } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ 201682c: c2 22 00 00 st %g1, [ %o0 ] /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2016830: 94 10 20 10 mov 0x10, %o2 2016834: 40 00 34 06 call 202384c 2016838: 90 02 20 14 add %o0, 0x14, %o0 * code we must _not_ free the original locs because * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 201683c: a0 07 bf e4 add %fp, -28, %l0 2016840: 96 10 20 00 clr %o3 2016844: 25 00 80 ce sethi %hi(0x2033800), %l2 2016848: 92 10 20 00 clr %o1 201684c: 94 10 00 10 mov %l0, %o2 2016850: 7f ff b5 11 call 2003c94 2016854: 90 14 a1 a8 or %l2, 0x1a8, %o0 rtems_filesystem_root = loc; 2016858: d0 04 63 10 ld [ %l1 + 0x310 ], %o0 201685c: 92 10 00 10 mov %l0, %o1 2016860: 94 10 20 10 mov 0x10, %o2 2016864: 40 00 33 fa call 202384c 2016868: 90 02 20 14 add %o0, 0x14, %o0 rtems_filesystem_evaluate_path("/", 0, &loc, 0); 201686c: 92 10 20 00 clr %o1 2016870: 94 10 00 10 mov %l0, %o2 2016874: 90 14 a1 a8 or %l2, 0x1a8, %o0 2016878: 7f ff b5 07 call 2003c94 201687c: 96 10 20 00 clr %o3 rtems_filesystem_current = loc; 2016880: d0 04 63 10 ld [ %l1 + 0x310 ], %o0 2016884: 92 10 00 10 mov %l0, %o1 2016888: 90 02 20 04 add %o0, 4, %o0 201688c: 40 00 33 f0 call 202384c 2016890: 94 10 20 10 mov 0x10, %o2 return RTEMS_SUCCESSFUL; } 2016894: 81 c7 e0 08 ret 2016898: 81 e8 00 00 restore 020166d0 : * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ #ifndef HAVE_USERENV_REFCNT rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 20166d0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED rtems_status_code sc; rtems_user_env_t * shared_user_env; rtems_id current_task_id; sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id); 20166d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20166d8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20166dc: 40 00 03 d9 call 2017640 <== NOT EXECUTED 20166e0: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 20166e4: 86 92 20 00 orcc %o0, 0, %g3 <== NOT EXECUTED 20166e8: 12 80 00 23 bne 2016774 <== NOT EXECUTED 20166ec: 25 00 80 dd sethi %hi(0x2037400), %l2 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 20166f0: e0 04 a3 10 ld [ %l2 + 0x310 ], %l0 ! 2037710 <== NOT EXECUTED 20166f4: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 20166f8: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED 20166fc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2016700: 12 80 00 09 bne 2016724 <== NOT EXECUTED 2016704: a2 14 a3 10 or %l2, 0x310, %l1 <== NOT EXECUTED /* kill the current user env & task_var*/ rtems_user_env_t *tmp = rtems_current_user_env; sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env); 2016708: 40 00 05 42 call 2017c10 <== NOT EXECUTED 201670c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 2016710: 86 92 20 00 orcc %o0, 0, %g3 <== NOT EXECUTED 2016714: 12 80 00 18 bne 2016774 <== NOT EXECUTED 2016718: 01 00 00 00 nop <== NOT EXECUTED free_user_env(tmp); 201671c: 7f ff ff cf call 2016658 <== NOT EXECUTED 2016720: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED }; /* AT THIS POINT, rtems_current_user_env is DANGLING */ sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, 2016724: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2016728: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201672c: 40 00 05 a5 call 2017dc0 <== NOT EXECUTED 2016730: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 2016734: 86 92 20 00 orcc %o0, 0, %g3 <== NOT EXECUTED 2016738: 12 80 00 0c bne 2016768 <== NOT EXECUTED 201673c: 03 00 80 e8 sethi %hi(0x203a000), %g1 <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 2016740: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2016744: 15 00 80 59 sethi %hi(0x2016400), %o2 <== NOT EXECUTED 2016748: 40 00 04 d6 call 2017aa0 <== NOT EXECUTED 201674c: 94 12 a2 58 or %o2, 0x258, %o2 ! 2016658 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 2016750: 86 92 20 00 orcc %o0, 0, %g3 <== NOT EXECUTED 2016754: 12 80 00 05 bne 2016768 <== NOT EXECUTED 2016758: 03 00 80 e8 sethi %hi(0x203a000), %g1 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 201675c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2016760: 10 80 00 05 b 2016774 <== NOT EXECUTED 2016764: c2 24 a3 10 st %g1, [ %l2 + 0x310 ] <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 2016768: 05 00 80 dd sethi %hi(0x2037400), %g2 <== NOT EXECUTED 201676c: 82 10 61 94 or %g1, 0x194, %g1 <== NOT EXECUTED 2016770: c2 20 a3 10 st %g1, [ %g2 + 0x310 ] <== NOT EXECUTED return sc; } 2016774: 81 c7 e0 08 ret <== NOT EXECUTED 2016778: 91 e8 00 03 restore %g0, %g3, %o0 <== NOT EXECUTED 0200ba4c : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 200ba4c: 84 10 00 08 mov %o0, %g2 uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 200ba50: 82 08 a0 06 and %g2, 6, %g1 200ba54: 80 a0 60 06 cmp %g1, 6 200ba58: 02 80 00 07 be 200ba74 200ba5c: 90 10 20 02 mov 2, %o0 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 200ba60: 80 88 a0 02 btst 2, %g2 200ba64: 12 80 00 04 bne 200ba74 200ba68: 90 10 20 00 clr %o0 200ba6c: 83 30 a0 02 srl %g2, 2, %g1 <== NOT EXECUTED 200ba70: 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 ) { 200ba74: 80 88 a0 01 btst 1, %g2 200ba78: 02 80 00 04 be 200ba88 200ba7c: 80 88 a2 00 btst 0x200, %g2 fcntl_flags |= O_NONBLOCK; 200ba80: 03 00 00 10 sethi %hi(0x4000), %g1 200ba84: 90 12 00 01 or %o0, %g1, %o0 } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 200ba88: 32 80 00 02 bne,a 200ba90 200ba8c: 90 12 20 08 or %o0, 8, %o0 fcntl_flags |= O_APPEND; } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 200ba90: 80 88 a4 00 btst 0x400, %g2 200ba94: 32 80 00 02 bne,a 200ba9c 200ba98: 90 12 22 00 or %o0, 0x200, %o0 fcntl_flags |= O_CREAT; } return fcntl_flags; } 200ba9c: 81 c3 e0 08 retl 200baa0: 01 00 00 00 nop 0200e7d4 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 200e7d4: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 200e7d8: 80 a6 60 00 cmp %i1, 0 200e7dc: 02 80 00 26 be 200e874 200e7e0: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 200e7e4: 02 80 00 24 be 200e874 200e7e8: 11 00 80 cb sethi %hi(0x2032c00), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200e7ec: 92 10 00 18 mov %i0, %o1 200e7f0: 90 12 23 e0 or %o0, 0x3e0, %o0 200e7f4: 40 00 18 af call 2014ab0 <_Objects_Get> 200e7f8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200e7fc: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e800: 80 a0 60 00 cmp %g1, 0 200e804: 02 80 00 07 be 200e820 200e808: 9a 10 00 1b mov %i3, %o5 200e80c: 80 a0 60 02 cmp %g1, 2 200e810: 08 80 00 1a bleu 200e878 200e814: 90 10 20 04 mov 4, %o0 200e818: 10 80 00 18 b 200e878 <== NOT EXECUTED 200e81c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 200e820: 92 10 00 19 mov %i1, %o1 200e824: 94 10 00 1a mov %i2, %o2 200e828: 96 10 00 18 mov %i0, %o3 200e82c: 98 10 20 00 clr %o4 200e830: 40 00 13 3d call 2013524 <_CORE_message_queue_Broadcast> 200e834: 90 02 20 14 add %o0, 0x14, %o0 200e838: b6 10 00 08 mov %o0, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e83c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200e840: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200e844: 84 00 bf ff add %g2, -1, %g2 200e848: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200e84c: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200e850: 80 a0 60 00 cmp %g1, 0 200e854: 12 80 00 04 bne 200e864 200e858: 01 00 00 00 nop _Thread_Dispatch(); 200e85c: 40 00 1d 9a call 2015ec4 <_Thread_Dispatch> 200e860: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 200e864: 40 00 01 2e call 200ed1c <_Message_queue_Translate_core_message_queue_return_code> 200e868: 90 10 00 1b mov %i3, %o0 _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e86c: 81 c7 e0 08 ret 200e870: 91 e8 00 08 restore %g0, %o0, %o0 #endif count ); _Thread_Enable_dispatch(); return 200e874: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e878: b0 10 00 08 mov %o0, %i0 200e87c: 81 c7 e0 08 ret 200e880: 81 e8 00 00 restore 0200e8b8 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200e8b8: 9d e3 bf 90 save %sp, -112, %sp CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) boolean is_global; #endif if ( !rtems_is_name_valid( name ) ) 200e8bc: a2 96 20 00 orcc %i0, 0, %l1 200e8c0: 02 80 00 17 be 200e91c 200e8c4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200e8c8: 80 a7 20 00 cmp %i4, 0 200e8cc: 02 80 00 14 be 200e91c 200e8d0: 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 ) 200e8d4: 80 a6 60 00 cmp %i1, 0 200e8d8: 02 80 00 11 be 200e91c 200e8dc: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200e8e0: 80 a6 a0 00 cmp %i2, 0 200e8e4: 02 80 00 0e be 200e91c 200e8e8: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e8ec: 05 00 80 c9 sethi %hi(0x2032400), %g2 200e8f0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200e8f4: 82 00 60 01 inc %g1 200e8f8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 200e8fc: 90 10 00 19 mov %i1, %o0 200e900: 40 00 2d 82 call 2019f08 <_Message_queue_Allocate> 200e904: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 200e908: a0 92 20 00 orcc %o0, 0, %l0 200e90c: 12 80 00 06 bne 200e924 200e910: 80 8e e0 04 btst 4, %i3 _Thread_Enable_dispatch(); 200e914: 7f ff ff dc call 200e884 <_Thread_Enable_dispatch> 200e918: b0 10 20 05 mov 5, %i0 200e91c: 81 c7 e0 08 ret 200e920: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200e924: 02 80 00 05 be 200e938 200e928: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200e92c: 82 10 20 01 mov 1, %g1 200e930: 10 80 00 03 b 200e93c 200e934: c2 27 bf f4 st %g1, [ %fp + -12 ] else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200e938: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 200e93c: 94 10 00 19 mov %i1, %o2 200e940: 96 10 00 1a mov %i2, %o3 200e944: 90 04 20 14 add %l0, 0x14, %o0 200e948: 40 00 13 43 call 2013654 <_CORE_message_queue_Initialize> 200e94c: 92 07 bf f4 add %fp, -12, %o1 200e950: 80 a2 20 00 cmp %o0, 0 200e954: 12 80 00 0a bne 200e97c 200e958: 11 00 80 cb sethi %hi(0x2032c00), %o0 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200e95c: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 2032fe0 <_Message_queue_Information> <== NOT EXECUTED 200e960: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200e964: 40 00 17 fd call 2014958 <_Objects_Free> <== NOT EXECUTED 200e968: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 200e96c: 7f ff ff c6 call 200e884 <_Thread_Enable_dispatch> <== NOT EXECUTED 200e970: 01 00 00 00 nop <== NOT EXECUTED 200e974: 81 c7 e0 08 ret <== NOT EXECUTED 200e978: 81 e8 00 00 restore <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e97c: 90 12 23 e0 or %o0, 0x3e0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200e980: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e984: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200e988: 05 00 00 3f sethi %hi(0xfc00), %g2 200e98c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e990: 82 08 40 02 and %g1, %g2, %g1 200e994: 80 a0 40 03 cmp %g1, %g3 200e998: 38 80 00 06 bgu,a 200e9b0 200e99c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200e9a0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200e9a4: 83 28 60 02 sll %g1, 2, %g1 200e9a8: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200e9ac: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200e9b0: e2 24 20 0c st %l1, [ %l0 + 0xc ] 200e9b4: c2 27 00 00 st %g1, [ %i4 ] name, 0 ); #endif _Thread_Enable_dispatch(); 200e9b8: 7f ff ff b3 call 200e884 <_Thread_Enable_dispatch> 200e9bc: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 200e9c0: 81 c7 e0 08 ret 200e9c4: 81 e8 00 00 restore 02012e20 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 2012e20: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 2012e24: 21 00 80 a1 sethi %hi(0x2028400), %l0 2012e28: 92 10 00 18 mov %i0, %o1 2012e2c: 94 07 bf f4 add %fp, -12, %o2 2012e30: 7f ff e4 7d call 200c024 <_Objects_Get> 2012e34: 90 14 20 bc or %l0, 0xbc, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012e38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012e3c: 80 a0 60 00 cmp %g1, 0 2012e40: 02 80 00 07 be 2012e5c 2012e44: b0 10 00 08 mov %o0, %i0 2012e48: 80 a0 60 02 cmp %g1, 2 2012e4c: 08 80 00 22 bleu 2012ed4 2012e50: b0 10 20 04 mov 4, %i0 2012e54: 81 c7 e0 08 ret <== NOT EXECUTED 2012e58: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012e5c: a0 14 20 bc or %l0, 0xbc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012e60: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012e64: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012e68: 05 00 00 3f sethi %hi(0xfc00), %g2 2012e6c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012e70: 82 08 40 02 and %g1, %g2, %g1 2012e74: 80 a0 40 03 cmp %g1, %g3 2012e78: 18 80 00 05 bgu 2012e8c 2012e7c: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 2012e80: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2012e84: 83 28 60 02 sll %g1, 2, %g1 2012e88: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 2012e8c: 90 06 20 14 add %i0, 0x14, %o0 uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 2012e90: c0 26 20 0c clr [ %i0 + 0xc ] 2012e94: 40 00 01 9e call 201350c <_CORE_message_queue_Close> 2012e98: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 2012e9c: 90 10 00 10 mov %l0, %o0 2012ea0: 7f ff e4 1f call 200bf1c <_Objects_Free> 2012ea4: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2012ea8: 03 00 80 9e sethi %hi(0x2027800), %g1 2012eac: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 2012eb0: b0 10 20 00 clr %i0 2012eb4: 84 00 bf ff add %g2, -1, %g2 2012eb8: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 2012ebc: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 2012ec0: 80 a0 60 00 cmp %g1, 0 2012ec4: 12 80 00 04 bne 2012ed4 2012ec8: 01 00 00 00 nop _Thread_Dispatch(); 2012ecc: 7f ff e9 5b call 200d438 <_Thread_Dispatch> 2012ed0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012ed4: 81 c7 e0 08 ret 2012ed8: 81 e8 00 00 restore 0200ea84 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200ea84: 9d e3 bf 90 save %sp, -112, %sp 200ea88: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200ea8c: 80 a6 60 00 cmp %i1, 0 200ea90: 02 80 00 1c be 200eb00 200ea94: 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 *) 200ea98: 11 00 80 cb sethi %hi(0x2032c00), %o0 200ea9c: 94 07 bf f4 add %fp, -12, %o2 200eaa0: 40 00 18 04 call 2014ab0 <_Objects_Get> 200eaa4: 90 12 23 e0 or %o0, 0x3e0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eaa8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eaac: 80 a0 60 00 cmp %g1, 0 200eab0: 02 80 00 06 be 200eac8 200eab4: 80 a0 60 02 cmp %g1, 2 200eab8: 08 80 00 12 bleu 200eb00 200eabc: b0 10 20 04 mov 4, %i0 200eac0: 81 c7 e0 08 ret <== NOT EXECUTED 200eac4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 200eac8: 40 00 12 c4 call 20135d8 <_CORE_message_queue_Flush> 200eacc: 90 02 20 14 add %o0, 0x14, %o0 200ead0: d0 26 40 00 st %o0, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ead4: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ead8: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200eadc: b0 10 20 00 clr %i0 200eae0: 84 00 bf ff add %g2, -1, %g2 200eae4: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200eae8: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200eaec: 80 a0 60 00 cmp %g1, 0 200eaf0: 12 80 00 04 bne 200eb00 200eaf4: 01 00 00 00 nop _Thread_Dispatch(); 200eaf8: 40 00 1c f3 call 2015ec4 <_Thread_Dispatch> 200eafc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eb00: 81 c7 e0 08 ret 200eb04: 81 e8 00 00 restore 0200eb08 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200eb08: 9d e3 bf 90 save %sp, -112, %sp 200eb0c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200eb10: 80 a6 60 00 cmp %i1, 0 200eb14: 02 80 00 1b be 200eb80 200eb18: b0 10 20 09 mov 9, %i0 200eb1c: 11 00 80 cb sethi %hi(0x2032c00), %o0 200eb20: 94 07 bf f4 add %fp, -12, %o2 200eb24: 40 00 17 e3 call 2014ab0 <_Objects_Get> 200eb28: 90 12 23 e0 or %o0, 0x3e0, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200eb2c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eb30: 80 a0 60 00 cmp %g1, 0 200eb34: 22 80 00 07 be,a 200eb50 200eb38: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 200eb3c: 80 a0 60 02 cmp %g1, 2 200eb40: 08 80 00 10 bleu 200eb80 200eb44: b0 10 20 04 mov 4, %i0 200eb48: 81 c7 e0 08 ret <== NOT EXECUTED 200eb4c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 200eb50: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200eb54: 05 00 80 c9 sethi %hi(0x2032400), %g2 200eb58: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200eb5c: b0 10 20 00 clr %i0 200eb60: 82 00 7f ff add %g1, -1, %g1 200eb64: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 200eb68: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200eb6c: 80 a0 60 00 cmp %g1, 0 200eb70: 12 80 00 04 bne 200eb80 200eb74: 01 00 00 00 nop _Thread_Dispatch(); 200eb78: 40 00 1c d3 call 2015ec4 <_Thread_Dispatch> 200eb7c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200eb80: 81 c7 e0 08 ret 200eb84: 81 e8 00 00 restore 02012f10 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 2012f10: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 2012f14: 80 a6 60 00 cmp %i1, 0 2012f18: 02 80 00 28 be 2012fb8 2012f1c: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 2012f20: 80 a6 a0 00 cmp %i2, 0 2012f24: 02 80 00 25 be 2012fb8 2012f28: 11 00 80 a1 sethi %hi(0x2028400), %o0 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 2012f2c: 94 07 bf f4 add %fp, -12, %o2 2012f30: 7f ff e4 3d call 200c024 <_Objects_Get> 2012f34: 90 12 20 bc or %o0, 0xbc, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2012f38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012f3c: 80 a0 60 00 cmp %g1, 0 2012f40: 22 80 00 07 be,a 2012f5c 2012f44: d2 02 20 08 ld [ %o0 + 8 ], %o1 2012f48: 80 a0 60 02 cmp %g1, 2 2012f4c: 08 80 00 1c bleu 2012fbc 2012f50: 90 10 20 04 mov 4, %o0 2012f54: 10 80 00 1a b 2012fbc <== NOT EXECUTED 2012f58: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED 2012f5c: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 2012f60: 94 10 00 19 mov %i1, %o2 2012f64: 96 10 00 1a mov %i2, %o3 2012f68: 98 1b 20 01 xor %o4, 1, %o4 2012f6c: 9a 10 00 1c mov %i4, %o5 2012f70: 40 00 01 94 call 20135c0 <_CORE_message_queue_Seize> 2012f74: 90 02 20 14 add %o0, 0x14, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2012f78: 05 00 80 9e sethi %hi(0x2027800), %g2 2012f7c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2012f80: 82 00 7f ff add %g1, -1, %g1 2012f84: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] 2012f88: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 2012f8c: 80 a0 60 00 cmp %g1, 0 2012f90: 12 80 00 05 bne 2012fa4 2012f94: 03 00 80 9e sethi %hi(0x2027800), %g1 _Thread_Dispatch(); 2012f98: 7f ff e9 28 call 200d438 <_Thread_Dispatch> 2012f9c: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012fa0: 03 00 80 9e sethi %hi(0x2027800), %g1 2012fa4: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 2027b30 <_Thread_Executing> 2012fa8: 40 00 00 32 call 2013070 <_Message_queue_Translate_core_message_queue_return_code> 2012fac: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012fb0: 81 c7 e0 08 ret 2012fb4: 91 e8 00 08 restore %g0, %o0, %o0 size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 2012fb8: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012fbc: b0 10 00 08 mov %o0, %i0 2012fc0: 81 c7 e0 08 ret 2012fc4: 81 e8 00 00 restore 02012fc8 : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 2012fc8: 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 ) 2012fcc: 80 a6 60 00 cmp %i1, 0 2012fd0: 02 80 00 26 be 2013068 2012fd4: 90 10 20 09 mov 9, %o0 2012fd8: 11 00 80 a1 sethi %hi(0x2028400), %o0 2012fdc: 92 10 00 18 mov %i0, %o1 2012fe0: 90 12 20 bc or %o0, 0xbc, %o0 2012fe4: 7f ff e4 10 call 200c024 <_Objects_Get> 2012fe8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2012fec: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012ff0: 80 a0 60 00 cmp %g1, 0 2012ff4: 22 80 00 07 be,a 2013010 2012ff8: 94 10 00 1a mov %i2, %o2 2012ffc: 80 a0 60 02 cmp %g1, 2 2013000: 08 80 00 1a bleu 2013068 2013004: 90 10 20 04 mov 4, %o0 2013008: 10 80 00 18 b 2013068 <== NOT EXECUTED 201300c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 2013010: c0 23 a0 5c clr [ %sp + 0x5c ] 2013014: c0 23 a0 60 clr [ %sp + 0x60 ] 2013018: 92 10 00 19 mov %i1, %o1 201301c: 96 10 00 18 mov %i0, %o3 2013020: 98 10 20 00 clr %o4 2013024: 90 02 20 14 add %o0, 0x14, %o0 2013028: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 201302c: 40 00 01 b2 call 20136f4 <_CORE_message_queue_Submit> 2013030: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 2013034: b4 10 00 08 mov %o0, %i2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013038: 05 00 80 9e sethi %hi(0x2027800), %g2 201303c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> 2013040: 82 00 7f ff add %g1, -1, %g1 2013044: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] 2013048: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 201304c: 80 a0 60 00 cmp %g1, 0 2013050: 12 80 00 04 bne 2013060 2013054: 01 00 00 00 nop _Thread_Dispatch(); 2013058: 7f ff e8 f8 call 200d438 <_Thread_Dispatch> 201305c: 01 00 00 00 nop /* * 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); 2013060: 40 00 00 04 call 2013070 <_Message_queue_Translate_core_message_queue_return_code> 2013064: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2013068: 81 c7 e0 08 ret 201306c: 91 e8 00 08 restore %g0, %o0, %o0 0200831c : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 200831c: 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 ) 2008320: 80 a6 60 00 cmp %i1, 0 2008324: 02 80 00 25 be 20083b8 2008328: 90 10 20 09 mov 9, %o0 200832c: 11 00 80 84 sethi %hi(0x2021000), %o0 2008330: 92 10 00 18 mov %i0, %o1 2008334: 90 12 23 c8 or %o0, 0x3c8, %o0 2008338: 40 00 0a 04 call 200ab48 <_Objects_Get> 200833c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2008340: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008344: 80 a0 60 00 cmp %g1, 0 2008348: 22 80 00 07 be,a 2008364 200834c: 94 10 00 1a mov %i2, %o2 2008350: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2008354: 08 80 00 19 bleu 20083b8 <== NOT EXECUTED 2008358: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 200835c: 10 80 00 17 b 20083b8 <== NOT EXECUTED 2008360: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 2008364: c0 23 a0 5c clr [ %sp + 0x5c ] 2008368: c0 23 a0 60 clr [ %sp + 0x60 ] 200836c: 92 10 00 19 mov %i1, %o1 2008370: 96 10 00 18 mov %i0, %o3 2008374: 98 10 20 00 clr %o4 2008378: 1b 20 00 00 sethi %hi(0x80000000), %o5 200837c: 40 00 05 ee call 2009b34 <_CORE_message_queue_Submit> 2008380: 90 02 20 14 add %o0, 0x14, %o0 2008384: b4 10 00 08 mov %o0, %i2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008388: 03 00 80 82 sethi %hi(0x2020800), %g1 200838c: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20209e0 <_Thread_Dispatch_disable_level> 2008390: 84 00 bf ff add %g2, -1, %g2 2008394: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ] 2008398: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1 200839c: 80 a0 60 00 cmp %g1, 0 20083a0: 12 80 00 04 bne 20083b0 20083a4: 01 00 00 00 nop _Thread_Dispatch(); 20083a8: 40 00 0e ed call 200bf5c <_Thread_Dispatch> 20083ac: 01 00 00 00 nop /* * 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); 20083b0: 7f ff ff d1 call 20082f4 <_Message_queue_Translate_core_message_queue_return_code> 20083b4: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20083b8: 81 c7 e0 08 ret 20083bc: 91 e8 00 08 restore %g0, %o0, %o0 020061ac : void rtems_panic( const char *printf_format, ... ) { 20061ac: 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); 20061b0: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED ... ) { va_list arglist; va_start(arglist, printf_format); 20061b4: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED void rtems_panic( const char *printf_format, ... ) { 20061b8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED 20061bc: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 20061c0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED 20061c4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED 20061c8: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED va_list arglist; va_start(arglist, printf_format); (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist); 20061cc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20061d0: 7f ff ff 8b call 2005ffc <== NOT EXECUTED 20061d4: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED va_end(arglist); } 20061d8: 81 c7 e0 08 ret <== NOT EXECUTED 20061dc: 81 e8 00 00 restore <== NOT EXECUTED 0200ed78 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200ed78: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200ed7c: a6 96 20 00 orcc %i0, 0, %l3 200ed80: 02 80 00 1e be 200edf8 200ed84: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200ed88: 80 a6 60 00 cmp %i1, 0 200ed8c: 02 80 00 3d be 200ee80 200ed90: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200ed94: 02 80 00 3b be 200ee80 200ed98: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200ed9c: 22 80 00 17 be,a 200edf8 200eda0: b0 10 20 08 mov 8, %i0 200eda4: 80 a6 e0 00 cmp %i3, 0 200eda8: 22 80 00 14 be,a 200edf8 200edac: b0 10 20 08 mov 8, %i0 200edb0: 80 a6 80 1b cmp %i2, %i3 200edb4: 0a 80 00 35 bcs 200ee88 200edb8: 80 8e e0 07 btst 7, %i3 200edbc: 12 80 00 33 bne 200ee88 200edc0: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200edc4: 12 80 00 2f bne 200ee80 200edc8: 05 00 80 c9 sethi %hi(0x2032400), %g2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200edcc: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200edd0: 82 00 60 01 inc %g1 200edd4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200edd8: 25 00 80 c8 sethi %hi(0x2032000), %l2 200eddc: 40 00 15 dd call 2014550 <_Objects_Allocate> 200ede0: 90 14 a3 74 or %l2, 0x374, %o0 ! 2032374 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200ede4: a2 92 20 00 orcc %o0, 0, %l1 200ede8: 12 80 00 06 bne 200ee00 200edec: 92 10 00 1b mov %i3, %o1 _Thread_Enable_dispatch(); 200edf0: 7f ff ff d5 call 200ed44 <_Thread_Enable_dispatch> 200edf4: b0 10 20 05 mov 5, %i0 200edf8: 81 c7 e0 08 ret 200edfc: 81 e8 00 00 restore #endif the_partition->starting_address = starting_address; the_partition->length = length; the_partition->buffer_size = buffer_size; the_partition->attribute_set = attribute_set; 200ee00: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200ee04: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200ee08: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200ee0c: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200ee10: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200ee14: 40 00 55 b9 call 20244f8 <.udiv> 200ee18: 90 10 00 1a mov %i2, %o0 200ee1c: a0 04 60 24 add %l1, 0x24, %l0 200ee20: 94 10 00 08 mov %o0, %o2 200ee24: 92 10 00 19 mov %i1, %o1 200ee28: 90 10 00 10 mov %l0, %o0 200ee2c: 40 00 11 b0 call 20134ec <_Chain_Initialize> 200ee30: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee34: 90 14 a3 74 or %l2, 0x374, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ee38: c4 04 60 08 ld [ %l1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ee3c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ee40: 03 00 00 3f sethi %hi(0xfc00), %g1 200ee44: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200ee48: 82 08 80 01 and %g2, %g1, %g1 200ee4c: 80 a0 40 03 cmp %g1, %g3 200ee50: 38 80 00 06 bgu,a 200ee68 200ee54: c2 04 60 08 ld [ %l1 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200ee58: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ee5c: 83 28 60 02 sll %g1, 2, %g1 200ee60: e2 20 80 01 st %l1, [ %g2 + %g1 ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200ee64: c2 04 60 08 ld [ %l1 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200ee68: e6 24 60 0c st %l3, [ %l1 + 0xc ] 200ee6c: c2 27 40 00 st %g1, [ %i5 ] name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 200ee70: 7f ff ff b5 call 200ed44 <_Thread_Enable_dispatch> 200ee74: b0 10 20 00 clr %i0 200ee78: 81 c7 e0 08 ret 200ee7c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200ee80: 81 c7 e0 08 ret 200ee84: 91 e8 20 09 restore %g0, 9, %o0 200ee88: b0 10 20 08 mov 8, %i0 } 200ee8c: 81 c7 e0 08 ret 200ee90: 81 e8 00 00 restore 0200eec8 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 200eec8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200eecc: 92 10 00 18 mov %i0, %o1 200eed0: 94 07 bf f4 add %fp, -12, %o2 200eed4: 31 00 80 c8 sethi %hi(0x2032000), %i0 200eed8: 40 00 16 f6 call 2014ab0 <_Objects_Get> 200eedc: 90 16 23 74 or %i0, 0x374, %o0 ! 2032374 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200eee0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200eee4: 80 a0 60 00 cmp %g1, 0 200eee8: 02 80 00 07 be 200ef04 200eeec: 88 10 00 08 mov %o0, %g4 200eef0: 80 a0 60 02 cmp %g1, 2 200eef4: 08 80 00 18 bleu 200ef54 200eef8: b0 10 20 04 mov 4, %i0 200eefc: 81 c7 e0 08 ret <== NOT EXECUTED 200ef00: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 200ef04: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 200ef08: 80 a0 60 00 cmp %g1, 0 200ef0c: 12 80 00 14 bne 200ef5c 200ef10: 90 16 23 74 or %i0, 0x374, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200ef14: c2 01 20 08 ld [ %g4 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ef18: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200ef1c: 05 00 00 3f sethi %hi(0xfc00), %g2 200ef20: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200ef24: 82 08 40 02 and %g1, %g2, %g1 200ef28: 80 a0 40 03 cmp %g1, %g3 200ef2c: 18 80 00 05 bgu 200ef40 200ef30: 92 10 00 04 mov %g4, %o1 information->local_table[ index ] = the_object; 200ef34: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ef38: 83 28 60 02 sll %g1, 2, %g1 200ef3c: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200ef40: c0 21 20 0c clr [ %g4 + 0xc ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 200ef44: 40 00 16 85 call 2014958 <_Objects_Free> 200ef48: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 200ef4c: 7f ff ff d2 call 200ee94 <_Thread_Enable_dispatch> 200ef50: 01 00 00 00 nop 200ef54: 81 c7 e0 08 ret 200ef58: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200ef5c: 7f ff ff ce call 200ee94 <_Thread_Enable_dispatch> 200ef60: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ef64: 81 c7 e0 08 ret 200ef68: 81 e8 00 00 restore 0200efa0 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200efa0: 9d e3 bf 90 save %sp, -112, %sp 200efa4: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200efa8: 80 a6 60 00 cmp %i1, 0 200efac: 02 80 00 1a be 200f014 200efb0: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200efb4: 11 00 80 c8 sethi %hi(0x2032000), %o0 200efb8: 94 07 bf f4 add %fp, -12, %o2 200efbc: 40 00 16 bd call 2014ab0 <_Objects_Get> 200efc0: 90 12 23 74 or %o0, 0x374, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200efc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200efc8: 80 a0 60 00 cmp %g1, 0 200efcc: 02 80 00 07 be 200efe8 200efd0: b0 10 00 08 mov %o0, %i0 200efd4: 80 a0 60 02 cmp %g1, 2 200efd8: 08 80 00 0f bleu 200f014 200efdc: b0 10 20 04 mov 4, %i0 200efe0: 81 c7 e0 08 ret <== NOT EXECUTED 200efe4: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 200efe8: 40 00 11 31 call 20134ac <_Chain_Get> 200efec: 90 02 20 24 add %o0, 0x24, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 200eff0: a0 92 20 00 orcc %o0, 0, %l0 200eff4: 02 80 00 0a be 200f01c 200eff8: 01 00 00 00 nop the_partition->number_of_used_blocks += 1; 200effc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f000: 82 00 60 01 inc %g1 200f004: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200f008: 7f ff ff d9 call 200ef6c <_Thread_Enable_dispatch> 200f00c: b0 10 20 00 clr %i0 *buffer = the_buffer; 200f010: e0 26 40 00 st %l0, [ %i1 ] 200f014: 81 c7 e0 08 ret 200f018: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f01c: 7f ff ff d4 call 200ef6c <_Thread_Enable_dispatch> 200f020: b0 10 20 0d mov 0xd, %i0 return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f024: 81 c7 e0 08 ret 200f028: 81 e8 00 00 restore 0200f094 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 200f094: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f098: 11 00 80 c8 sethi %hi(0x2032000), %o0 200f09c: 92 10 00 18 mov %i0, %o1 200f0a0: 90 12 23 74 or %o0, 0x374, %o0 200f0a4: 40 00 16 83 call 2014ab0 <_Objects_Get> 200f0a8: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f0ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f0b0: 80 a0 60 00 cmp %g1, 0 200f0b4: 02 80 00 07 be 200f0d0 200f0b8: b0 10 00 08 mov %o0, %i0 200f0bc: 80 a0 60 02 cmp %g1, 2 200f0c0: 08 80 00 1a bleu 200f128 200f0c4: b0 10 20 04 mov 4, %i0 200f0c8: 81 c7 e0 08 ret <== NOT EXECUTED 200f0cc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { void *starting; void *ending; starting = the_partition->starting_address; 200f0d0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 200f0d4: 80 a6 40 02 cmp %i1, %g2 200f0d8: 0a 80 00 16 bcs 200f130 200f0dc: 01 00 00 00 nop 200f0e0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200f0e4: 82 00 80 01 add %g2, %g1, %g1 200f0e8: 80 a6 40 01 cmp %i1, %g1 200f0ec: 18 80 00 11 bgu 200f130 200f0f0: 01 00 00 00 nop 200f0f4: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 200f0f8: 40 00 55 ac call 20247a8 <.urem> 200f0fc: 90 26 40 02 sub %i1, %g2, %o0 200f100: 80 a2 20 00 cmp %o0, 0 200f104: 12 80 00 0b bne 200f130 200f108: 90 06 20 24 add %i0, 0x24, %o0 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 200f10c: 40 00 10 dc call 201347c <_Chain_Append> 200f110: 92 10 00 19 mov %i1, %o1 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 200f114: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f118: 82 00 7f ff add %g1, -1, %g1 200f11c: c2 26 20 20 st %g1, [ %i0 + 0x20 ] _Thread_Enable_dispatch(); 200f120: 7f ff ff d0 call 200f060 <_Thread_Enable_dispatch> 200f124: b0 10 20 00 clr %i0 200f128: 81 c7 e0 08 ret 200f12c: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 200f130: 7f ff ff cc call 200f060 <_Thread_Enable_dispatch> 200f134: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f138: 81 c7 e0 08 ret 200f13c: 81 e8 00 00 restore 0200df3c : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 200df3c: 9d e3 bf 98 save %sp, -104, %sp register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 200df40: a2 96 20 00 orcc %i0, 0, %l1 200df44: 02 80 00 15 be 200df98 200df48: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200df4c: 80 a7 20 00 cmp %i4, 0 200df50: 02 80 00 29 be 200dff4 200df54: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 200df58: 12 80 00 27 bne 200dff4 200df5c: 80 8e a0 07 btst 7, %i2 200df60: 32 80 00 0e bne,a 200df98 200df64: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200df68: 05 00 80 c9 sethi %hi(0x2032400), %g2 200df6c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200df70: 82 00 60 01 inc %g1 200df74: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) 200df78: 21 00 80 c8 sethi %hi(0x2032000), %l0 200df7c: 40 00 19 75 call 2014550 <_Objects_Allocate> 200df80: 90 14 23 28 or %l0, 0x328, %o0 ! 2032328 <_Dual_ported_memory_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 200df84: 80 a2 20 00 cmp %o0, 0 200df88: 12 80 00 06 bne 200dfa0 200df8c: 88 14 23 28 or %l0, 0x328, %g4 _Thread_Enable_dispatch(); 200df90: 7f ff ff de call 200df08 <_Thread_Enable_dispatch> 200df94: b0 10 20 05 mov 5, %i0 200df98: 81 c7 e0 08 ret 200df9c: 81 e8 00 00 restore ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200dfa0: c4 02 20 08 ld [ %o0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dfa4: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; the_port->external_base = external_start; the_port->length = length - 1; 200dfa8: 82 06 ff ff add %i3, -1, %g1 if ( !the_port ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 200dfac: f2 22 20 10 st %i1, [ %o0 + 0x10 ] the_port->external_base = external_start; the_port->length = length - 1; 200dfb0: c2 22 20 18 st %g1, [ %o0 + 0x18 ] 200dfb4: 03 00 00 3f sethi %hi(0xfc00), %g1 200dfb8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200dfbc: 82 08 80 01 and %g2, %g1, %g1 200dfc0: 80 a0 40 03 cmp %g1, %g3 200dfc4: 18 80 00 05 bgu 200dfd8 200dfc8: f4 22 20 14 st %i2, [ %o0 + 0x14 ] information->local_table[ index ] = the_object; 200dfcc: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200dfd0: 83 28 60 02 sll %g1, 2, %g1 200dfd4: d0 20 80 01 st %o0, [ %g2 + %g1 ] &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 200dfd8: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200dfdc: e2 22 20 0c st %l1, [ %o0 + 0xc ] 200dfe0: c2 27 00 00 st %g1, [ %i4 ] _Thread_Enable_dispatch(); 200dfe4: 7f ff ff c9 call 200df08 <_Thread_Enable_dispatch> 200dfe8: b0 10 20 00 clr %i0 200dfec: 81 c7 e0 08 ret 200dff0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200dff4: b0 10 20 09 mov 9, %i0 } 200dff8: 81 c7 e0 08 ret 200dffc: 81 e8 00 00 restore 02006444 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 2006444: 9d e3 bf 98 save %sp, -104, %sp Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 2006448: a4 96 20 00 orcc %i0, 0, %l2 200644c: 02 80 00 11 be 2006490 2006450: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2006454: 80 a6 60 00 cmp %i1, 0 2006458: 02 80 00 0e be 2006490 200645c: b0 10 20 09 mov 9, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006460: 05 00 80 76 sethi %hi(0x201d800), %g2 2006464: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006468: 82 00 60 01 inc %g1 200646c: c2 20 a0 e0 st %g1, [ %g2 + 0xe0 ] * the inactive chain of free period control blocks. */ RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Allocate( void ) { return (Rate_monotonic_Control *) 2006470: 23 00 80 75 sethi %hi(0x201d400), %l1 2006474: 40 00 09 de call 2008bec <_Objects_Allocate> 2006478: 90 14 63 44 or %l1, 0x344, %o0 ! 201d744 <_Rate_monotonic_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 200647c: a0 92 20 00 orcc %o0, 0, %l0 2006480: 12 80 00 06 bne 2006498 2006484: 03 00 80 76 sethi %hi(0x201d800), %g1 _Thread_Enable_dispatch(); 2006488: 7f ff ff e2 call 2006410 <_Thread_Enable_dispatch> 200648c: b0 10 20 05 mov 5, %i0 2006490: 81 c7 e0 08 ret 2006494: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 2006498: c2 00 61 c0 ld [ %g1 + 0x1c0 ], %g1 the_period->state = RATE_MONOTONIC_INACTIVE; 200649c: c0 24 20 38 clr [ %l0 + 0x38 ] if ( !the_period ) { _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 20064a0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20064a4: c0 24 20 18 clr [ %l0 + 0x18 ] the_watchdog->routine = routine; 20064a8: c0 24 20 2c clr [ %l0 + 0x2c ] the_watchdog->id = id; 20064ac: c0 24 20 30 clr [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20064b0: c0 24 20 34 clr [ %l0 + 0x34 ] the_period->state = RATE_MONOTONIC_INACTIVE; _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 20064b4: 90 04 20 54 add %l0, 0x54, %o0 20064b8: 92 10 20 00 clr %o1 20064bc: 40 00 28 cd call 20107f0 20064c0: 94 10 20 38 mov 0x38, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064c4: 90 14 63 44 or %l1, 0x344, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20064c8: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20064cc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20064d0: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 20064d4: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 20064d8: c2 24 20 78 st %g1, [ %l0 + 0x78 ] 20064dc: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 20064e0: c2 24 20 60 st %g1, [ %l0 + 0x60 ] 20064e4: c2 24 20 74 st %g1, [ %l0 + 0x74 ] 20064e8: 03 00 00 3f sethi %hi(0xfc00), %g1 20064ec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20064f0: 82 08 80 01 and %g2, %g1, %g1 20064f4: 80 a0 40 03 cmp %g1, %g3 20064f8: 38 80 00 06 bgu,a 2006510 20064fc: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 2006500: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006504: 83 28 60 02 sll %g1, 2, %g1 2006508: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 200650c: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 2006510: e4 24 20 0c st %l2, [ %l0 + 0xc ] 2006514: c2 26 40 00 st %g1, [ %i1 ] _Thread_Enable_dispatch(); 2006518: 7f ff ff be call 2006410 <_Thread_Enable_dispatch> 200651c: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2006520: 81 c7 e0 08 ret 2006524: 81 e8 00 00 restore 0200f310 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 200f310: 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 *) 200f314: 21 00 80 c8 sethi %hi(0x2032000), %l0 200f318: 92 10 00 18 mov %i0, %o1 200f31c: 94 07 bf f4 add %fp, -12, %o2 200f320: 40 00 15 e4 call 2014ab0 <_Objects_Get> 200f324: 90 14 23 c0 or %l0, 0x3c0, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f328: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f32c: 80 a0 60 00 cmp %g1, 0 200f330: 02 80 00 08 be 200f350 200f334: b0 10 00 08 mov %o0, %i0 200f338: 82 18 60 02 xor %g1, 2, %g1 200f33c: 80 a0 00 01 cmp %g0, %g1 200f340: 82 60 20 00 subx %g0, 0, %g1 200f344: b0 08 60 15 and %g1, 0x15, %i0 200f348: 81 c7 e0 08 ret 200f34c: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f350: a0 14 23 c0 or %l0, 0x3c0, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200f354: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f358: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 200f35c: 05 00 00 3f sethi %hi(0xfc00), %g2 200f360: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200f364: 82 08 40 02 and %g1, %g2, %g1 200f368: 80 a0 40 03 cmp %g1, %g3 200f36c: 38 80 00 06 bgu,a 200f384 200f370: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f374: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 200f378: 83 28 60 02 sll %g1, 2, %g1 200f37c: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200f380: c0 26 20 0c clr [ %i0 + 0xc ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); (void) _Watchdog_Remove( &the_period->Timer ); 200f384: 40 00 21 5e call 20178fc <_Watchdog_Remove> 200f388: 90 06 20 10 add %i0, 0x10, %o0 RTEMS_INLINE_ROUTINE void _Rate_monotonic_Free ( Rate_monotonic_Control *the_period ) { _Objects_Free( &_Rate_monotonic_Information, &the_period->Object ); 200f38c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 200f390: c0 26 20 38 clr [ %i0 + 0x38 ] 200f394: 40 00 15 71 call 2014958 <_Objects_Free> 200f398: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f39c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f3a0: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 200f3a4: b0 10 20 00 clr %i0 200f3a8: 84 00 bf ff add %g2, -1, %g2 200f3ac: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200f3b0: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 200f3b4: 80 a0 60 00 cmp %g1, 0 200f3b8: 12 80 00 04 bne 200f3c8 200f3bc: 01 00 00 00 nop _Thread_Dispatch(); 200f3c0: 40 00 1a c1 call 2015ec4 <_Thread_Dispatch> 200f3c4: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f3c8: 81 c7 e0 08 ret 200f3cc: 81 e8 00 00 restore 0200e454 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200e454: 9d e3 bf 88 save %sp, -120, %sp 200e458: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200e45c: 80 a6 60 00 cmp %i1, 0 200e460: 02 80 00 36 be 200e538 200e464: b0 10 20 09 mov 9, %i0 200e468: 11 00 80 75 sethi %hi(0x201d400), %o0 200e46c: 94 07 bf f4 add %fp, -12, %o2 200e470: 7f ff eb 6c call 2009220 <_Objects_Get> 200e474: 90 12 23 44 or %o0, 0x344, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200e478: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e47c: 80 a0 60 00 cmp %g1, 0 200e480: 02 80 00 08 be 200e4a0 200e484: b0 10 00 08 mov %o0, %i0 200e488: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 200e48c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200e490: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 200e494: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 200e498: 81 c7 e0 08 ret <== NOT EXECUTED 200e49c: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200e4a0: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200e4a4: 80 a0 60 00 cmp %g1, 0 200e4a8: 02 80 00 03 be 200e4b4 200e4ac: 84 10 20 00 clr %g2 200e4b0: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200e4b4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200e4b8: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200e4bc: 80 a0 60 00 cmp %g1, 0 200e4c0: 12 80 00 07 bne 200e4dc 200e4c4: c2 26 60 04 st %g1, [ %i1 + 4 ] #else status->ticks_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; 200e4c8: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED 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; 200e4cc: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 200e4d0: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED #else status->ticks_since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 200e4d4: 10 80 00 0e b 200e50c <== NOT EXECUTED 200e4d8: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED * 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 ); 200e4dc: a0 07 bf ec add %fp, -20, %l0 200e4e0: 7f ff e8 21 call 2008564 <_TOD_Get_uptime> 200e4e4: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200e4e8: 90 06 20 44 add %i0, 0x44, %o0 200e4ec: 92 10 00 10 mov %l0, %o1 200e4f0: 7f ff f5 07 call 200b90c <_Timespec_Subtract> 200e4f4: 94 06 60 08 add %i1, 8, %o2 status->ticks_since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 200e4f8: 11 00 80 76 sethi %hi(0x201d800), %o0 200e4fc: 92 10 00 10 mov %l0, %o1 200e500: 94 06 60 10 add %i1, 0x10, %o2 200e504: 7f ff f5 02 call 200b90c <_Timespec_Subtract> 200e508: 90 12 21 c8 or %o0, 0x1c8, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200e50c: 03 00 80 76 sethi %hi(0x201d800), %g1 200e510: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 200e514: b0 10 20 00 clr %i0 200e518: 84 00 bf ff add %g2, -1, %g2 200e51c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 200e520: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 200e524: 80 a0 60 00 cmp %g1, 0 200e528: 12 80 00 04 bne 200e538 200e52c: 01 00 00 00 nop _Thread_Dispatch(); 200e530: 7f ff f0 41 call 200a634 <_Thread_Dispatch> 200e534: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e538: 81 c7 e0 08 ret 200e53c: 81 e8 00 00 restore 02006730 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 2006730: 9d e3 bf 80 save %sp, -128, %sp RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get ( Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) 2006734: 11 00 80 75 sethi %hi(0x201d400), %o0 2006738: 92 10 00 18 mov %i0, %o1 200673c: 90 12 23 44 or %o0, 0x344, %o0 2006740: 40 00 0a b8 call 2009220 <_Objects_Get> 2006744: 94 07 bf f4 add %fp, -12, %o2 rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2006748: c2 07 bf f4 ld [ %fp + -12 ], %g1 200674c: 80 a0 60 00 cmp %g1, 0 2006750: 02 80 00 07 be 200676c 2006754: a2 10 00 08 mov %o0, %l1 2006758: 80 a0 60 02 cmp %g1, 2 200675c: 02 80 00 0c be 200678c 2006760: b0 10 20 04 mov 4, %i0 the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 2006764: 81 c7 e0 08 ret <== NOT EXECUTED 2006768: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 200676c: 27 00 80 76 sethi %hi(0x201d800), %l3 2006770: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006774: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 2006778: 80 a0 80 01 cmp %g2, %g1 200677c: 02 80 00 06 be 2006794 2006780: 80 a6 60 00 cmp %i1, 0 _Thread_Enable_dispatch(); 2006784: 7f ff ff 7f call 2006580 <_Thread_Enable_dispatch> 2006788: b0 10 20 17 mov 0x17, %i0 200678c: 81 c7 e0 08 ret 2006790: 81 e8 00 00 restore return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006794: 12 80 00 11 bne 20067d8 2006798: 01 00 00 00 nop switch ( the_period->state ) { 200679c: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 20067a0: 80 a2 20 02 cmp %o0, 2 20067a4: 02 80 00 09 be 20067c8 20067a8: b0 10 20 00 clr %i0 20067ac: 80 a2 20 04 cmp %o0, 4 20067b0: 02 80 00 06 be 20067c8 20067b4: b0 10 20 06 mov 6, %i0 20067b8: 80 a2 20 00 cmp %o0, 0 20067bc: 02 80 00 03 be 20067c8 20067c0: b0 10 20 0b mov 0xb, %i0 20067c4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED break; default: /* unreached -- only to remove warnings */ return_value = RTEMS_INTERNAL_ERROR; break; } _Thread_Enable_dispatch(); 20067c8: 7f ff ff 6e call 2006580 <_Thread_Enable_dispatch> 20067cc: 01 00 00 00 nop 20067d0: 81 c7 e0 08 ret 20067d4: 81 e8 00 00 restore return( return_value ); } _ISR_Disable( level ); 20067d8: 7f ff f0 43 call 20028e4 20067dc: 01 00 00 00 nop 20067e0: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 20067e4: e4 04 60 38 ld [ %l1 + 0x38 ], %l2 20067e8: 80 a4 a0 02 cmp %l2, 2 20067ec: 02 80 00 29 be 2006890 20067f0: 80 a4 a0 04 cmp %l2, 4 20067f4: 02 80 00 43 be 2006900 20067f8: 80 a4 a0 00 cmp %l2, 0 20067fc: 32 bf ff e4 bne,a 200678c 2006800: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 2006804: 7f ff f0 3c call 20028f4 2006808: a0 07 bf ec add %fp, -20, %l0 #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) _TOD_Get_uptime( &uptime ); 200680c: 40 00 07 56 call 2008564 <_TOD_Get_uptime> 2006810: 90 10 00 10 mov %l0, %o0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 2006814: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006818: c4 04 e1 c0 ld [ %l3 + 0x1c0 ], %g2 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 200681c: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 2006820: c2 07 bf f0 ld [ %fp + -16 ], %g1 the_period->owner_executed_at_period = _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006824: 92 10 00 10 mov %l0, %o1 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS /* * Since the statistics didn't update the starting time, * we do it here. */ the_period->time_at_period = uptime; 2006828: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 200682c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006830: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006834: c2 24 60 3c st %g1, [ %l1 + 0x3c ] 2006838: c2 00 a0 94 ld [ %g2 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 200683c: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006840: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006844: 11 00 80 76 sethi %hi(0x201d800), %o0 2006848: 40 00 14 31 call 200b90c <_Timespec_Subtract> 200684c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 201d9c8 <_Thread_Time_of_last_context_switch> /* The thread had executed before the last context switch also. * * the_period->owner_executed_at_period += ran */ _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 2006850: 92 10 00 10 mov %l0, %o1 2006854: 40 00 13 cd call 200b788 <_Timespec_Add_to> 2006858: 90 04 60 3c add %l1, 0x3c, %o0 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 200685c: 82 10 20 02 mov 2, %g1 2006860: c2 24 60 38 st %g1, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006864: 03 00 80 1b sethi %hi(0x2006c00), %g1 2006868: 82 10 60 98 or %g1, 0x98, %g1 ! 2006c98 <_Rate_monotonic_Timeout> NULL ); the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 200686c: 90 04 60 10 add %l1, 0x10, %o0 2006870: 92 10 00 19 mov %i1, %o1 the_watchdog->id = id; 2006874: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006878: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200687c: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006880: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006884: 7f ff ff 37 call 2006560 <_Watchdog_Insert_ticks> 2006888: c2 24 60 2c st %g1, [ %l1 + 0x2c ] 200688c: 30 80 00 19 b,a 20068f0 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006890: 7f ff ff 49 call 20065b4 <_Rate_monotonic_Update_statistics> 2006894: 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; 2006898: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 200689c: 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; 20068a0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 20068a4: 7f ff f0 14 call 20028f4 20068a8: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 20068ac: c2 04 e1 c0 ld [ %l3 + 0x1c0 ], %g1 20068b0: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068b4: 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; 20068b8: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068bc: 40 00 12 89 call 200b2e0 <_Thread_Set_state> 20068c0: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 20068c4: 7f ff f0 08 call 20028e4 20068c8: 01 00 00 00 nop local_state = the_period->state; 20068cc: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 20068d0: e4 24 60 38 st %l2, [ %l1 + 0x38 ] _ISR_Enable( level ); 20068d4: 7f ff f0 08 call 20028f4 20068d8: 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 ) 20068dc: 80 a4 20 03 cmp %l0, 3 20068e0: 12 80 00 04 bne 20068f0 20068e4: d0 04 e1 c0 ld [ %l3 + 0x1c0 ], %o0 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 20068e8: 40 00 0e 88 call 200a308 <_Thread_Clear_state> <== NOT EXECUTED 20068ec: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED _Thread_Enable_dispatch(); 20068f0: 7f ff ff 24 call 2006580 <_Thread_Enable_dispatch> 20068f4: b0 10 20 00 clr %i0 20068f8: 81 c7 e0 08 ret 20068fc: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006900: 7f ff ff 2d call 20065b4 <_Rate_monotonic_Update_statistics> 2006904: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 2006908: 7f ff ef fb call 20028f4 200690c: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006910: 82 10 20 02 mov 2, %g1 the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006914: 90 04 60 10 add %l1, 0x10, %o0 2006918: 92 10 00 19 mov %i1, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 200691c: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; 2006920: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert_ticks( &the_period->Timer, length ); 2006924: 7f ff ff 0f call 2006560 <_Watchdog_Insert_ticks> 2006928: b0 10 20 06 mov 6, %i0 _Thread_Enable_dispatch(); 200692c: 7f ff ff 15 call 2006580 <_Thread_Enable_dispatch> 2006930: 01 00 00 00 nop 2006934: 81 c7 e0 08 ret 2006938: 81 e8 00 00 restore break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200693c: 81 c7 e0 08 ret <== NOT EXECUTED 2006940: 81 e8 00 00 restore <== NOT EXECUTED 02006944 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006944: 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 ) 2006948: 80 a6 60 00 cmp %i1, 0 200694c: 02 80 00 7f be 2006b48 2006950: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006954: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006958: 9f c6 40 00 call %i1 200695c: 92 12 61 60 or %o1, 0x160, %o1 ! 201ad60 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006960: 90 10 00 18 mov %i0, %o0 2006964: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006968: 9f c6 40 00 call %i1 200696c: 92 12 61 80 or %o1, 0x180, %o1 ! 201ad80 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006970: 90 10 00 18 mov %i0, %o0 2006974: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006978: 9f c6 40 00 call %i1 200697c: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 201ada8 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006980: 90 10 00 18 mov %i0, %o0 2006984: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006988: 9f c6 40 00 call %i1 200698c: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 201add0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006990: 90 10 00 18 mov %i0, %o0 2006994: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006998: 9f c6 40 00 call %i1 200699c: 92 12 62 20 or %o1, 0x220, %o1 ! 201ae20 /* * 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 ; 20069a0: 03 00 80 75 sethi %hi(0x201d400), %g1 20069a4: 82 10 63 44 or %g1, 0x344, %g1 ! 201d744 <_Rate_monotonic_Information> 20069a8: e4 00 60 08 ld [ %g1 + 8 ], %l2 _Timespec_Divide_by_integer( &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 20069ac: 03 00 80 6b sethi %hi(0x201ac00), %g1 20069b0: b4 10 62 88 or %g1, 0x288, %i2 ! 201ae88 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 20069b4: 03 00 80 6b sethi %hi(0x201ac00), %g1 * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 20069b8: ba 07 bf 98 add %fp, -104, %i5 _Timespec_Divide_by_integer( &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 20069bc: b6 10 62 a8 or %g1, 0x2a8, %i3 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 ); 20069c0: ae 07 bf d0 add %fp, -48, %l7 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 20069c4: 03 00 80 6b sethi %hi(0x201ac00), %g1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 20069c8: a8 07 bf f3 add %fp, -13, %l4 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 20069cc: b8 10 61 a0 or %g1, 0x1a0, %i4 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 20069d0: ac 07 bf b0 add %fp, -80, %l6 20069d4: a6 07 bf e8 add %fp, -24, %l3 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 20069d8: 10 80 00 56 b 2006b30 20069dc: aa 07 bf c8 add %fp, -56, %l5 * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 20069e0: 40 00 1e 79 call 200e3c4 20069e4: 92 10 00 1d mov %i5, %o1 if ( status != RTEMS_SUCCESSFUL ) 20069e8: 80 a2 20 00 cmp %o0, 0 20069ec: 32 80 00 51 bne,a 2006b30 20069f0: a4 04 a0 01 inc %l2 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 20069f4: 92 10 00 17 mov %l7, %o1 20069f8: 40 00 1e 97 call 200e454 20069fc: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 2006a00: 80 a2 20 00 cmp %o0, 0 2006a04: 32 80 00 4b bne,a 2006b30 2006a08: a4 04 a0 01 inc %l2 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 2006a0c: d0 07 bf d0 ld [ %fp + -48 ], %o0 2006a10: 80 a2 20 00 cmp %o0, 0 2006a14: 02 80 00 05 be 2006a28 2006a18: c0 2f bf f3 clrb [ %fp + -13 ] rtems_object_get_name( the_status.owner, sizeof(name), name ); 2006a1c: 94 10 00 14 mov %l4, %o2 2006a20: 40 00 00 c8 call 2006d40 2006a24: 92 10 20 05 mov 5, %o1 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006a28: d8 1f bf 98 ldd [ %fp + -104 ], %o4 2006a2c: 94 10 00 12 mov %l2, %o2 2006a30: 96 10 00 14 mov %l4, %o3 2006a34: 13 00 80 6b sethi %hi(0x201ac00), %o1 2006a38: 90 10 00 18 mov %i0, %o0 2006a3c: 9f c6 40 00 call %i1 2006a40: 92 12 62 70 or %o1, 0x270, %o1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a44: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a48: 94 10 00 13 mov %l3, %o2 2006a4c: 90 10 00 16 mov %l6, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006a50: 80 a0 60 00 cmp %g1, 0 2006a54: 12 80 00 06 bne 2006a6c 2006a58: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006a5c: 9f c6 40 00 call %i1 2006a60: 90 10 00 18 mov %i0, %o0 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006a64: 10 80 00 33 b 2006b30 2006a68: a4 04 a0 01 inc %l2 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006a6c: 40 00 13 5f call 200b7e8 <_Timespec_Divide_by_integer> 2006a70: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2006a74: d0 07 bf a4 ld [ %fp + -92 ], %o0 2006a78: 40 00 47 b6 call 2018950 <.div> 2006a7c: 92 10 23 e8 mov 0x3e8, %o1 2006a80: a2 10 00 08 mov %o0, %l1 2006a84: d0 07 bf ac ld [ %fp + -84 ], %o0 2006a88: 40 00 47 b2 call 2018950 <.div> 2006a8c: 92 10 23 e8 mov 0x3e8, %o1 2006a90: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006a94: a0 10 00 08 mov %o0, %l0 2006a98: d0 07 bf ec ld [ %fp + -20 ], %o0 2006a9c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006aa0: 40 00 47 ac call 2018950 <.div> 2006aa4: 92 10 23 e8 mov 0x3e8, %o1 2006aa8: d8 07 bf a8 ld [ %fp + -88 ], %o4 2006aac: d4 07 bf a0 ld [ %fp + -96 ], %o2 2006ab0: 96 10 00 11 mov %l1, %o3 2006ab4: 9a 10 00 10 mov %l0, %o5 2006ab8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006abc: 92 10 00 1a mov %i2, %o1 2006ac0: 9f c6 40 00 call %i1 2006ac4: 90 10 00 18 mov %i0, %o0 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006ac8: d2 07 bf 98 ld [ %fp + -104 ], %o1 2006acc: 94 10 00 13 mov %l3, %o2 2006ad0: 40 00 13 46 call 200b7e8 <_Timespec_Divide_by_integer> 2006ad4: 90 10 00 15 mov %l5, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 2006ad8: d0 07 bf bc ld [ %fp + -68 ], %o0 2006adc: 40 00 47 9d call 2018950 <.div> 2006ae0: 92 10 23 e8 mov 0x3e8, %o1 2006ae4: a2 10 00 08 mov %o0, %l1 2006ae8: d0 07 bf c4 ld [ %fp + -60 ], %o0 2006aec: 40 00 47 99 call 2018950 <.div> 2006af0: 92 10 23 e8 mov 0x3e8, %o1 2006af4: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006af8: a0 10 00 08 mov %o0, %l0 2006afc: d0 07 bf ec ld [ %fp + -20 ], %o0 2006b00: 92 10 23 e8 mov 0x3e8, %o1 2006b04: 40 00 47 93 call 2018950 <.div> 2006b08: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2006b0c: d4 07 bf b8 ld [ %fp + -72 ], %o2 2006b10: d8 07 bf c0 ld [ %fp + -64 ], %o4 2006b14: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 2006b18: 96 10 00 11 mov %l1, %o3 2006b1c: 9a 10 00 10 mov %l0, %o5 2006b20: 90 10 00 18 mov %i0, %o0 2006b24: 9f c6 40 00 call %i1 2006b28: 92 10 00 1b mov %i3, %o1 * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 2006b2c: 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 ; 2006b30: 05 00 80 75 sethi %hi(0x201d400), %g2 2006b34: 84 10 a3 44 or %g2, 0x344, %g2 ! 201d744 <_Rate_monotonic_Information> 2006b38: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 2006b3c: 80 a4 80 01 cmp %l2, %g1 2006b40: 08 bf ff a8 bleu 20069e0 2006b44: 90 10 00 12 mov %l2, %o0 2006b48: 81 c7 e0 08 ret 2006b4c: 81 e8 00 00 restore 02006b6c : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 2006b6c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006b70: 03 00 80 76 sethi %hi(0x201d800), %g1 2006b74: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006b78: 84 00 a0 01 inc %g2 2006b7c: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] /* * 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 ; 2006b80: 03 00 80 75 sethi %hi(0x201d400), %g1 2006b84: 82 10 63 44 or %g1, 0x344, %g1 ! 201d744 <_Rate_monotonic_Information> 2006b88: e0 00 60 08 ld [ %g1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 2006b8c: 10 80 00 04 b 2006b9c 2006b90: a2 10 00 01 mov %g1, %l1 id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 2006b94: 40 00 00 12 call 2006bdc 2006b98: 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 ; 2006b9c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2006ba0: 80 a4 00 01 cmp %l0, %g1 2006ba4: 08 bf ff fc bleu 2006b94 2006ba8: 90 10 00 10 mov %l0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006bac: 03 00 80 76 sethi %hi(0x201d800), %g1 2006bb0: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201d8e0 <_Thread_Dispatch_disable_level> 2006bb4: 84 00 bf ff add %g2, -1, %g2 2006bb8: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 2006bbc: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1 2006bc0: 80 a0 60 00 cmp %g1, 0 2006bc4: 12 80 00 04 bne 2006bd4 2006bc8: 01 00 00 00 nop _Thread_Dispatch(); 2006bcc: 40 00 0e 9a call 200a634 <_Thread_Dispatch> 2006bd0: 81 e8 00 00 restore 2006bd4: 81 c7 e0 08 ret <== NOT EXECUTED 2006bd8: 81 e8 00 00 restore <== NOT EXECUTED 0200f8e8 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f8e8: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 200f8ec: a4 96 20 00 orcc %i0, 0, %l2 200f8f0: 02 80 00 87 be 200fb0c 200f8f4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f8f8: 80 a6 60 00 cmp %i1, 0 200f8fc: 02 80 00 c7 be 200fc18 200f900: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f904: 02 80 00 c5 be 200fc18 200f908: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 200f90c: 32 80 00 80 bne,a 200fb0c 200f910: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200f914: 7f ff eb 8b call 200a740 200f918: 01 00 00 00 nop 200f91c: a2 10 00 08 mov %o0, %l1 200f920: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f924: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200f928: 80 a0 60 00 cmp %g1, 0 200f92c: 02 80 00 0b be 200f958 200f930: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f934: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200f938: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200f93c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200f940: 08 80 00 05 bleu 200f954 <== NOT EXECUTED 200f944: 90 10 20 00 clr %o0 <== NOT EXECUTED 200f948: 92 10 20 00 clr %o1 <== NOT EXECUTED 200f94c: 40 00 12 d4 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 200f950: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200f954: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200f958: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200f95c: 03 00 80 c9 sethi %hi(0x2032400), %g1 200f960: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200f964: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200f968: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200f96c: 80 a0 60 00 cmp %g1, 0 200f970: 22 80 00 30 be,a 200fa30 200f974: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200f978: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200f97c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200f980: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 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; the_mutex->nest_count = 1; 200f984: 88 10 20 01 mov 1, %g4 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; 200f988: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 200f98c: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200f990: 80 a0 e0 02 cmp %g3, 2 200f994: 02 80 00 05 be 200f9a8 200f998: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 200f99c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200f9a0: 12 80 00 07 bne 200f9bc <== NOT EXECUTED 200f9a4: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200f9a8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f9ac: 80 a0 e0 03 cmp %g3, 3 the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200f9b0: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200f9b4: 02 80 00 03 be 200f9c0 200f9b8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 200f9bc: 30 80 00 2b b,a 200fa68 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200f9c0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200f9c4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200f9c8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200f9cc: 12 80 00 03 bne 200f9d8 <== NOT EXECUTED 200f9d0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200f9d4: 30 80 00 25 b,a 200fa68 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200f9d8: 08 80 00 0f bleu 200fa14 <== NOT EXECUTED 200f9dc: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f9e0: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200f9e4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200f9e8: 82 00 60 01 inc %g1 <== NOT EXECUTED 200f9ec: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200f9f0: 7f ff eb 58 call 200a750 <== NOT EXECUTED 200f9f4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200f9f8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200f9fc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200fa00: 40 00 17 f4 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 200fa04: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200fa08: 7f ff ff ab call 200f8b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fa0c: 23 00 80 c9 sethi %hi(0x2032400), %l1 <== NOT EXECUTED 200fa10: 30 80 00 2f b,a 200facc <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200fa14: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fa18: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fa1c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200fa20: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fa24: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fa28: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fa2c: 30 80 00 0f b,a 200fa68 <== 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 ) ) { 200fa30: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fa34: 12 80 00 13 bne 200fa80 <== NOT EXECUTED 200fa38: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fa3c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200fa40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fa44: 22 80 00 07 be,a 200fa60 <== NOT EXECUTED 200fa48: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fa4c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fa50: 32 80 00 0c bne,a 200fa80 <== NOT EXECUTED 200fa54: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 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; 200fa58: 10 80 00 08 b 200fa78 <== NOT EXECUTED 200fa5c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 200fa60: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa64: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa68: 7f ff eb 3a call 200a750 200fa6c: 90 10 00 11 mov %l1, %o0 * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 200fa70: 10 80 00 17 b 200facc 200fa74: 23 00 80 c9 sethi %hi(0x2032400), %l1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fa78: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fa7c: 30 bf ff fb b,a 200fa68 <== NOT EXECUTED 200fa80: c6 04 20 08 ld [ %l0 + 8 ], %g3 <== NOT EXECUTED 200fa84: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 200fa88: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fa8c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fa90: c6 21 20 20 st %g3, [ %g4 + 0x20 ] <== NOT EXECUTED 200fa94: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fa98: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 200fa9c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200faa0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 200faa4: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 200faa8: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200faac: 7f ff eb 29 call 200a750 <== NOT EXECUTED 200fab0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fab4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fab8: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200fabc: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fac0: 40 00 0f e5 call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200fac4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fac8: 23 00 80 c9 sethi %hi(0x2032400), %l1 <== NOT EXECUTED 200facc: 40 00 12 a1 call 2014550 <_Objects_Allocate> 200fad0: 90 14 60 0c or %l1, 0xc, %o0 ! 203240c <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 200fad4: a0 92 20 00 orcc %o0, 0, %l0 200fad8: 12 80 00 0f bne 200fb14 200fadc: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fae0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fae4: 82 00 60 01 inc %g1 200fae8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 200faec: 03 00 80 c9 sethi %hi(0x2032400), %g1 200faf0: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200faf4: 94 10 20 00 clr %o2 200faf8: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fafc: 40 00 0f f8 call 2013adc <_CORE_mutex_Surrender> 200fb00: 90 02 20 10 add %o0, 0x10, %o0 200fb04: 7f ff ff 6c call 200f8b4 <_Thread_Enable_dispatch> 200fb08: b0 10 20 05 mov 5, %i0 200fb0c: 81 c7 e0 08 ret 200fb10: 81 e8 00 00 restore return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 200fb14: 90 04 20 68 add %l0, 0x68, %o0 200fb18: 92 10 00 19 mov %i1, %o1 200fb1c: 94 10 00 1a mov %i2, %o2 200fb20: 40 00 12 15 call 2014374 <_Heap_Initialize> 200fb24: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 200fb28: 80 a2 20 00 cmp %o0, 0 200fb2c: 12 80 00 13 bne 200fb78 200fb30: d0 24 20 5c st %o0, [ %l0 + 0x5c ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 200fb34: 90 14 60 0c or %l1, 0xc, %o0 200fb38: 40 00 13 88 call 2014958 <_Objects_Free> 200fb3c: 92 10 00 10 mov %l0, %o1 200fb40: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fb44: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fb48: 82 00 60 01 inc %g1 200fb4c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200fb50: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fb54: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200fb58: 94 10 20 00 clr %o2 200fb5c: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fb60: 40 00 0f df call 2013adc <_CORE_mutex_Surrender> 200fb64: 90 02 20 10 add %o0, 0x10, %o0 200fb68: 7f ff ff 53 call 200f8b4 <_Thread_Enable_dispatch> 200fb6c: b0 10 20 08 mov 8, %i0 200fb70: 81 c7 e0 08 ret 200fb74: 81 e8 00 00 restore the_region->length = length; the_region->page_size = page_size; the_region->attribute_set = attribute_set; the_region->number_of_used_blocks = 0; _Thread_queue_Initialize( 200fb78: 90 04 20 10 add %l0, 0x10, %o0 _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_INVALID_SIZE; } the_region->starting_address = starting_address; 200fb7c: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 200fb80: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 200fb84: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 200fb88: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 200fb8c: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 200fb90: 93 37 20 02 srl %i4, 2, %o1 200fb94: 94 10 20 40 mov 0x40, %o2 200fb98: 92 0a 60 01 and %o1, 1, %o1 200fb9c: 40 00 1b 48 call 20168bc <_Thread_queue_Initialize> 200fba0: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fba4: 90 14 60 0c or %l1, 0xc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200fba8: c4 04 20 08 ld [ %l0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fbac: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fbb0: 03 00 00 3f sethi %hi(0xfc00), %g1 200fbb4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200fbb8: 82 08 80 01 and %g2, %g1, %g1 200fbbc: 80 a0 40 03 cmp %g1, %g3 200fbc0: 38 80 00 06 bgu,a 200fbd8 200fbc4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200fbc8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200fbcc: 83 28 60 02 sll %g1, 2, %g1 200fbd0: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 200fbd4: c2 04 20 08 ld [ %l0 + 8 ], %g1 200fbd8: 05 00 80 c9 sethi %hi(0x2032400), %g2 200fbdc: c2 27 40 00 st %g1, [ %i5 ] 200fbe0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200fbe4: e4 24 20 0c st %l2, [ %l0 + 0xc ] 200fbe8: 82 00 60 01 inc %g1 200fbec: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 200fbf0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fbf4: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200fbf8: 94 10 20 00 clr %o2 200fbfc: d2 02 20 08 ld [ %o0 + 8 ], %o1 200fc00: 40 00 0f b7 call 2013adc <_CORE_mutex_Surrender> 200fc04: 90 02 20 10 add %o0, 0x10, %o0 200fc08: 7f ff ff 2b call 200f8b4 <_Thread_Enable_dispatch> 200fc0c: b0 10 20 00 clr %i0 200fc10: 81 c7 e0 08 ret 200fc14: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 200fc18: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } 200fc1c: 81 c7 e0 08 ret <== NOT EXECUTED 200fc20: 81 e8 00 00 restore <== NOT EXECUTED 0200fc58 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 200fc58: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 200fc5c: 7f ff ea b9 call 200a740 200fc60: 01 00 00 00 nop 200fc64: a2 10 00 08 mov %o0, %l1 200fc68: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fc6c: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200fc70: 80 a0 60 00 cmp %g1, 0 200fc74: 02 80 00 0b be 200fca0 200fc78: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fc7c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fc80: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200fc84: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fc88: 08 80 00 05 bleu 200fc9c <== NOT EXECUTED 200fc8c: 90 10 20 00 clr %o0 <== NOT EXECUTED 200fc90: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fc94: 40 00 12 02 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 200fc98: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200fc9c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fca0: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200fca4: 03 00 80 c9 sethi %hi(0x2032400), %g1 200fca8: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200fcac: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200fcb0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 200fcb4: 80 a0 60 00 cmp %g1, 0 200fcb8: 22 80 00 33 be,a 200fd84 200fcbc: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200fcc0: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200fcc4: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 200fcc8: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200fccc: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 200fcd0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 200fcd4: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200fcd8: 80 a0 e0 02 cmp %g3, 2 200fcdc: 02 80 00 05 be 200fcf0 200fce0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 200fce4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200fce8: 32 80 00 06 bne,a 200fd00 <== NOT EXECUTED 200fcec: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200fcf0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 200fcf4: 82 00 60 01 inc %g1 200fcf8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200fcfc: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 200fd00: 80 a0 60 03 cmp %g1, 3 200fd04: 22 80 00 03 be,a 200fd10 200fd08: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 200fd0c: 30 80 00 2c b,a 200fdbc { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 200fd10: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200fd14: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200fd18: 12 80 00 03 bne 200fd24 <== NOT EXECUTED 200fd1c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 200fd20: 30 80 00 27 b,a 200fdbc <== NOT EXECUTED return 0; } if ( current > ceiling ) { 200fd24: 08 80 00 10 bleu 200fd64 <== NOT EXECUTED 200fd28: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200fd2c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fd30: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fd34: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fd38: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200fd3c: 7f ff ea 85 call 200a750 <== NOT EXECUTED 200fd40: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 200fd44: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200fd48: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200fd4c: 40 00 17 21 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 200fd50: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 200fd54: 7f ff ff b4 call 200fc24 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fd58: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 200fd5c: 10 80 00 32 b 200fe24 <== NOT EXECUTED 200fd60: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200fd64: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200fd68: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200fd6c: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 200fd70: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 200fd74: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200fd78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200fd7c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200fd80: 30 80 00 0f b,a 200fdbc <== 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 ) ) { 200fd84: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200fd88: 32 80 00 13 bne,a 200fdd4 <== NOT EXECUTED 200fd8c: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200fd90: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 200fd94: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200fd98: 22 80 00 07 be,a 200fdb4 <== NOT EXECUTED 200fd9c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200fda0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fda4: 12 80 00 0c bne 200fdd4 <== NOT EXECUTED 200fda8: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED 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; 200fdac: 10 80 00 08 b 200fdcc <== NOT EXECUTED 200fdb0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 200fdb4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fdb8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200fdbc: 7f ff ea 65 call 200a750 200fdc0: 90 10 00 11 mov %l1, %o0 200fdc4: 10 80 00 18 b 200fe24 200fdc8: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 200fdcc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200fdd0: 30 bf ff fb b,a 200fdbc <== NOT EXECUTED 200fdd4: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 200fdd8: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fddc: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 200fde0: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 200fde4: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fde8: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fdec: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 200fdf0: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fdf4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 200fdf8: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 200fdfc: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 200fe00: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200fe04: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200fe08: 7f ff ea 52 call 200a750 <== NOT EXECUTED 200fe0c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200fe10: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 200fe14: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fe18: 40 00 0f 0f call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200fe1c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe20: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200fe24: 21 00 80 c9 sethi %hi(0x2032400), %l0 200fe28: 94 07 bf f4 add %fp, -12, %o2 200fe2c: 40 00 13 0d call 2014a60 <_Objects_Get_no_protection> 200fe30: 90 14 20 0c or %l0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 200fe34: c2 07 bf f4 ld [ %fp + -12 ], %g1 200fe38: 80 a0 60 01 cmp %g1, 1 200fe3c: 02 80 00 0a be 200fe64 200fe40: 92 10 00 08 mov %o0, %o1 200fe44: 80 a0 60 01 cmp %g1, 1 200fe48: 2a 80 00 22 bcs,a 200fed0 200fe4c: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 200fe50: 80 a0 60 02 cmp %g1, 2 200fe54: 12 80 00 10 bne 200fe94 200fe58: b0 10 20 19 mov 0x19, %i0 200fe5c: 10 80 00 10 b 200fe9c 200fe60: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 200fe64: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 200fe68: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200fe6c: 82 00 60 01 inc %g1 <== NOT EXECUTED 200fe70: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 200fe74: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200fe78: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 200fe7c: 94 10 20 00 clr %o2 <== NOT EXECUTED 200fe80: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200fe84: 40 00 0f 16 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 200fe88: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 200fe8c: 7f ff ff 66 call 200fc24 <_Thread_Enable_dispatch> <== NOT EXECUTED 200fe90: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 200fe94: 81 c7 e0 08 ret <== NOT EXECUTED 200fe98: 81 e8 00 00 restore <== NOT EXECUTED 200fe9c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200fea0: 82 00 60 01 inc %g1 200fea4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 200fea8: 03 00 80 c9 sethi %hi(0x2032400), %g1 200feac: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200feb0: 94 10 20 00 clr %o2 200feb4: d2 02 20 08 ld [ %o0 + 8 ], %o1 200feb8: 40 00 0f 09 call 2013adc <_CORE_mutex_Surrender> 200febc: 90 02 20 10 add %o0, 0x10, %o0 200fec0: 7f ff ff 59 call 200fc24 <_Thread_Enable_dispatch> 200fec4: b0 10 20 04 mov 4, %i0 200fec8: 81 c7 e0 08 ret 200fecc: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 200fed0: 80 a0 60 00 cmp %g1, 0 200fed4: 12 80 00 1d bne 200ff48 200fed8: 05 00 80 c9 sethi %hi(0x2032400), %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fedc: 90 14 20 0c or %l0, 0xc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200fee0: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fee4: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200fee8: 05 00 00 3f sethi %hi(0xfc00), %g2 200feec: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200fef0: 82 08 40 02 and %g1, %g2, %g1 200fef4: 80 a0 40 03 cmp %g1, %g3 200fef8: 18 80 00 04 bgu 200ff08 200fefc: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200ff00: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200ff04: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 200ff08: 40 00 12 94 call 2014958 <_Objects_Free> 200ff0c: c0 22 60 0c clr [ %o1 + 0xc ] 200ff10: 05 00 80 c9 sethi %hi(0x2032400), %g2 200ff14: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200ff18: 82 00 60 01 inc %g1 200ff1c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 200ff20: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ff24: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200ff28: 94 10 20 00 clr %o2 200ff2c: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff30: 40 00 0e eb call 2013adc <_CORE_mutex_Surrender> 200ff34: 90 02 20 10 add %o0, 0x10, %o0 200ff38: 7f ff ff 3b call 200fc24 <_Thread_Enable_dispatch> 200ff3c: b0 10 20 00 clr %i0 200ff40: 81 c7 e0 08 ret 200ff44: 81 e8 00 00 restore 200ff48: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 200ff4c: 82 00 60 01 inc %g1 200ff50: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 200ff54: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ff58: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 200ff5c: 94 10 20 00 clr %o2 200ff60: d2 02 20 08 ld [ %o0 + 8 ], %o1 200ff64: 40 00 0e de call 2013adc <_CORE_mutex_Surrender> 200ff68: 90 02 20 10 add %o0, 0x10, %o0 200ff6c: 7f ff ff 2e call 200fc24 <_Thread_Enable_dispatch> 200ff70: b0 10 20 0c mov 0xc, %i0 return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200ff74: 81 c7 e0 08 ret 200ff78: 81 e8 00 00 restore 0200ffb0 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 200ffb0: 9d e3 bf 90 save %sp, -112, %sp 200ffb4: a4 10 00 18 mov %i0, %l2 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 200ffb8: 80 a6 60 00 cmp %i1, 0 200ffbc: 02 80 00 90 be 20101fc 200ffc0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 200ffc4: 7f ff e9 df call 200a740 200ffc8: 01 00 00 00 nop 200ffcc: a2 10 00 08 mov %o0, %l1 200ffd0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ffd4: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 200ffd8: 80 a0 60 00 cmp %g1, 0 200ffdc: 02 80 00 0b be 2010008 200ffe0: 03 00 80 c9 sethi %hi(0x2032400), %g1 200ffe4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 200ffe8: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 200ffec: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200fff0: 08 80 00 05 bleu 2010004 <== NOT EXECUTED 200fff4: 90 10 20 00 clr %o0 <== NOT EXECUTED 200fff8: 92 10 20 00 clr %o1 <== NOT EXECUTED 200fffc: 40 00 11 28 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 2010000: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010004: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010008: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 201000c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010010: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010014: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010018: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 201001c: 80 a0 60 00 cmp %g1, 0 2010020: 22 80 00 33 be,a 20100ec 2010024: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010028: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201002c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2010030: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010034: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 2010038: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 201003c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010040: 80 a0 e0 02 cmp %g3, 2 2010044: 02 80 00 05 be 2010058 2010048: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 201004c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010050: 32 80 00 06 bne,a 2010068 <== NOT EXECUTED 2010054: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010058: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 201005c: 82 00 60 01 inc %g1 2010060: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010064: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2010068: 80 a0 60 03 cmp %g1, 3 201006c: 22 80 00 03 be,a 2010078 2010070: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2010074: 30 80 00 2c b,a 2010124 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2010078: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201007c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010080: 12 80 00 03 bne 201008c <== NOT EXECUTED 2010084: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2010088: 30 80 00 27 b,a 2010124 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 201008c: 08 80 00 10 bleu 20100cc <== NOT EXECUTED 2010090: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010094: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010098: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201009c: 82 00 60 01 inc %g1 <== NOT EXECUTED 20100a0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20100a4: 7f ff e9 ab call 200a750 <== NOT EXECUTED 20100a8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 20100ac: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20100b0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20100b4: 40 00 16 47 call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 20100b8: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 20100bc: 7f ff ff b0 call 200ff7c <_Thread_Enable_dispatch> <== NOT EXECUTED 20100c0: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 20100c4: 10 80 00 32 b 201018c <== NOT EXECUTED 20100c8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20100cc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20100d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20100d4: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 20100d8: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 20100dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20100e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20100e4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20100e8: 30 80 00 0f b,a 2010124 <== 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 ) ) { 20100ec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20100f0: 32 80 00 13 bne,a 201013c <== NOT EXECUTED 20100f4: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20100f8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 20100fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010100: 22 80 00 07 be,a 201011c <== NOT EXECUTED 2010104: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010108: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201010c: 12 80 00 0c bne 201013c <== NOT EXECUTED 2010110: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED 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; 2010114: 10 80 00 08 b 2010134 <== NOT EXECUTED 2010118: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 201011c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010120: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010124: 7f ff e9 8b call 200a750 2010128: 90 10 00 11 mov %l1, %o0 201012c: 10 80 00 18 b 201018c 2010130: 92 10 00 12 mov %l2, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010134: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010138: 30 bf ff fb b,a 2010124 <== NOT EXECUTED 201013c: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 2010140: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010144: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 2010148: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 201014c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010150: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010154: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 2010158: 82 00 60 01 inc %g1 <== NOT EXECUTED 201015c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010160: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2010164: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2010168: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 201016c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010170: 7f ff e9 78 call 200a750 <== NOT EXECUTED 2010174: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010178: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 201017c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010180: 40 00 0e 35 call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010184: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010188: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 201018c: 11 00 80 c9 sethi %hi(0x2032400), %o0 2010190: 94 07 bf f4 add %fp, -12, %o2 2010194: 40 00 12 33 call 2014a60 <_Objects_Get_no_protection> 2010198: 90 12 20 0c or %o0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201019c: c2 07 bf f4 ld [ %fp + -12 ], %g1 20101a0: 80 a0 60 01 cmp %g1, 1 20101a4: 02 80 00 0a be 20101cc 20101a8: a0 10 00 08 mov %o0, %l0 20101ac: 80 a0 60 01 cmp %g1, 1 20101b0: 0a 80 00 22 bcs 2010238 20101b4: 92 10 00 19 mov %i1, %o1 20101b8: 80 a0 60 02 cmp %g1, 2 20101bc: 12 80 00 10 bne 20101fc 20101c0: b0 10 20 19 mov 0x19, %i0 20101c4: 10 80 00 10 b 2010204 20101c8: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 20101cc: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20101d0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20101d4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20101d8: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 20101dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20101e0: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 20101e4: 94 10 20 00 clr %o2 <== NOT EXECUTED 20101e8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20101ec: 40 00 0e 3c call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 20101f0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20101f4: 7f ff ff 62 call 200ff7c <_Thread_Enable_dispatch> <== NOT EXECUTED 20101f8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 20101fc: 81 c7 e0 08 ret <== NOT EXECUTED 2010200: 81 e8 00 00 restore <== NOT EXECUTED 2010204: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010208: 82 00 60 01 inc %g1 201020c: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010210: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010214: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010218: 94 10 20 00 clr %o2 201021c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010220: 40 00 0e 2f call 2013adc <_CORE_mutex_Surrender> 2010224: 90 02 20 10 add %o0, 0x10, %o0 2010228: 7f ff ff 55 call 200ff7c <_Thread_Enable_dispatch> 201022c: b0 10 20 04 mov 4, %i0 2010230: 81 c7 e0 08 ret 2010234: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 2010238: 94 10 00 1a mov %i2, %o2 201023c: 90 02 20 68 add %o0, 0x68, %o0 2010240: 96 07 bf f0 add %fp, -16, %o3 2010244: 40 00 0f 61 call 2013fc8 <_Heap_Extend> 2010248: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 201024c: 80 a2 20 01 cmp %o0, 1 2010250: 02 80 00 12 be 2010298 2010254: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010258: 0a 80 00 08 bcs 2010278 201025c: c6 07 bf f0 ld [ %fp + -16 ], %g3 2010260: 82 1a 20 02 xor %o0, 2, %g1 2010264: 80 a0 00 01 cmp %g0, %g1 2010268: 82 60 20 00 subx %g0, 0, %g1 201026c: b0 08 7f e8 and %g1, -24, %i0 2010270: 10 80 00 0a b 2010298 2010274: b0 06 20 18 add %i0, 0x18, %i0 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010278: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 201027c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010280: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 2010284: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010288: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 201028c: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 2010290: b0 10 20 00 clr %i0 2010294: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010298: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 201029c: 82 00 60 01 inc %g1 20102a0: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 20102a4: 03 00 80 c9 sethi %hi(0x2032400), %g1 20102a8: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20102ac: 94 10 20 00 clr %o2 20102b0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20102b4: 40 00 0e 0a call 2013adc <_CORE_mutex_Surrender> 20102b8: 90 02 20 10 add %o0, 0x10, %o0 20102bc: 7f ff ff 30 call 200ff7c <_Thread_Enable_dispatch> 20102c0: 01 00 00 00 nop return( status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20102c4: 81 c7 e0 08 ret 20102c8: 81 e8 00 00 restore 02010300 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 2010300: 9d e3 bf 90 save %sp, -112, %sp 2010304: a4 10 00 18 mov %i0, %l2 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 2010308: 80 a7 20 00 cmp %i4, 0 201030c: 02 80 00 96 be 2010564 2010310: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; 2010314: c0 27 00 00 clr [ %i4 ] if ( size == 0 ) 2010318: 80 a6 60 00 cmp %i1, 0 201031c: 02 80 00 92 be 2010564 2010320: b0 10 20 08 mov 8, %i0 return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010324: 7f ff e9 07 call 200a740 2010328: 01 00 00 00 nop 201032c: a2 10 00 08 mov %o0, %l1 2010330: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010334: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2010338: 80 a0 60 00 cmp %g1, 0 201033c: 02 80 00 0b be 2010368 2010340: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010344: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010348: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 201034c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010350: 08 80 00 05 bleu 2010364 <== NOT EXECUTED 2010354: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010358: 92 10 20 00 clr %o1 <== NOT EXECUTED 201035c: 40 00 10 50 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 2010360: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010364: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010368: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 201036c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010370: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010374: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010378: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 201037c: 80 a0 60 00 cmp %g1, 0 2010380: 22 80 00 33 be,a 201044c 2010384: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010388: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201038c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2010390: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010394: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 2010398: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 201039c: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20103a0: 80 a0 e0 02 cmp %g3, 2 20103a4: 02 80 00 05 be 20103b8 20103a8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20103ac: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20103b0: 32 80 00 06 bne,a 20103c8 <== NOT EXECUTED 20103b4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20103b8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20103bc: 82 00 60 01 inc %g1 20103c0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20103c4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 20103c8: 80 a0 60 03 cmp %g1, 3 20103cc: 22 80 00 03 be,a 20103d8 20103d0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 20103d4: 30 80 00 2c b,a 2010484 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20103d8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20103dc: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20103e0: 12 80 00 03 bne 20103ec <== NOT EXECUTED 20103e4: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 20103e8: 30 80 00 27 b,a 2010484 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 20103ec: 28 80 00 10 bleu,a 201042c <== NOT EXECUTED 20103f0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20103f4: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20103f8: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20103fc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010400: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010404: 7f ff e8 d3 call 200a750 <== NOT EXECUTED 2010408: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 201040c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010410: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010414: 40 00 15 6f call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 2010418: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 201041c: 7f ff ff ac call 20102cc <_Thread_Enable_dispatch> <== NOT EXECUTED 2010420: 01 00 00 00 nop <== NOT EXECUTED executing = _Thread_Executing; 2010424: 10 80 00 32 b 20104ec <== NOT EXECUTED 2010428: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 201042c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010430: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010434: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2010438: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 201043c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010440: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010444: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010448: 30 80 00 0f b,a 2010484 <== 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 ) ) { 201044c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010450: 32 80 00 13 bne,a 201049c <== NOT EXECUTED 2010454: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010458: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 201045c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010460: 22 80 00 07 be,a 201047c <== NOT EXECUTED 2010464: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010468: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201046c: 12 80 00 0c bne 201049c <== NOT EXECUTED 2010470: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED 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; 2010474: 10 80 00 08 b 2010494 <== NOT EXECUTED 2010478: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 201047c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010480: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010484: 7f ff e8 b3 call 200a750 2010488: 90 10 00 11 mov %l1, %o0 201048c: 10 80 00 18 b 20104ec 2010490: 03 00 80 c9 sethi %hi(0x2032400), %g1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2010494: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010498: 30 bf ff fb b,a 2010484 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 201049c: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 20104a0: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20104a4: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20104a8: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 20104ac: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20104b0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20104b4: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20104b8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20104bc: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 20104c0: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 20104c4: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 20104c8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20104cc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20104d0: 7f ff e8 a0 call 200a750 <== NOT EXECUTED 20104d4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20104d8: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 20104dc: 92 10 20 00 clr %o1 <== NOT EXECUTED 20104e0: 40 00 0d 5d call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20104e4: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 20104e8: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20104ec: 11 00 80 c9 sethi %hi(0x2032400), %o0 20104f0: f0 00 62 d0 ld [ %g1 + 0x2d0 ], %i0 20104f4: 90 12 20 0c or %o0, 0xc, %o0 20104f8: 92 10 00 12 mov %l2, %o1 20104fc: 40 00 11 59 call 2014a60 <_Objects_Get_no_protection> 2010500: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 2010504: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010508: 80 a0 60 01 cmp %g1, 1 201050c: 02 80 00 0a be 2010534 2010510: a0 10 00 08 mov %o0, %l0 2010514: 80 a0 60 01 cmp %g1, 1 2010518: 2a 80 00 22 bcs,a 20105a0 201051c: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010520: 80 a0 60 02 cmp %g1, 2 2010524: 12 80 00 10 bne 2010564 2010528: b0 10 20 19 mov 0x19, %i0 201052c: 10 80 00 10 b 201056c 2010530: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010534: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010538: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201053c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010540: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010544: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010548: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 201054c: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010550: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010554: 40 00 0d 62 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 2010558: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 201055c: 7f ff ff 5c call 20102cc <_Thread_Enable_dispatch> <== NOT EXECUTED 2010560: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2010564: 81 c7 e0 08 ret <== NOT EXECUTED 2010568: 81 e8 00 00 restore <== NOT EXECUTED 201056c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010570: 82 00 60 01 inc %g1 2010574: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010578: 03 00 80 c9 sethi %hi(0x2032400), %g1 201057c: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010580: 94 10 20 00 clr %o2 2010584: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010588: 40 00 0d 55 call 2013adc <_CORE_mutex_Surrender> 201058c: 90 02 20 10 add %o0, 0x10, %o0 2010590: 7f ff ff 4f call 20102cc <_Thread_Enable_dispatch> 2010594: b0 10 20 04 mov 4, %i0 2010598: 81 c7 e0 08 ret 201059c: 81 e8 00 00 restore return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 20105a0: 80 a6 40 01 cmp %i1, %g1 20105a4: 08 80 00 0f bleu 20105e0 20105a8: 05 00 80 c9 sethi %hi(0x2032400), %g2 20105ac: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 20105b0: 82 00 60 01 inc %g1 20105b4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 20105b8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20105bc: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20105c0: 94 10 20 00 clr %o2 20105c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 20105c8: 40 00 0d 45 call 2013adc <_CORE_mutex_Surrender> 20105cc: 90 02 20 10 add %o0, 0x10, %o0 20105d0: 7f ff ff 3f call 20102cc <_Thread_Enable_dispatch> 20105d4: b0 10 20 08 mov 8, %i0 20105d8: 81 c7 e0 08 ret 20105dc: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 20105e0: 90 02 20 68 add %o0, 0x68, %o0 20105e4: 40 00 0e 52 call 2013f2c <_Heap_Allocate> 20105e8: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 20105ec: a2 92 20 00 orcc %o0, 0, %l1 20105f0: 02 80 00 13 be 201063c 20105f4: 07 00 80 c9 sethi %hi(0x2032400), %g3 the_region->number_of_used_blocks += 1; 20105f8: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 20105fc: c4 00 e1 f0 ld [ %g3 + 0x1f0 ], %g2 2010600: 82 00 60 01 inc %g1 2010604: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010608: 84 00 a0 01 inc %g2 201060c: c4 20 e1 f0 st %g2, [ %g3 + 0x1f0 ] _RTEMS_Unlock_allocator(); 2010610: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010614: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010618: 94 10 20 00 clr %o2 201061c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010620: 40 00 0d 2f call 2013adc <_CORE_mutex_Surrender> 2010624: 90 02 20 10 add %o0, 0x10, %o0 2010628: 7f ff ff 29 call 20102cc <_Thread_Enable_dispatch> 201062c: b0 10 20 00 clr %i0 *segment = the_segment; 2010630: e2 27 00 00 st %l1, [ %i4 ] 2010634: 81 c7 e0 08 ret 2010638: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 201063c: 80 8e a0 01 btst 1, %i2 2010640: 05 00 80 c9 sethi %hi(0x2032400), %g2 2010644: 02 80 00 0e be 201067c 2010648: 07 00 80 c9 sethi %hi(0x2032400), %g3 201064c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010650: 82 00 60 01 inc %g1 2010654: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 2010658: d0 00 e2 c8 ld [ %g3 + 0x2c8 ], %o0 201065c: 94 10 20 00 clr %o2 2010660: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010664: 40 00 0d 1e call 2013adc <_CORE_mutex_Surrender> 2010668: 90 02 20 10 add %o0, 0x10, %o0 201066c: 7f ff ff 18 call 20102cc <_Thread_Enable_dispatch> 2010670: b0 10 20 0d mov 0xd, %i0 2010674: 81 c7 e0 08 ret 2010678: 81 e8 00 00 restore 201067c: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 2010680: 82 00 60 01 inc %g1 2010684: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 2010688: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 201068c: 82 00 60 01 inc %g1 2010690: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * 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(); 2010694: d0 00 e2 c8 ld [ %g3 + 0x2c8 ], %o0 2010698: 94 10 20 00 clr %o2 201069c: d2 02 20 08 ld [ %o0 + 8 ], %o1 20106a0: 40 00 0d 0f call 2013adc <_CORE_mutex_Surrender> 20106a4: 90 02 20 10 add %o0, 0x10, %o0 20106a8: 7f ff ff 09 call 20102cc <_Thread_Enable_dispatch> 20106ac: 01 00 00 00 nop executing->Wait.queue = &the_region->Wait_queue; 20106b0: 82 04 20 10 add %l0, 0x10, %g1 executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 20106b4: 92 10 00 1b mov %i3, %o1 20106b8: 90 10 00 01 mov %g1, %o0 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 20106bc: c2 26 20 44 st %g1, [ %i0 + 0x44 ] executing->Wait.count = size; executing->Wait.return_argument = segment; _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 20106c0: 15 00 80 5a sethi %hi(0x2016800), %o2 20106c4: 82 10 20 01 mov 1, %g1 20106c8: 94 12 a1 b8 or %o2, 0x1b8, %o2 */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; executing->Wait.id = id; 20106cc: e4 26 20 20 st %l2, [ %i0 + 0x20 ] executing->Wait.count = size; 20106d0: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 20106d4: f8 26 20 28 st %i4, [ %i0 + 0x28 ] _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 20106d8: 40 00 17 92 call 2016520 <_Thread_queue_Enqueue_with_handler> 20106dc: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Thread_Enable_dispatch(); 20106e0: 7f ff fe fb call 20102cc <_Thread_Enable_dispatch> 20106e4: 01 00 00 00 nop return (rtems_status_code) executing->Wait.return_code; 20106e8: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20106ec: 81 c7 e0 08 ret 20106f0: 81 e8 00 00 restore 02010760 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 2010760: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2010764: 7f ff e7 f7 call 200a740 2010768: 01 00 00 00 nop 201076c: a2 10 00 08 mov %o0, %l1 2010770: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010774: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2010778: 80 a0 60 00 cmp %g1, 0 201077c: 02 80 00 0b be 20107a8 2010780: 03 00 80 c9 sethi %hi(0x2032400), %g1 2010784: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010788: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 20327d0 <_System_state_Current> <== NOT EXECUTED 201078c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010790: 08 80 00 05 bleu 20107a4 <== NOT EXECUTED 2010794: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010798: 92 10 20 00 clr %o1 <== NOT EXECUTED 201079c: 40 00 0f 40 call 201449c <_Internal_error_Occurred> <== NOT EXECUTED 20107a0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20107a4: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20107a8: e0 00 62 c8 ld [ %g1 + 0x2c8 ], %l0 ! 20326c8 <_RTEMS_Allocator_Mutex> Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20107ac: 03 00 80 c9 sethi %hi(0x2032400), %g1 20107b0: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 20326d0 <_Thread_Executing> executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20107b4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20107b8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20107bc: 80 a0 60 00 cmp %g1, 0 20107c0: 22 80 00 33 be,a 201088c 20107c4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20107c8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20107cc: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 20107d0: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20107d4: c2 24 20 70 st %g1, [ %l0 + 0x70 ] 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; 20107d8: c4 24 20 6c st %g2, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; 20107dc: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20107e0: 80 a0 e0 02 cmp %g3, 2 20107e4: 02 80 00 05 be 20107f8 20107e8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 20107ec: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20107f0: 32 80 00 06 bne,a 2010808 <== NOT EXECUTED 20107f4: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20107f8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 20107fc: 82 00 60 01 inc %g1 2010800: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010804: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2010808: 80 a0 60 03 cmp %g1, 3 201080c: 22 80 00 03 be,a 2010818 2010810: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2010814: 30 80 00 2c b,a 20108c4 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2010818: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201081c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010820: 12 80 00 03 bne 201082c <== NOT EXECUTED 2010824: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2010828: 30 80 00 27 b,a 20108c4 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 201082c: 08 80 00 10 bleu 201086c <== NOT EXECUTED 2010830: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010834: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010838: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201083c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010840: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010844: 7f ff e7 c3 call 200a750 <== NOT EXECUTED 2010848: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 201084c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010850: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010854: 40 00 14 5f call 20159d0 <_Thread_Change_priority> <== NOT EXECUTED 2010858: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 201085c: 7f ff ff b4 call 201072c <_Thread_Enable_dispatch> <== NOT EXECUTED 2010860: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010864: 10 80 00 32 b 201092c <== NOT EXECUTED 2010868: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 201086c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010870: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010874: c0 24 20 64 clr [ %l0 + 0x64 ] <== 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; 2010878: c2 24 20 60 st %g1, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 201087c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010880: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010884: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010888: 30 80 00 0f b,a 20108c4 <== 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 ) ) { 201088c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010890: 32 80 00 13 bne,a 20108dc <== NOT EXECUTED 2010894: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010898: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 ! 2032450 <_Region_Information+0x44> <== NOT EXECUTED 201089c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20108a0: 22 80 00 07 be,a 20108bc <== NOT EXECUTED 20108a4: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20108a8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20108ac: 12 80 00 0c bne 20108dc <== NOT EXECUTED 20108b0: 21 00 80 c9 sethi %hi(0x2032400), %l0 <== NOT EXECUTED 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; 20108b4: 10 80 00 08 b 20108d4 <== NOT EXECUTED 20108b8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 20108bc: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108c0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20108c4: 7f ff e7 a3 call 200a750 20108c8: 90 10 00 11 mov %l1, %o0 20108cc: 10 80 00 18 b 201092c 20108d0: 92 10 00 18 mov %i0, %o1 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 20108d4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20108d8: 30 bf ff fb b,a 20108c4 <== NOT EXECUTED 20108dc: c6 04 22 c8 ld [ %l0 + 0x2c8 ], %g3 <== NOT EXECUTED 20108e0: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 20108e4: da 00 e0 08 ld [ %g3 + 8 ], %o5 <== NOT EXECUTED 20108e8: c8 00 62 d0 ld [ %g1 + 0x2d0 ], %g4 <== NOT EXECUTED 20108ec: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 20108f0: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20108f4: da 21 20 20 st %o5, [ %g4 + 0x20 ] <== NOT EXECUTED 20108f8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20108fc: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 2010900: 82 00 e0 10 add %g3, 0x10, %g1 <== NOT EXECUTED 2010904: c2 21 20 44 st %g1, [ %g4 + 0x44 ] <== NOT EXECUTED 2010908: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 201090c: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010910: 7f ff e7 90 call 200a750 <== NOT EXECUTED 2010914: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010918: d0 04 22 c8 ld [ %l0 + 0x2c8 ], %o0 <== NOT EXECUTED 201091c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010920: 40 00 0c 4d call 2013a54 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010924: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010928: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 201092c: 11 00 80 c9 sethi %hi(0x2032400), %o0 2010930: 94 07 bf f4 add %fp, -12, %o2 2010934: 40 00 10 4b call 2014a60 <_Objects_Get_no_protection> 2010938: 90 12 20 0c or %o0, 0xc, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 201093c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010940: 80 a0 60 01 cmp %g1, 1 2010944: 02 80 00 0a be 201096c 2010948: a0 10 00 08 mov %o0, %l0 201094c: 80 a0 60 01 cmp %g1, 1 2010950: 0a 80 00 22 bcs 20109d8 2010954: 92 10 00 19 mov %i1, %o1 2010958: 80 a0 60 02 cmp %g1, 2 201095c: 12 80 00 10 bne 201099c 2010960: b0 10 20 19 mov 0x19, %i0 2010964: 10 80 00 10 b 20109a4 2010968: 05 00 80 c9 sethi %hi(0x2032400), %g2 case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 201096c: 05 00 80 c9 sethi %hi(0x2032400), %g2 <== NOT EXECUTED 2010970: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2010974: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010978: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] <== NOT EXECUTED 201097c: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2010980: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> <== NOT EXECUTED 2010984: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010988: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 201098c: 40 00 0c 54 call 2013adc <_CORE_mutex_Surrender> <== NOT EXECUTED 2010990: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010994: 7f ff ff 66 call 201072c <_Thread_Enable_dispatch> <== NOT EXECUTED 2010998: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 201099c: 81 c7 e0 08 ret <== NOT EXECUTED 20109a0: 81 e8 00 00 restore <== NOT EXECUTED 20109a4: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 20109a8: 82 00 60 01 inc %g1 20109ac: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 20109b0: 03 00 80 c9 sethi %hi(0x2032400), %g1 20109b4: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 20109b8: 94 10 20 00 clr %o2 20109bc: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109c0: 40 00 0c 47 call 2013adc <_CORE_mutex_Surrender> 20109c4: 90 02 20 10 add %o0, 0x10, %o0 20109c8: 7f ff ff 59 call 201072c <_Thread_Enable_dispatch> 20109cc: b0 10 20 04 mov 4, %i0 20109d0: 81 c7 e0 08 ret 20109d4: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 20109d8: 40 00 0d ad call 201408c <_Heap_Free> 20109dc: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 20109e0: 80 a2 20 00 cmp %o0, 0 20109e4: 12 80 00 0f bne 2010a20 20109e8: 05 00 80 c9 sethi %hi(0x2032400), %g2 20109ec: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 20109f0: 82 00 60 01 inc %g1 20109f4: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] _RTEMS_Unlock_allocator(); 20109f8: 03 00 80 c9 sethi %hi(0x2032400), %g1 20109fc: d0 00 62 c8 ld [ %g1 + 0x2c8 ], %o0 ! 20326c8 <_RTEMS_Allocator_Mutex> 2010a00: 94 10 20 00 clr %o2 2010a04: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010a08: 40 00 0c 35 call 2013adc <_CORE_mutex_Surrender> 2010a0c: 90 02 20 10 add %o0, 0x10, %o0 2010a10: 7f ff ff 47 call 201072c <_Thread_Enable_dispatch> 2010a14: b0 10 20 09 mov 9, %i0 2010a18: 81 c7 e0 08 ret 2010a1c: 81 e8 00 00 restore return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a20: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a24: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2010a28: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2010a2c: b0 10 20 00 clr %i0 2010a30: 40 00 25 70 call 2019ff0 <_Region_Process_queue> 2010a34: c2 24 20 64 st %g1, [ %l0 + 0x64 ] return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2010a38: 81 c7 e0 08 ret 2010a3c: 81 e8 00 00 restore 02005608 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 2005608: 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 ) ) 200560c: a8 96 20 00 orcc %i0, 0, %l4 2005610: 02 80 00 2c be 20056c0 2005614: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005618: 80 a7 20 00 cmp %i4, 0 200561c: 02 80 00 29 be 20056c0 2005620: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 2005624: a4 8e a0 40 andcc %i2, 0x40, %l2 2005628: 12 80 00 06 bne 2005640 200562c: 82 0e a0 30 and %i2, 0x30, %g1 2005630: 80 8e a0 80 btst 0x80, %i2 2005634: 02 80 00 10 be 2005674 2005638: a6 0e a0 30 and %i2, 0x30, %l3 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 200563c: 82 0e a0 30 and %i2, 0x30, %g1 _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005640: 80 a0 60 10 cmp %g1, 0x10 2005644: 02 80 00 05 be 2005658 2005648: 80 8e a0 04 btst 4, %i2 200564c: 80 a0 60 20 cmp %g1, 0x20 2005650: 12 80 00 71 bne 2005814 2005654: 80 8e a0 04 btst 4, %i2 2005658: 02 80 00 6f be 2005814 200565c: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 2005660: 02 80 00 04 be 2005670 2005664: 80 8e a0 80 btst 0x80, %i2 2005668: 32 80 00 16 bne,a 20056c0 200566c: b0 10 20 0b mov 0xb, %i0 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 2005670: a6 0e a0 30 and %i2, 0x30, %l3 2005674: 80 a0 00 13 cmp %g0, %l3 2005678: a2 60 3f ff subx %g0, -1, %l1 _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 200567c: 80 a4 60 00 cmp %l1, 0 2005680: 12 80 00 04 bne 2005690 2005684: 80 a6 60 01 cmp %i1, 1 2005688: 18 80 00 0e bgu 20056c0 200568c: b0 10 20 0a mov 0xa, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005690: 03 00 80 62 sethi %hi(0x2018800), %g1 2005694: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2005698: 84 00 a0 01 inc %g2 200569c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 20056a0: 11 00 80 62 sethi %hi(0x2018800), %o0 20056a4: 40 00 07 05 call 20072b8 <_Objects_Allocate> 20056a8: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20189a0 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 20056ac: a0 92 20 00 orcc %o0, 0, %l0 20056b0: 12 80 00 06 bne 20056c8 20056b4: 80 a4 60 00 cmp %l1, 0 _Thread_Enable_dispatch(); 20056b8: 7f ff ff c7 call 20055d4 <_Thread_Enable_dispatch> 20056bc: b0 10 20 05 mov 5, %i0 20056c0: 81 c7 e0 08 ret 20056c4: 81 e8 00 00 restore * If it is not a counting semaphore, then it is either a * simple binary semaphore or a more powerful mutex style binary * semaphore. */ if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { 20056c8: 12 80 00 32 bne 2005790 20056cc: f4 24 20 10 st %i2, [ %l0 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 20056d0: 80 a4 a0 00 cmp %l2, 0 20056d4: 12 80 00 06 bne 20056ec 20056d8: 82 10 20 02 mov 2, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 20056dc: 80 8e a0 80 btst 0x80, %i2 20056e0: 02 80 00 05 be 20056f4 20056e4: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 20056e8: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 20056ec: 10 80 00 05 b 2005700 20056f0: c2 27 bf e8 st %g1, [ %fp + -24 ] else if ( _Attributes_Is_priority( attribute_set ) ) 20056f4: 12 bf ff fe bne 20056ec 20056f8: 82 10 20 01 mov 1, %g1 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; 20056fc: c0 27 bf e8 clr [ %fp + -24 ] if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 2005700: 80 a4 e0 10 cmp %l3, 0x10 2005704: 12 80 00 0f bne 2005740 2005708: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 200570c: c2 07 bf e8 ld [ %fp + -24 ], %g1 2005710: 80 a0 60 01 cmp %g1, 1 2005714: 08 80 00 07 bleu 2005730 2005718: c0 27 bf e0 clr [ %fp + -32 ] 200571c: 80 a0 60 03 cmp %g1, 3 2005720: 38 80 00 0b bgu,a 200574c 2005724: 82 1e 60 01 xor %i1, 1, %g1 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 2005728: 10 80 00 04 b 2005738 200572c: 82 10 20 01 mov 1, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 2005730: 10 80 00 06 b 2005748 2005734: c0 27 bf e4 clr [ %fp + -28 ] break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 2005738: 10 80 00 04 b 2005748 200573c: c2 27 bf e4 st %g1, [ %fp + -28 ] break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 2005740: c0 27 bf e4 clr [ %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; 2005744: 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( 2005748: 82 1e 60 01 xor %i1, 1, %g1 200574c: 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; 2005750: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005754: 94 60 3f ff subx %g0, -1, %o2 2005758: 90 04 20 14 add %l0, 0x14, %o0 200575c: 40 00 04 62 call 20068e4 <_CORE_mutex_Initialize> 2005760: 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 ) { 2005764: 80 a2 20 06 cmp %o0, 6 2005768: 12 80 00 17 bne 20057c4 200576c: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005770: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 2005774: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 20189a0 <_Semaphore_Information> <== NOT EXECUTED 2005778: 40 00 07 d2 call 20076c0 <_Objects_Free> <== NOT EXECUTED 200577c: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 2005780: 7f ff ff 95 call 20055d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005784: 01 00 00 00 nop <== NOT EXECUTED 2005788: 81 c7 e0 08 ret <== NOT EXECUTED 200578c: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 2005790: 80 8e a0 04 btst 4, %i2 2005794: 22 80 00 04 be,a 20057a4 2005798: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 200579c: 82 10 20 01 mov 1, %g1 20057a0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20057a4: 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; 20057a8: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 20057ac: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 20057b0: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 20057b4: 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( 20057b8: 90 04 20 14 add %l0, 0x14, %o0 20057bc: 40 00 04 f9 call 2006ba0 <_CORE_semaphore_Initialize> 20057c0: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057c4: 03 00 80 62 sethi %hi(0x2018800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20057c8: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20057cc: 88 10 61 a0 or %g1, 0x1a0, %g4 20057d0: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 20057d4: 03 00 00 3f sethi %hi(0xfc00), %g1 20057d8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20057dc: 82 08 c0 01 and %g3, %g1, %g1 20057e0: 80 a0 40 02 cmp %g1, %g2 20057e4: 38 80 00 06 bgu,a 20057fc 20057e8: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 20057ec: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 20057f0: 83 28 60 02 sll %g1, 2, %g1 20057f4: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 20057f8: c2 04 20 08 ld [ %l0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 20057fc: e8 24 20 0c st %l4, [ %l0 + 0xc ] 2005800: c2 27 00 00 st %g1, [ %i4 ] the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 2005804: 7f ff ff 74 call 20055d4 <_Thread_Enable_dispatch> 2005808: b0 10 20 00 clr %i0 200580c: 81 c7 e0 08 ret 2005810: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; 2005814: b0 10 20 0b mov 0xb, %i0 } 2005818: 81 c7 e0 08 ret 200581c: 81 e8 00 00 restore 02005854 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 2005854: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005858: 11 00 80 62 sethi %hi(0x2018800), %o0 200585c: 92 10 00 18 mov %i0, %o1 2005860: 90 12 21 a0 or %o0, 0x1a0, %o0 2005864: 40 00 07 d9 call 20077c8 <_Objects_Get> 2005868: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 200586c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005870: 80 a0 60 00 cmp %g1, 0 2005874: 02 80 00 07 be 2005890 2005878: b0 10 00 08 mov %o0, %i0 200587c: 80 a0 60 02 cmp %g1, 2 2005880: 08 80 00 10 bleu 20058c0 2005884: b0 10 20 04 mov 4, %i0 2005888: 81 c7 e0 08 ret <== NOT EXECUTED 200588c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 2005890: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005894: 84 88 60 30 andcc %g1, 0x30, %g2 2005898: 22 80 00 12 be,a 20058e0 200589c: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 20058a0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 20058a4: 80 a0 60 00 cmp %g1, 0 20058a8: 12 80 00 08 bne 20058c8 20058ac: 80 a0 a0 20 cmp %g2, 0x20 20058b0: 02 80 00 07 be 20058cc 20058b4: 90 06 20 14 add %i0, 0x14, %o0 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 20058b8: 7f ff ff da call 2005820 <_Thread_Enable_dispatch> 20058bc: b0 10 20 0c mov 0xc, %i0 20058c0: 81 c7 e0 08 ret 20058c4: 81 e8 00 00 restore return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 20058c8: 90 06 20 14 add %i0, 0x14, %o0 20058cc: 92 10 20 00 clr %o1 20058d0: 40 00 04 01 call 20068d4 <_CORE_mutex_Flush> 20058d4: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058d8: 10 80 00 06 b 20058f0 20058dc: 03 00 80 62 sethi %hi(0x2018800), %g1 &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 20058e0: 92 10 20 00 clr %o1 20058e4: 40 00 04 ab call 2006b90 <_CORE_semaphore_Flush> 20058e8: 94 10 20 02 mov 2, %o2 20058ec: 03 00 80 62 sethi %hi(0x2018800), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20058f0: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20058f4: 90 10 61 a0 or %g1, 0x1a0, %o0 20058f8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 20058fc: 03 00 00 3f sethi %hi(0xfc00), %g1 2005900: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005904: 82 08 c0 01 and %g3, %g1, %g1 2005908: 80 a0 40 02 cmp %g1, %g2 200590c: 18 80 00 05 bgu 2005920 2005910: 92 10 00 18 mov %i0, %o1 information->local_table[ index ] = the_object; 2005914: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005918: 83 28 60 02 sll %g1, 2, %g1 200591c: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 2005920: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005924: 40 00 07 67 call 20076c0 <_Objects_Free> 2005928: b0 10 20 00 clr %i0 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 200592c: 7f ff ff bd call 2005820 <_Thread_Enable_dispatch> 2005930: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005934: 81 c7 e0 08 ret 2005938: 81 e8 00 00 restore 02005d98 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 2005d98: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005d9c: 11 00 80 6a sethi %hi(0x201a800), %o0 2005da0: 92 10 00 18 mov %i0, %o1 2005da4: 90 12 23 68 or %o0, 0x368, %o0 2005da8: 40 00 08 56 call 2007f00 <_Objects_Get> 2005dac: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005db0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005db4: 80 a0 60 00 cmp %g1, 0 2005db8: 22 80 00 07 be,a 2005dd4 2005dbc: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005dc0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2005dc4: 08 80 00 19 bleu 2005e28 <== NOT EXECUTED 2005dc8: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2005dcc: 81 c7 e0 08 ret <== NOT EXECUTED 2005dd0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005dd4: 80 88 60 30 btst 0x30, %g1 2005dd8: 02 80 00 06 be 2005df0 2005ddc: 90 02 20 14 add %o0, 0x14, %o0 _CORE_mutex_Flush( 2005de0: 92 10 20 00 clr %o1 2005de4: 40 00 04 8a call 200700c <_CORE_mutex_Flush> 2005de8: 94 10 20 01 mov 1, %o2 2005dec: 30 80 00 04 b,a 2005dfc &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 2005df0: 92 10 20 00 clr %o1 <== NOT EXECUTED 2005df4: 40 00 05 35 call 20072c8 <_CORE_semaphore_Flush> <== NOT EXECUTED 2005df8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005dfc: 03 00 80 6b sethi %hi(0x201ac00), %g1 2005e00: c4 00 60 b0 ld [ %g1 + 0xb0 ], %g2 ! 201acb0 <_Thread_Dispatch_disable_level> 2005e04: b0 10 20 00 clr %i0 2005e08: 84 00 bf ff add %g2, -1, %g2 2005e0c: c4 20 60 b0 st %g2, [ %g1 + 0xb0 ] 2005e10: c2 00 60 b0 ld [ %g1 + 0xb0 ], %g1 2005e14: 80 a0 60 00 cmp %g1, 0 2005e18: 12 80 00 04 bne 2005e28 2005e1c: 01 00 00 00 nop _Thread_Dispatch(); 2005e20: 40 00 0c fe call 2009218 <_Thread_Dispatch> 2005e24: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e28: 81 c7 e0 08 ret 2005e2c: 81 e8 00 00 restore 02005970 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 2005970: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 2005974: 11 00 80 62 sethi %hi(0x2018800), %o0 2005978: 92 10 00 18 mov %i0, %o1 200597c: 90 12 21 a0 or %o0, 0x1a0, %o0 2005980: 94 07 bf f4 add %fp, -12, %o2 2005984: 40 00 07 73 call 2007750 <_Objects_Get_isr_disable> 2005988: 96 07 bf f0 add %fp, -16, %o3 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 200598c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005990: 80 a0 60 00 cmp %g1, 0 2005994: 02 80 00 07 be 20059b0 2005998: a0 10 00 08 mov %o0, %l0 200599c: 80 a0 60 02 cmp %g1, 2 20059a0: 08 80 00 ab bleu 2005c4c 20059a4: 90 10 20 04 mov 4, %o0 20059a8: 10 80 00 a9 b 2005c4c <== NOT EXECUTED 20059ac: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 20059b0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20059b4: 80 88 60 30 btst 0x30, %g1 20059b8: 02 80 00 7c be 2005ba8 20059bc: 03 00 80 62 sethi %hi(0x2018800), %g1 _CORE_mutex_Seize( 20059c0: 03 00 80 62 sethi %hi(0x2018800), %g1 20059c4: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> 20059c8: 80 a0 60 00 cmp %g1, 0 20059cc: 02 80 00 0e be 2005a04 20059d0: 03 00 80 62 sethi %hi(0x2018800), %g1 20059d4: 80 8e 60 01 btst 1, %i1 20059d8: 12 80 00 0c bne 2005a08 20059dc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 20059e0: 03 00 80 63 sethi %hi(0x2018c00), %g1 20059e4: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 20059e8: 80 a0 60 01 cmp %g1, 1 20059ec: 08 80 00 05 bleu 2005a00 20059f0: 90 10 20 00 clr %o0 20059f4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20059f8: 40 00 06 03 call 2007204 <_Internal_error_Occurred> <== NOT EXECUTED 20059fc: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005a00: 03 00 80 62 sethi %hi(0x2018800), %g1 2005a04: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 2018bd0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005a08: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2005a0c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2005a10: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 2005a14: 80 a0 60 00 cmp %g1, 0 2005a18: 22 80 00 33 be,a 2005ae4 2005a1c: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2005a20: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 2005a24: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 2005a28: c2 00 a0 08 ld [ %g2 + 8 ], %g1 */ RTEMS_INLINE_ROUTINE boolean _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2005a2c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2005a30: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; 2005a34: 82 10 20 01 mov 1, %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005a38: 80 a0 e0 02 cmp %g3, 2 2005a3c: 02 80 00 05 be 2005a50 2005a40: c2 24 20 68 st %g1, [ %l0 + 0x68 ] 2005a44: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2005a48: 32 80 00 06 bne,a 2005a60 <== NOT EXECUTED 2005a4c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2005a50: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2005a54: 82 00 60 01 inc %g1 2005a58: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2005a5c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005a60: 80 a0 60 03 cmp %g1, 3 2005a64: 22 80 00 03 be,a 2005a70 2005a68: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 <== NOT EXECUTED _ISR_Enable( level ); 2005a6c: 30 80 00 2e b,a 2005b24 { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 2005a70: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2005a74: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2005a78: 12 80 00 03 bne 2005a84 <== NOT EXECUTED 2005a7c: 01 00 00 00 nop <== NOT EXECUTED _ISR_Enable( level ); 2005a80: 30 80 00 29 b,a 2005b24 <== NOT EXECUTED return 0; } if ( current > ceiling ) { 2005a84: 28 80 00 10 bleu,a 2005ac4 <== NOT EXECUTED 2005a88: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005a8c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2005a90: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 2018af0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005a94: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005a98: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2005a9c: 7f ff f0 b4 call 2001d6c <== NOT EXECUTED 2005aa0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 2005aa4: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 2005aa8: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 2005aac: 40 00 0b 0f call 20086e8 <_Thread_Change_priority> <== NOT EXECUTED 2005ab0: 94 10 20 00 clr %o2 <== NOT EXECUTED the_mutex->holder, the_mutex->Attributes.priority_ceiling, FALSE ); _Thread_Enable_dispatch(); 2005ab4: 7f ff ff a2 call 200593c <_Thread_Enable_dispatch> <== NOT EXECUTED 2005ab8: 01 00 00 00 nop <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 2005abc: 10 80 00 36 b 2005b94 <== NOT EXECUTED 2005ac0: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2005ac4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2005ac8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2005acc: c0 24 20 68 clr [ %l0 + 0x68 ] <== 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; 2005ad0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ executing->resource_count--; /* undo locking above */ 2005ad4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2005ad8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005adc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2005ae0: 30 80 00 11 b,a 2005b24 <== 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 ) ) { 2005ae4: 80 a0 40 02 cmp %g1, %g2 2005ae8: 12 80 00 13 bne 2005b34 2005aec: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2005af0: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2005af4: 80 a0 60 00 cmp %g1, 0 2005af8: 22 80 00 07 be,a 2005b14 2005afc: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 2005b00: 80 a0 60 01 cmp %g1, 1 2005b04: 12 80 00 0c bne 2005b34 2005b08: 80 8e 60 01 btst 1, %i1 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; 2005b0c: 10 80 00 05 b 2005b20 <== NOT EXECUTED 2005b10: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED * 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++; 2005b14: 82 00 60 01 inc %g1 2005b18: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 2005b1c: 30 80 00 02 b,a 2005b24 return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 2005b20: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2005b24: 7f ff f0 92 call 2001d6c 2005b28: 01 00 00 00 nop 2005b2c: 10 80 00 1a b 2005b94 2005b30: 03 00 80 62 sethi %hi(0x2018800), %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005b34: 02 80 00 08 be 2005b54 2005b38: 23 00 80 62 sethi %hi(0x2018800), %l1 2005b3c: 7f ff f0 8c call 2001d6c 2005b40: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b44: c4 04 63 d0 ld [ %l1 + 0x3d0 ], %g2 2005b48: 82 10 20 01 mov 1, %g1 2005b4c: 10 80 00 11 b 2005b90 2005b50: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2005b54: c6 04 63 d0 ld [ %l1 + 0x3d0 ], %g3 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2005b58: 82 10 20 01 mov 1, %g1 2005b5c: 05 00 80 62 sethi %hi(0x2018800), %g2 2005b60: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 2005b64: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005b68: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 2005b6c: 82 00 60 01 inc %g1 2005b70: a0 04 20 14 add %l0, 0x14, %l0 2005b74: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005b78: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 2005b7c: 7f ff f0 7c call 2001d6c 2005b80: d0 07 bf f0 ld [ %fp + -16 ], %o0 2005b84: 90 10 00 10 mov %l0, %o0 2005b88: 40 00 03 85 call 200699c <_CORE_mutex_Seize_interrupt_blocking> 2005b8c: 92 10 00 1a mov %i2, %o1 id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 2005b90: 03 00 80 62 sethi %hi(0x2018800), %g1 2005b94: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2005b98: 40 00 00 62 call 2005d20 <_Semaphore_Translate_core_mutex_return_code> 2005b9c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005ba0: 81 c7 e0 08 ret 2005ba4: 91 e8 00 08 restore %g0, %o0, %o0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005ba8: e2 00 63 d0 ld [ %g1 + 0x3d0 ], %l1 Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005bac: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2005bb0: c0 24 60 34 clr [ %l1 + 0x34 ] if ( the_semaphore->count != 0 ) { 2005bb4: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005bb8: 80 a0 60 00 cmp %g1, 0 2005bbc: 02 80 00 08 be 2005bdc 2005bc0: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; 2005bc4: 82 00 7f ff add %g1, -1, %g1 2005bc8: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 2005bcc: 7f ff f0 68 call 2001d6c 2005bd0: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2005bd4: 10 80 00 1b b 2005c40 2005bd8: 03 00 80 62 sethi %hi(0x2018800), %g1 return; } if ( !wait ) { 2005bdc: 02 80 00 07 be 2005bf8 2005be0: 05 00 80 62 sethi %hi(0x2018800), %g2 _ISR_Enable( level ); 2005be4: 7f ff f0 62 call 2001d6c 2005be8: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 2005bec: 82 10 20 01 mov 1, %g1 ! 1 2005bf0: 10 80 00 13 b 2005c3c 2005bf4: c2 24 60 34 st %g1, [ %l1 + 0x34 ] 2005bf8: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 2005bfc: 82 00 60 01 inc %g1 2005c00: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2005c04: 82 10 20 01 mov 1, %g1 2005c08: c2 24 20 44 st %g1, [ %l0 + 0x44 ] } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; 2005c0c: f0 24 60 20 st %i0, [ %l1 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 2005c10: a0 04 20 14 add %l0, 0x14, %l0 2005c14: e0 24 60 44 st %l0, [ %l1 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 2005c18: 7f ff f0 55 call 2001d6c 2005c1c: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 2005c20: 90 10 00 10 mov %l0, %o0 2005c24: 92 10 00 1a mov %i2, %o1 2005c28: 15 00 80 25 sethi %hi(0x2009400), %o2 2005c2c: 40 00 0d 83 call 2009238 <_Thread_queue_Enqueue_with_handler> 2005c30: 94 12 a2 d0 or %o2, 0x2d0, %o2 ! 20096d0 <_Thread_queue_Timeout> _Thread_Enable_dispatch(); 2005c34: 7f ff ff 42 call 200593c <_Thread_Enable_dispatch> 2005c38: 01 00 00 00 nop 2005c3c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005c40: c2 00 63 d0 ld [ %g1 + 0x3d0 ], %g1 ! 2018bd0 <_Thread_Executing> 2005c44: 40 00 00 41 call 2005d48 <_Semaphore_Translate_core_semaphore_return_code> 2005c48: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005c4c: b0 10 00 08 mov %o0, %i0 2005c50: 81 c7 e0 08 ret 2005c54: 81 e8 00 00 restore 02005c8c : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 2005c8c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005c90: 11 00 80 62 sethi %hi(0x2018800), %o0 2005c94: 92 10 00 18 mov %i0, %o1 2005c98: 90 12 21 a0 or %o0, 0x1a0, %o0 2005c9c: 40 00 06 cb call 20077c8 <_Objects_Get> 2005ca0: 94 07 bf f4 add %fp, -12, %o2 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005ca4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005ca8: 80 a0 60 00 cmp %g1, 0 2005cac: 22 80 00 07 be,a 2005cc8 2005cb0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005cb4: 80 a0 60 02 cmp %g1, 2 2005cb8: 08 80 00 17 bleu 2005d14 2005cbc: 90 10 20 04 mov 4, %o0 2005cc0: 10 80 00 15 b 2005d14 <== NOT EXECUTED 2005cc4: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005cc8: 80 88 60 30 btst 0x30, %g1 2005ccc: 02 80 00 0b be 2005cf8 2005cd0: 90 02 20 14 add %o0, 0x14, %o0 mutex_status = _CORE_mutex_Surrender( 2005cd4: 92 10 00 18 mov %i0, %o1 2005cd8: 40 00 03 53 call 2006a24 <_CORE_mutex_Surrender> 2005cdc: 94 10 20 00 clr %o2 &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005ce0: 7f ff ff de call 2005c58 <_Thread_Enable_dispatch> 2005ce4: a0 10 00 08 mov %o0, %l0 return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 2005ce8: 40 00 00 0e call 2005d20 <_Semaphore_Translate_core_mutex_return_code> 2005cec: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005cf0: 81 c7 e0 08 ret 2005cf4: 91 e8 00 08 restore %g0, %o0, %o0 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 2005cf8: 92 10 00 18 mov %i0, %o1 2005cfc: 40 00 03 b8 call 2006bdc <_CORE_semaphore_Surrender> 2005d00: 94 10 20 00 clr %o2 &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 2005d04: 7f ff ff d5 call 2005c58 <_Thread_Enable_dispatch> 2005d08: a0 10 00 08 mov %o0, %l0 return 2005d0c: 40 00 00 0f call 2005d48 <_Semaphore_Translate_core_semaphore_return_code> 2005d10: 90 10 00 10 mov %l0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005d14: b0 10 00 08 mov %o0, %i0 2005d18: 81 c7 e0 08 ret 2005d1c: 81 e8 00 00 restore 02016334 : */ void rtems_shutdown_executive( uint32_t result ) { 2016334: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 2016338: 33 00 80 63 sethi %hi(0x2018c00), %i1 201633c: c2 06 60 d0 ld [ %i1 + 0xd0 ], %g1 ! 2018cd0 <_System_state_Current> 2016340: 80 a0 60 04 cmp %g1, 4 2016344: 02 80 00 0c be 2016374 2016348: 11 00 80 5d sethi %hi(0x2017400), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 201634c: 7f ff e0 1d call 200e3c0 2016350: 90 12 23 74 or %o0, 0x374, %o0 ! 2017774 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 2016354: 03 00 80 62 sethi %hi(0x2018800), %g1 2016358: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> 201635c: 82 10 20 04 mov 4, %g1 2016360: b0 06 20 e0 add %i0, 0xe0, %i0 2016364: c2 26 60 d0 st %g1, [ %i1 + 0xd0 ] 2016368: 33 00 80 62 sethi %hi(0x2018800), %i1 201636c: 7f ff d0 43 call 200a478 <_CPU_Context_switch> 2016370: 93 ee 62 68 restore %i1, 0x268, %o1 2016374: 81 c7 e0 08 ret <== NOT EXECUTED 2016378: 81 e8 00 00 restore <== NOT EXECUTED 02011268 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 2011268: 9d e3 bf 90 save %sp, -112, %sp 201126c: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 2011270: 80 a6 60 00 cmp %i1, 0 2011274: 02 80 00 47 be 2011390 2011278: b0 10 20 0a mov 0xa, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 201127c: 80 a2 60 00 cmp %o1, 0 2011280: 12 80 00 0a bne 20112a8 2011284: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011288: 03 00 80 c9 sethi %hi(0x2032400), %g1 201128c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 2011290: 84 00 a0 01 inc %g2 2011294: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 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; 2011298: 03 00 80 c9 sethi %hi(0x2032400), %g1 201129c: f0 00 62 d0 ld [ %g1 + 0x2d0 ], %i0 ! 20326d0 <_Thread_Executing> 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; 20112a0: 10 80 00 18 b 2011300 20112a4: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20112a8: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 20112ac: 80 a0 a0 04 cmp %g2, 4 20112b0: 18 80 00 0e bgu 20112e8 20112b4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20112b8: 83 32 60 1b srl %o1, 0x1b, %g1 20112bc: 80 a0 60 01 cmp %g1, 1 20112c0: 12 80 00 0a bne 20112e8 20112c4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20112c8: 83 28 a0 02 sll %g2, 2, %g1 20112cc: 05 00 80 c9 sethi %hi(0x2032400), %g2 20112d0: 84 10 a1 50 or %g2, 0x150, %g2 ! 2032550 <_Objects_Information_table> 20112d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20112d8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20112dc: 80 a2 20 00 cmp %o0, 0 20112e0: 12 80 00 05 bne 20112f4 20112e4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20112e8: b0 10 20 00 clr %i0 20112ec: 10 80 00 05 b 2011300 20112f0: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20112f4: 40 00 0d ef call 2014ab0 <_Objects_Get> 20112f8: 94 07 bf f4 add %fp, -12, %o2 20112fc: b0 10 00 08 mov %o0, %i0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2011300: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011304: 80 a0 60 00 cmp %g1, 0 2011308: 22 80 00 07 be,a 2011324 201130c: d2 06 21 70 ld [ %i0 + 0x170 ], %o1 2011310: 80 a0 60 02 cmp %g1, 2 2011314: 08 80 00 1f bleu 2011390 2011318: b0 10 20 04 mov 4, %i0 201131c: 81 c7 e0 08 ret <== NOT EXECUTED 2011320: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2011324: c2 02 60 4c ld [ %o1 + 0x4c ], %g1 2011328: 80 a0 60 00 cmp %g1, 0 201132c: 02 80 00 1b be 2011398 2011330: 01 00 00 00 nop if ( asr->is_enabled ) { 2011334: c2 02 60 48 ld [ %o1 + 0x48 ], %g1 2011338: 80 a0 60 00 cmp %g1, 0 201133c: 02 80 00 11 be 2011380 2011340: 90 10 00 19 mov %i1, %o0 _ASR_Post_signals( signal_set, &asr->signals_posted ); 2011344: 7f ff ff b3 call 2011210 <_ASR_Post_signals> 2011348: 92 02 60 54 add %o1, 0x54, %o1 the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 201134c: 03 00 80 c9 sethi %hi(0x2032400), %g1 2011350: c2 00 62 b8 ld [ %g1 + 0x2b8 ], %g1 ! 20326b8 <_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; 2011354: 84 10 20 01 mov 1, %g2 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011358: 80 a0 60 00 cmp %g1, 0 201135c: 02 80 00 0b be 2011388 2011360: c4 26 20 78 st %g2, [ %i0 + 0x78 ] 2011364: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED 2011368: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 20326d0 <_Thread_Executing> <== NOT EXECUTED 201136c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2011370: 12 80 00 06 bne 2011388 <== NOT EXECUTED 2011374: 03 00 80 c9 sethi %hi(0x2032400), %g1 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 2011378: 10 80 00 04 b 2011388 <== NOT EXECUTED 201137c: c4 20 63 78 st %g2, [ %g1 + 0x378 ] ! 2032778 <_ISR_Signals_to_thread_executing> <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); 2011380: 7f ff ff a4 call 2011210 <_ASR_Post_signals> 2011384: 92 02 60 58 add %o1, 0x58, %o1 } _Thread_Enable_dispatch(); 2011388: 7f ff ff ab call 2011234 <_Thread_Enable_dispatch> 201138c: b0 10 20 00 clr %i0 2011390: 81 c7 e0 08 ret 2011394: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2011398: 7f ff ff a7 call 2011234 <_Thread_Enable_dispatch> 201139c: b0 10 20 0b mov 0xb, %i0 return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20113a0: 81 c7 e0 08 ret 20113a4: 81 e8 00 00 restore 020028f4 : /* * Check if blown */ boolean rtems_stack_checker_is_blown( void ) { 20028f4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 20028f8: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED 20028fc: f0 00 61 b0 ld [ %g1 + 0x1b0 ], %i0 ! 201d1b0 <_Thread_Executing> <== NOT EXECUTED /* * Check for an out of bounds stack pointer */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); 2002900: 7f ff ff d7 call 200285c <== NOT EXECUTED 2002904: 90 06 20 d0 add %i0, 0xd0, %o0 <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 2002908: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED 200290c: c2 00 63 7c ld [ %g1 + 0x37c ], %g1 ! 201cb7c <== NOT EXECUTED /* * Check for an out of bounds stack pointer */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); 2002910: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 2002914: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2002918: 02 80 00 0a be 2002940 <== NOT EXECUTED 200291c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED pattern_ok = (!memcmp( 2002920: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 2002924: 13 00 80 73 sethi %hi(0x201cc00), %o1 <== NOT EXECUTED 2002928: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED 200292c: 92 12 62 ec or %o1, 0x2ec, %o1 <== NOT EXECUTED 2002930: 40 00 36 04 call 2010140 <== NOT EXECUTED 2002934: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 2002938: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200293c: 92 60 3f ff subx %g0, -1, %o1 <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return FALSE. */ if ( sp_ok && pattern_ok ) 2002940: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2002944: 02 80 00 06 be 200295c <== NOT EXECUTED 2002948: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED 200294c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 2002950: 12 80 00 06 bne 2002968 <== NOT EXECUTED 2002954: 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 ); 2002958: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED 200295c: d0 00 61 b0 ld [ %g1 + 0x1b0 ], %o0 ! 201d1b0 <_Thread_Executing> <== NOT EXECUTED 2002960: 7f ff ff cb call 200288c <== NOT EXECUTED 2002964: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return TRUE; } 2002968: 81 c7 e0 08 ret <== NOT EXECUTED 200296c: 81 e8 00 00 restore <== NOT EXECUTED 02002840 : } void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 2002840: 13 00 80 0f sethi %hi(0x2003c00), %o1 <== NOT EXECUTED 2002844: 90 10 20 00 clr %o0 <== NOT EXECUTED 2002848: 92 12 63 b0 or %o1, 0x3b0, %o1 <== NOT EXECUTED 200284c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2002850: 7f ff ff e2 call 20027d8 <== NOT EXECUTED 2002854: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2002858: 01 00 00 00 nop 020027d8 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 20027d8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (Stack_check_Initialized == 0) 20027dc: 03 00 80 72 sethi %hi(0x201c800), %g1 <== NOT EXECUTED 20027e0: c2 00 63 7c ld [ %g1 + 0x37c ], %g1 ! 201cb7c <== NOT EXECUTED 20027e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20027e8: 02 80 00 14 be 2002838 <== NOT EXECUTED 20027ec: 23 00 80 72 sethi %hi(0x201c800), %l1 <== NOT EXECUTED return; print_context = context; print_handler = print; 20027f0: 21 00 80 72 sethi %hi(0x201c800), %l0 <== NOT EXECUTED ) { if (Stack_check_Initialized == 0) return; print_context = context; 20027f4: f0 24 63 80 st %i0, [ %l1 + 0x380 ] <== NOT EXECUTED print_handler = print; 20027f8: f2 24 23 84 st %i1, [ %l0 + 0x384 ] <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 20027fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2002800: 13 00 80 68 sethi %hi(0x201a000), %o1 <== NOT EXECUTED 2002804: 9f c6 40 00 call %i1 <== NOT EXECUTED 2002808: 92 12 61 78 or %o1, 0x178, %o1 ! 201a178 <== NOT EXECUTED (*print)( context, 200280c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2002810: 13 00 80 68 sethi %hi(0x201a000), %o1 <== NOT EXECUTED 2002814: 9f c6 40 00 call %i1 <== NOT EXECUTED 2002818: 92 12 61 90 or %o1, 0x190, %o1 ! 201a190 <== NOT EXECUTED " ID NAME LOW HIGH AVAILABLE USED\n" ); /* iterate over all threads and dump the usage */ rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage ); 200281c: 11 00 80 09 sethi %hi(0x2002400), %o0 <== NOT EXECUTED 2002820: 40 00 17 6b call 20085cc <== NOT EXECUTED 2002824: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 20026d0 <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 2002828: 7f ff ff aa call 20026d0 <== NOT EXECUTED 200282c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED print_context = NULL; 2002830: c0 24 63 80 clr [ %l1 + 0x380 ] <== NOT EXECUTED print_handler = NULL; 2002834: c0 24 23 84 clr [ %l0 + 0x384 ] <== NOT EXECUTED 2002838: 81 c7 e0 08 ret <== NOT EXECUTED 200283c: 81 e8 00 00 restore <== NOT EXECUTED 02002970 : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 2002970: 9d e3 bf 98 save %sp, -104, %sp Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; boolean sp_ok; boolean pattern_ok = TRUE; pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern; 2002974: e0 06 20 d4 ld [ %i0 + 0xd4 ], %l0 /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); 2002978: 7f ff ff b9 call 200285c 200297c: 90 06 20 d0 add %i0, 0xd0, %o0 Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; boolean sp_ok; boolean pattern_ok = TRUE; pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern; 2002980: a0 04 20 08 add %l0, 8, %l0 /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); 2002984: a2 10 00 08 mov %o0, %l1 pattern_ok = (!memcmp( pattern, 2002988: 13 00 80 73 sethi %hi(0x201cc00), %o1 200298c: 90 10 00 10 mov %l0, %o0 2002990: 92 12 62 ec or %o1, 0x2ec, %o1 2002994: 40 00 35 eb call 2010140 2002998: 94 10 20 10 mov 0x10, %o2 200299c: 80 a0 00 08 cmp %g0, %o0 20029a0: b2 60 3f ff subx %g0, -1, %i1 (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 20029a4: 80 a4 60 00 cmp %l1, 0 20029a8: 02 80 00 04 be 20029b8 20029ac: 80 a6 60 00 cmp %i1, 0 20029b0: 12 80 00 04 bne 20029c0 20029b4: 01 00 00 00 nop Stack_check_report_blown_task( running, pattern_ok ); 20029b8: 7f ff ff b5 call 200288c <== NOT EXECUTED 20029bc: 81 e8 00 00 restore <== NOT EXECUTED 20029c0: 81 c7 e0 08 ret 20029c4: 81 e8 00 00 restore 02005fe0 : const char * rtems_status_text( rtems_status_code status ) { 2005fe0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 2005fe4: 11 00 80 95 sethi %hi(0x2025400), %o0 <== NOT EXECUTED 2005fe8: 90 12 23 90 or %o0, 0x390, %o0 ! 2025790 <== NOT EXECUTED 2005fec: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005ff0: 40 00 2e e5 call 2011b84 <== NOT EXECUTED 2005ff4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2005ff8: 01 00 00 00 nop 02005f2c : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 2005f2c: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2005f30: 92 96 20 00 orcc %i0, 0, %o1 2005f34: 12 80 00 0a bne 2005f5c 2005f38: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005f3c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005f40: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2005f44: 84 00 a0 01 inc %g2 2005f48: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 2005f4c: 03 00 80 62 sethi %hi(0x2018800), %g1 2005f50: f0 00 63 d0 ld [ %g1 + 0x3d0 ], %i0 ! 2018bd0 <_Thread_Executing> 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; 2005f54: 10 80 00 18 b 2005fb4 2005f58: c0 27 bf f4 clr [ %fp + -12 ] */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005f5c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2005f60: 80 a0 a0 04 cmp %g2, 4 2005f64: 18 80 00 0e bgu 2005f9c 2005f68: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2005f6c: 83 32 60 1b srl %o1, 0x1b, %g1 2005f70: 80 a0 60 01 cmp %g1, 1 2005f74: 12 80 00 0a bne 2005f9c 2005f78: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2005f7c: 83 28 a0 02 sll %g2, 2, %g1 2005f80: 05 00 80 62 sethi %hi(0x2018800), %g2 2005f84: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 2005f88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2005f8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2005f90: 80 a2 20 00 cmp %o0, 0 2005f94: 12 80 00 05 bne 2005fa8 2005f98: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2005f9c: b0 10 20 00 clr %i0 2005fa0: 10 80 00 05 b 2005fb4 2005fa4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2005fa8: 40 00 06 08 call 20077c8 <_Objects_Get> 2005fac: 94 07 bf f4 add %fp, -12, %o2 2005fb0: b0 10 00 08 mov %o0, %i0 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2005fb4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005fb8: 80 a0 60 00 cmp %g1, 0 2005fbc: 02 80 00 06 be 2005fd4 2005fc0: 80 a0 60 02 cmp %g1, 2 2005fc4: 08 80 00 0b bleu 2005ff0 2005fc8: b0 10 20 04 mov 4, %i0 2005fcc: 81 c7 e0 08 ret <== NOT EXECUTED 2005fd0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 2005fd4: 7f ff ff c0 call 2005ed4 <_Objects_Get_information> 2005fd8: d0 06 20 08 ld [ %i0 + 8 ], %o0 if ( !the_information ) { 2005fdc: 80 a2 20 00 cmp %o0, 0 2005fe0: 12 80 00 06 bne 2005ff8 2005fe4: 01 00 00 00 nop _Thread_Enable_dispatch(); 2005fe8: 7f ff ff c4 call 2005ef8 <_Thread_Enable_dispatch> <== NOT EXECUTED 2005fec: b0 10 20 04 mov 4, %i0 ! 4 <== NOT EXECUTED 2005ff0: 81 c7 e0 08 ret 2005ff4: 81 e8 00 00 restore return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 2005ff8: 40 00 0a 6a call 20089a0 <_Thread_Close> 2005ffc: 92 10 00 18 mov %i0, %o1 2006000: 7f ff ff b5 call 2005ed4 <_Objects_Get_information> 2006004: d0 06 20 08 ld [ %i0 + 8 ], %o0 2006008: 92 10 00 18 mov %i0, %o1 200600c: 40 00 05 ad call 20076c0 <_Objects_Free> 2006010: b0 10 20 00 clr %i0 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 2006014: 7f ff ff b9 call 2005ef8 <_Thread_Enable_dispatch> 2006018: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200601c: 81 c7 e0 08 ret 2006020: 81 e8 00 00 restore 02007838 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 2007838: 9d e3 bf 90 save %sp, -112, %sp 200783c: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 2007840: 80 a6 a0 00 cmp %i2, 0 2007844: 02 80 00 43 be 2007950 2007848: 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 ) 200784c: 80 a6 60 0f cmp %i1, 0xf 2007850: 18 80 00 40 bgu 2007950 2007854: b0 10 20 0a mov 0xa, %i0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007858: 80 a2 60 00 cmp %o1, 0 200785c: 02 80 00 08 be 200787c 2007860: 03 00 80 79 sethi %hi(0x201e400), %g1 2007864: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007868: c2 00 60 08 ld [ %g1 + 8 ], %g1 200786c: 80 a2 40 01 cmp %o1, %g1 2007870: 12 80 00 0a bne 2007898 2007874: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007878: 03 00 80 79 sethi %hi(0x201e400), %g1 <== NOT EXECUTED 200787c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007880: 85 2e 60 02 sll %i1, 2, %g2 2007884: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 2007888: c2 00 40 02 ld [ %g1 + %g2 ], %g1 200788c: c2 26 80 00 st %g1, [ %i2 ] 2007890: 81 c7 e0 08 ret 2007894: 91 e8 20 00 restore %g0, 0, %o0 2007898: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 200789c: 80 a0 a0 04 cmp %g2, 4 20078a0: 18 80 00 06 bgu 20078b8 20078a4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20078a8: 83 32 60 1b srl %o1, 0x1b, %g1 20078ac: 80 a0 60 01 cmp %g1, 1 20078b0: 02 80 00 05 be 20078c4 20078b4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20078b8: 90 10 20 00 clr %o0 20078bc: 10 80 00 0e b 20078f4 20078c0: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20078c4: 83 28 a0 02 sll %g2, 2, %g1 20078c8: 05 00 80 79 sethi %hi(0x201e400), %g2 20078cc: 84 10 a0 00 mov %g2, %g2 ! 201e400 <_Objects_Information_table> 20078d0: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20078d4: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20078d8: 80 a2 20 00 cmp %o0, 0 20078dc: 12 80 00 04 bne 20078ec 20078e0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20078e4: 10 80 00 04 b 20078f4 <== NOT EXECUTED 20078e8: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20078ec: 40 00 07 52 call 2009634 <_Objects_Get> 20078f0: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 20078f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20078f8: 80 a0 60 00 cmp %g1, 0 20078fc: 22 80 00 07 be,a 2007918 2007900: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2007904: 80 a0 60 02 cmp %g1, 2 2007908: 08 80 00 12 bleu 2007950 200790c: b0 10 20 04 mov 4, %i0 2007910: 81 c7 e0 08 ret <== NOT EXECUTED 2007914: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007918: 83 2e 60 02 sll %i1, 2, %g1 200791c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007920: c2 26 80 00 st %g1, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007924: 05 00 80 79 sethi %hi(0x201e400), %g2 2007928: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 201e4a0 <_Thread_Dispatch_disable_level> 200792c: b0 10 20 00 clr %i0 2007930: 82 00 7f ff add %g1, -1, %g1 2007934: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 2007938: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 200793c: 80 a0 60 00 cmp %g1, 0 2007940: 12 80 00 04 bne 2007950 2007944: 01 00 00 00 nop _Thread_Dispatch(); 2007948: 40 00 0c 01 call 200a94c <_Thread_Dispatch> 200794c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007950: 81 c7 e0 08 ret 2007954: 81 e8 00 00 restore 020066b8 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 20066b8: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 20066bc: 92 96 20 00 orcc %i0, 0, %o1 20066c0: 12 80 00 0a bne 20066e8 20066c4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20066c8: 03 00 80 70 sethi %hi(0x201c000), %g1 <== NOT EXECUTED 20066cc: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 201c290 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 20066d0: 84 00 a0 01 inc %g2 <== NOT EXECUTED 20066d4: c4 20 62 90 st %g2, [ %g1 + 0x290 ] <== NOT EXECUTED 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; 20066d8: 03 00 80 70 sethi %hi(0x201c000), %g1 <== NOT EXECUTED 20066dc: d0 00 63 70 ld [ %g1 + 0x370 ], %o0 ! 201c370 <_Thread_Executing> <== NOT EXECUTED 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; 20066e0: 10 80 00 19 b 2006744 <== NOT EXECUTED 20066e4: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 20066e8: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 20066ec: 80 a0 a0 04 cmp %g2, 4 20066f0: 18 80 00 06 bgu 2006708 20066f4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20066f8: 83 32 60 1b srl %o1, 0x1b, %g1 20066fc: 80 a0 60 01 cmp %g1, 1 2006700: 02 80 00 05 be 2006714 2006704: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006708: 90 10 20 00 clr %o0 <== NOT EXECUTED 200670c: 10 80 00 0e b 2006744 <== NOT EXECUTED 2006710: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006714: 83 28 a0 02 sll %g2, 2, %g1 2006718: 05 00 80 70 sethi %hi(0x201c000), %g2 200671c: 84 10 a1 f0 or %g2, 0x1f0, %g2 ! 201c1f0 <_Objects_Information_table> 2006720: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006724: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2006728: 80 a2 20 00 cmp %o0, 0 200672c: 12 80 00 04 bne 200673c 2006730: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006734: 10 80 00 04 b 2006744 <== NOT EXECUTED 2006738: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200673c: 40 00 06 58 call 200809c <_Objects_Get> 2006740: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006744: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006748: 80 a0 60 00 cmp %g1, 0 200674c: 22 80 00 07 be,a 2006768 2006750: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006754: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006758: 08 80 00 09 bleu 200677c <== NOT EXECUTED 200675c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2006760: 81 c7 e0 08 ret <== NOT EXECUTED 2006764: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2006768: 80 88 60 02 btst 2, %g1 200676c: 12 80 00 06 bne 2006784 2006770: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006774: 7f ff ff c4 call 2006684 <_Thread_Enable_dispatch> 2006778: b0 10 20 00 clr %i0 ! 0 200677c: 81 c7 e0 08 ret 2006780: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006784: 7f ff ff c0 call 2006684 <_Thread_Enable_dispatch> 2006788: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200678c: 81 c7 e0 08 ret 2006790: 81 e8 00 00 restore 02006d0c : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 2006d0c: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2006d10: 92 96 20 00 orcc %i0, 0, %o1 2006d14: 12 80 00 0a bne 2006d3c 2006d18: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006d1c: 03 00 80 71 sethi %hi(0x201c400), %g1 2006d20: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201c7d0 <_Thread_Dispatch_disable_level> 2006d24: 84 00 a0 01 inc %g2 2006d28: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 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; 2006d2c: 03 00 80 72 sethi %hi(0x201c800), %g1 2006d30: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 201c8b0 <_Thread_Executing> 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; 2006d34: 10 80 00 19 b 2006d98 2006d38: c0 27 bf f4 clr [ %fp + -12 ] 2006d3c: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2006d40: 80 a0 a0 04 cmp %g2, 4 2006d44: 18 80 00 06 bgu 2006d5c 2006d48: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2006d4c: 83 32 60 1b srl %o1, 0x1b, %g1 2006d50: 80 a0 60 01 cmp %g1, 1 2006d54: 02 80 00 05 be 2006d68 2006d58: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d5c: 90 10 20 00 clr %o0 2006d60: 10 80 00 0e b 2006d98 2006d64: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006d68: 83 28 a0 02 sll %g2, 2, %g1 2006d6c: 05 00 80 71 sethi %hi(0x201c400), %g2 2006d70: 84 10 a3 30 or %g2, 0x330, %g2 ! 201c730 <_Objects_Information_table> 2006d74: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2006d78: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2006d7c: 80 a2 20 00 cmp %o0, 0 2006d80: 12 80 00 04 bne 2006d90 2006d84: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2006d88: 10 80 00 04 b 2006d98 <== NOT EXECUTED 2006d8c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006d90: 40 00 06 1f call 200860c <_Objects_Get> 2006d94: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006d98: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006d9c: 80 a0 60 00 cmp %g1, 0 2006da0: 22 80 00 07 be,a 2006dbc 2006da4: 94 10 00 19 mov %i1, %o2 2006da8: 80 a0 60 02 cmp %g1, 2 2006dac: 08 80 00 0b bleu 2006dd8 2006db0: b0 10 20 04 mov 4, %i0 2006db4: 81 c7 e0 08 ret <== NOT EXECUTED 2006db8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 2006dbc: 40 00 0d d5 call 200a510 <_Thread_Restart> 2006dc0: 92 10 20 00 clr %o1 2006dc4: 80 a2 20 00 cmp %o0, 0 2006dc8: 02 80 00 06 be 2006de0 2006dcc: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006dd0: 7f ff ff c2 call 2006cd8 <_Thread_Enable_dispatch> 2006dd4: b0 10 20 00 clr %i0 ! 0 2006dd8: 81 c7 e0 08 ret 2006ddc: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006de0: 7f ff ff be call 2006cd8 <_Thread_Enable_dispatch> 2006de4: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006de8: 81 c7 e0 08 ret 2006dec: 81 e8 00 00 restore 020076d8 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 20076d8: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 20076dc: 92 96 20 00 orcc %i0, 0, %o1 20076e0: 12 80 00 0a bne 2007708 20076e4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20076e8: 03 00 80 95 sethi %hi(0x2025400), %g1 20076ec: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 20076f0: 84 00 a0 01 inc %g2 20076f4: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 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; 20076f8: 03 00 80 95 sethi %hi(0x2025400), %g1 20076fc: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 20257e0 <_Thread_Executing> 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; 2007700: 10 80 00 19 b 2007764 2007704: c0 27 bf f4 clr [ %fp + -12 ] 2007708: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 200770c: 80 a0 a0 04 cmp %g2, 4 2007710: 18 80 00 06 bgu 2007728 2007714: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007718: 83 32 60 1b srl %o1, 0x1b, %g1 200771c: 80 a0 60 01 cmp %g1, 1 2007720: 02 80 00 05 be 2007734 2007724: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007728: 90 10 20 00 clr %o0 200772c: 10 80 00 0e b 2007764 2007730: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007734: 83 28 a0 02 sll %g2, 2, %g1 2007738: 05 00 80 95 sethi %hi(0x2025400), %g2 200773c: 84 10 a2 60 or %g2, 0x260, %g2 ! 2025660 <_Objects_Information_table> 2007740: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007744: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007748: 80 a2 20 00 cmp %o0, 0 200774c: 12 80 00 04 bne 200775c 2007750: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007754: 10 80 00 04 b 2007764 <== NOT EXECUTED 2007758: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200775c: 40 00 06 f9 call 2009340 <_Objects_Get> 2007760: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007764: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007768: 80 a0 60 00 cmp %g1, 0 200776c: 22 80 00 07 be,a 2007788 2007770: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007774: 80 a0 60 02 cmp %g1, 2 2007778: 08 80 00 0b bleu 20077a4 200777c: b0 10 20 04 mov 4, %i0 2007780: 81 c7 e0 08 ret <== NOT EXECUTED 2007784: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 2007788: 80 88 60 02 btst 2, %g1 200778c: 02 80 00 08 be 20077ac 2007790: 92 10 20 01 mov 1, %o1 _Thread_Resume( the_thread, TRUE ); 2007794: 40 00 0e c2 call 200b29c <_Thread_Resume> 2007798: b0 10 20 00 clr %i0 _Thread_Enable_dispatch(); 200779c: 7f ff ff c2 call 20076a4 <_Thread_Enable_dispatch> 20077a0: 01 00 00 00 nop 20077a4: 81 c7 e0 08 ret 20077a8: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20077ac: 7f ff ff be call 20076a4 <_Thread_Enable_dispatch> 20077b0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20077b4: 81 c7 e0 08 ret 20077b8: 81 e8 00 00 restore 02007b24 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 2007b24: 9d e3 bf 90 save %sp, -112, %sp 2007b28: 92 10 00 18 mov %i0, %o1 /* * 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 ) 2007b2c: 80 a6 60 0f cmp %i1, 0xf 2007b30: 18 80 00 3e bgu 2007c28 2007b34: b0 10 20 0a mov 0xa, %i0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007b38: 80 a2 60 00 cmp %o1, 0 2007b3c: 02 80 00 08 be 2007b5c 2007b40: 03 00 80 79 sethi %hi(0x201e400), %g1 2007b44: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> 2007b48: c2 00 60 08 ld [ %g1 + 8 ], %g1 2007b4c: 80 a2 40 01 cmp %o1, %g1 2007b50: 12 80 00 09 bne 2007b74 2007b54: 83 32 60 18 srl %o1, 0x18, %g1 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007b58: 03 00 80 79 sethi %hi(0x201e400), %g1 <== NOT EXECUTED 2007b5c: c2 00 61 80 ld [ %g1 + 0x180 ], %g1 ! 201e580 <_Thread_Executing> <== NOT EXECUTED 2007b60: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED 2007b64: c2 00 61 70 ld [ %g1 + 0x170 ], %g1 <== NOT EXECUTED 2007b68: f4 20 40 02 st %i2, [ %g1 + %g2 ] <== NOT EXECUTED 2007b6c: 81 c7 e0 08 ret <== NOT EXECUTED 2007b70: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 2007b74: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2007b78: 80 a0 a0 04 cmp %g2, 4 2007b7c: 18 80 00 06 bgu 2007b94 2007b80: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007b84: 83 32 60 1b srl %o1, 0x1b, %g1 2007b88: 80 a0 60 01 cmp %g1, 1 2007b8c: 02 80 00 05 be 2007ba0 2007b90: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007b94: 90 10 20 00 clr %o0 2007b98: 10 80 00 0e b 2007bd0 2007b9c: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007ba0: 83 28 a0 02 sll %g2, 2, %g1 2007ba4: 05 00 80 79 sethi %hi(0x201e400), %g2 2007ba8: 84 10 a0 00 mov %g2, %g2 ! 201e400 <_Objects_Information_table> 2007bac: c2 00 80 01 ld [ %g2 + %g1 ], %g1 2007bb0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007bb4: 80 a2 20 00 cmp %o0, 0 2007bb8: 12 80 00 04 bne 2007bc8 2007bbc: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007bc0: 10 80 00 04 b 2007bd0 <== NOT EXECUTED 2007bc4: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007bc8: 40 00 06 9b call 2009634 <_Objects_Get> 2007bcc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007bd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007bd4: 80 a0 60 00 cmp %g1, 0 2007bd8: 22 80 00 07 be,a 2007bf4 2007bdc: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2007be0: 80 a0 60 02 cmp %g1, 2 2007be4: 08 80 00 11 bleu 2007c28 2007be8: b0 10 20 04 mov 4, %i0 2007bec: 81 c7 e0 08 ret <== NOT EXECUTED 2007bf0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007bf4: 83 2e 60 02 sll %i1, 2, %g1 2007bf8: f4 20 80 01 st %i2, [ %g2 + %g1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007bfc: 05 00 80 79 sethi %hi(0x201e400), %g2 2007c00: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 201e4a0 <_Thread_Dispatch_disable_level> 2007c04: b0 10 20 00 clr %i0 2007c08: 82 00 7f ff add %g1, -1, %g1 2007c0c: c2 20 a0 a0 st %g1, [ %g2 + 0xa0 ] 2007c10: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 2007c14: 80 a0 60 00 cmp %g1, 0 2007c18: 12 80 00 04 bne 2007c28 2007c1c: 01 00 00 00 nop _Thread_Dispatch(); 2007c20: 40 00 0b 4b call 200a94c <_Thread_Dispatch> 2007c24: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007c28: 81 c7 e0 08 ret 2007c2c: 81 e8 00 00 restore 0200a684 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200a684: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200a688: 80 a6 60 00 cmp %i1, 0 200a68c: 02 80 00 06 be 200a6a4 200a690: 92 10 00 18 mov %i0, %o1 200a694: 82 06 7f ff add %i1, -1, %g1 200a698: 80 a0 60 fe cmp %g1, 0xfe 200a69c: 18 80 00 49 bgu 200a7c0 200a6a0: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200a6a4: 80 a6 a0 00 cmp %i2, 0 200a6a8: 02 80 00 46 be 200a7c0 200a6ac: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 200a6b0: 80 a2 60 00 cmp %o1, 0 200a6b4: 12 80 00 0a bne 200a6dc 200a6b8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200a6bc: 03 00 80 9e sethi %hi(0x2027800), %g1 200a6c0: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 200a6c4: 84 00 a0 01 inc %g2 200a6c8: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 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; 200a6cc: 03 00 80 9e sethi %hi(0x2027800), %g1 200a6d0: d0 00 63 30 ld [ %g1 + 0x330 ], %o0 ! 2027b30 <_Thread_Executing> 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; 200a6d4: 10 80 00 19 b 200a738 200a6d8: c0 27 bf f4 clr [ %fp + -12 ] 200a6dc: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 200a6e0: 80 a0 a0 04 cmp %g2, 4 200a6e4: 18 80 00 06 bgu 200a6fc 200a6e8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200a6ec: 83 32 60 1b srl %o1, 0x1b, %g1 200a6f0: 80 a0 60 01 cmp %g1, 1 200a6f4: 02 80 00 05 be 200a708 200a6f8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a6fc: 90 10 20 00 clr %o0 200a700: 10 80 00 0e b 200a738 200a704: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200a708: 83 28 a0 02 sll %g2, 2, %g1 200a70c: 05 00 80 9e sethi %hi(0x2027800), %g2 200a710: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 20279b0 <_Objects_Information_table> 200a714: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200a718: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 200a71c: 80 a2 20 00 cmp %o0, 0 200a720: 12 80 00 04 bne 200a730 200a724: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200a728: 10 80 00 04 b 200a738 <== NOT EXECUTED 200a72c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200a730: 40 00 06 3d call 200c024 <_Objects_Get> 200a734: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200a738: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a73c: 80 a0 60 00 cmp %g1, 0 200a740: 22 80 00 07 be,a 200a75c 200a744: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a748: 80 a0 60 02 cmp %g1, 2 200a74c: 08 80 00 1d bleu 200a7c0 200a750: b0 10 20 04 mov 4, %i0 200a754: 81 c7 e0 08 ret <== NOT EXECUTED 200a758: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 200a75c: 80 a6 60 00 cmp %i1, 0 200a760: 02 80 00 0d be 200a794 200a764: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200a768: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200a76c: 80 a0 60 00 cmp %g1, 0 200a770: 02 80 00 06 be 200a788 200a774: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200a778: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a77c: 80 a0 40 19 cmp %g1, %i1 200a780: 08 80 00 05 bleu 200a794 200a784: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 200a788: 92 10 00 19 mov %i1, %o1 200a78c: 40 00 09 ee call 200cf44 <_Thread_Change_priority> 200a790: 94 10 20 00 clr %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a794: 03 00 80 9e sethi %hi(0x2027800), %g1 200a798: c4 00 62 50 ld [ %g1 + 0x250 ], %g2 ! 2027a50 <_Thread_Dispatch_disable_level> 200a79c: b0 10 20 00 clr %i0 200a7a0: 84 00 bf ff add %g2, -1, %g2 200a7a4: c4 20 62 50 st %g2, [ %g1 + 0x250 ] 200a7a8: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 200a7ac: 80 a0 60 00 cmp %g1, 0 200a7b0: 12 80 00 04 bne 200a7c0 200a7b4: 01 00 00 00 nop _Thread_Dispatch(); 200a7b8: 40 00 0b 20 call 200d438 <_Thread_Dispatch> 200a7bc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200a7c0: 81 c7 e0 08 ret 200a7c4: 81 e8 00 00 restore 0200616c : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 200616c: 9d e3 bf 90 save %sp, -112, %sp 2006170: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 2006174: 80 a6 60 00 cmp %i1, 0 2006178: 02 80 00 36 be 2006250 200617c: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2006180: 80 a2 60 00 cmp %o1, 0 2006184: 12 80 00 0a bne 20061ac 2006188: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200618c: 03 00 80 62 sethi %hi(0x2018800), %g1 2006190: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 2018af0 <_Thread_Dispatch_disable_level> 2006194: 84 00 a0 01 inc %g2 2006198: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] 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; 200619c: 03 00 80 62 sethi %hi(0x2018800), %g1 20061a0: d0 00 63 d0 ld [ %g1 + 0x3d0 ], %o0 ! 2018bd0 <_Thread_Executing> 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; 20061a4: 10 80 00 19 b 2006208 20061a8: c0 27 bf f4 clr [ %fp + -12 ] 20061ac: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 20061b0: 80 a0 a0 04 cmp %g2, 4 20061b4: 18 80 00 06 bgu 20061cc 20061b8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20061bc: 83 32 60 1b srl %o1, 0x1b, %g1 20061c0: 80 a0 60 01 cmp %g1, 1 20061c4: 02 80 00 05 be 20061d8 20061c8: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061cc: 90 10 20 00 clr %o0 20061d0: 10 80 00 0e b 2006208 20061d4: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20061d8: 83 28 a0 02 sll %g2, 2, %g1 20061dc: 05 00 80 62 sethi %hi(0x2018800), %g2 20061e0: 84 10 a2 50 or %g2, 0x250, %g2 ! 2018a50 <_Objects_Information_table> 20061e4: c2 00 80 01 ld [ %g2 + %g1 ], %g1 20061e8: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20061ec: 80 a2 20 00 cmp %o0, 0 20061f0: 12 80 00 04 bne 2006200 20061f4: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 20061f8: 10 80 00 04 b 2006208 <== NOT EXECUTED 20061fc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006200: 40 00 05 72 call 20077c8 <_Objects_Get> 2006204: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006208: c2 07 bf f4 ld [ %fp + -12 ], %g1 200620c: 80 a0 60 00 cmp %g1, 0 2006210: 22 80 00 07 be,a 200622c 2006214: 94 10 00 19 mov %i1, %o2 2006218: 80 a0 60 02 cmp %g1, 2 200621c: 08 80 00 0d bleu 2006250 2006220: b0 10 20 04 mov 4, %i0 2006224: 81 c7 e0 08 ret <== NOT EXECUTED 2006228: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 200622c: 98 10 00 1a mov %i2, %o4 2006230: 92 10 20 00 clr %o1 2006234: 40 00 0e 44 call 2009b44 <_Thread_Start> 2006238: 96 10 20 00 clr %o3 200623c: 80 a2 20 00 cmp %o0, 0 2006240: 02 80 00 06 be 2006258 2006244: 01 00 00 00 nop the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 2006248: 7f ff ff bc call 2006138 <_Thread_Enable_dispatch> 200624c: b0 10 20 00 clr %i0 ! 0 2006250: 81 c7 e0 08 ret 2006254: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 2006258: 7f ff ff b8 call 2006138 <_Thread_Enable_dispatch> 200625c: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006260: 81 c7 e0 08 ret 2006264: 81 e8 00 00 restore 02007920 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 2007920: 9d e3 bf 90 save %sp, -112, %sp uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2007924: 92 96 20 00 orcc %i0, 0, %o1 2007928: 12 80 00 0a bne 2007950 200792c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007930: 03 00 80 95 sethi %hi(0x2025400), %g1 2007934: c4 00 63 00 ld [ %g1 + 0x300 ], %g2 ! 2025700 <_Thread_Dispatch_disable_level> 2007938: 84 00 a0 01 inc %g2 200793c: c4 20 63 00 st %g2, [ %g1 + 0x300 ] 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; 2007940: 03 00 80 95 sethi %hi(0x2025400), %g1 2007944: d0 00 63 e0 ld [ %g1 + 0x3e0 ], %o0 ! 20257e0 <_Thread_Executing> 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; 2007948: 10 80 00 19 b 20079ac 200794c: c0 27 bf f4 clr [ %fp + -12 ] 2007950: 84 08 60 07 and %g1, 7, %g2 tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2007954: 80 a0 a0 04 cmp %g2, 4 2007958: 18 80 00 06 bgu 2007970 200795c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007960: 83 32 60 1b srl %o1, 0x1b, %g1 2007964: 80 a0 60 01 cmp %g1, 1 2007968: 02 80 00 05 be 200797c 200796c: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 2007970: 90 10 20 00 clr %o0 2007974: 10 80 00 0e b 20079ac 2007978: c2 27 bf f4 st %g1, [ %fp + -12 ] goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200797c: 83 28 a0 02 sll %g2, 2, %g1 2007980: 05 00 80 95 sethi %hi(0x2025400), %g2 2007984: 84 10 a2 60 or %g2, 0x260, %g2 ! 2025660 <_Objects_Information_table> 2007988: c2 00 80 01 ld [ %g2 + %g1 ], %g1 200798c: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 2007990: 80 a2 20 00 cmp %o0, 0 2007994: 12 80 00 04 bne 20079a4 2007998: 82 10 20 02 mov 2, %g1 *location = OBJECTS_ERROR; 200799c: 10 80 00 04 b 20079ac <== NOT EXECUTED 20079a0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20079a4: 40 00 06 67 call 2009340 <_Objects_Get> 20079a8: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20079ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20079b0: 80 a0 60 00 cmp %g1, 0 20079b4: 22 80 00 07 be,a 20079d0 20079b8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20079bc: 80 a0 60 02 cmp %g1, 2 20079c0: 08 80 00 0b bleu 20079ec 20079c4: b0 10 20 04 mov 4, %i0 20079c8: 81 c7 e0 08 ret <== NOT EXECUTED 20079cc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 20079d0: 80 88 60 02 btst 2, %g1 20079d4: 12 80 00 08 bne 20079f4 20079d8: 01 00 00 00 nop _Thread_Suspend( the_thread ); 20079dc: 40 00 0f 61 call 200b760 <_Thread_Suspend> 20079e0: b0 10 20 00 clr %i0 ! 0 _Thread_Enable_dispatch(); 20079e4: 7f ff ff c2 call 20078ec <_Thread_Enable_dispatch> 20079e8: 01 00 00 00 nop 20079ec: 81 c7 e0 08 ret 20079f0: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 20079f4: 7f ff ff be call 20078ec <_Thread_Enable_dispatch> 20079f8: b0 10 20 0f mov 0xf, %i0 return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20079fc: 81 c7 e0 08 ret 2007a00: 81 e8 00 00 restore 02017aa0 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 2017aa0: 9d e3 bf 90 save %sp, -112, %sp 2017aa4: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 2017aa8: 80 a6 60 00 cmp %i1, 0 2017aac: 02 80 00 32 be 2017b74 2017ab0: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2017ab4: 80 a2 60 00 cmp %o1, 0 2017ab8: 12 80 00 0a bne 2017ae0 2017abc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017ac0: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017ac4: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> 2017ac8: 84 00 a0 01 inc %g2 2017acc: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 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; 2017ad0: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017ad4: f0 00 63 f0 ld [ %g1 + 0x3f0 ], %i0 ! 2039bf0 <_Thread_Executing> 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; 2017ad8: 10 80 00 18 b 2017b38 2017adc: c0 27 bf f4 clr [ %fp + -12 ] 2017ae0: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2017ae4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017ae8: 18 80 00 0e bgu 2017b20 <== NOT EXECUTED 2017aec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2017af0: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017af4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017af8: 12 80 00 0a bne 2017b20 <== NOT EXECUTED 2017afc: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017b00: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017b04: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017b08: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017b0c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017b10: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017b14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017b18: 12 80 00 05 bne 2017b2c <== NOT EXECUTED 2017b1c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017b20: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017b24: 10 80 00 05 b 2017b38 <== NOT EXECUTED 2017b28: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017b2c: 7f ff c8 b8 call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017b30: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2017b34: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2017b38: c2 07 bf f4 ld [ %fp + -12 ], %g1 2017b3c: 80 a0 60 00 cmp %g1, 0 2017b40: 22 80 00 0f be,a 2017b7c 2017b44: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 2017b48: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017b4c: 08 80 00 0a bleu 2017b74 <== NOT EXECUTED 2017b50: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017b54: 81 c7 e0 08 ret <== NOT EXECUTED 2017b58: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 2017b5c: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017b60: 32 80 00 07 bne,a 2017b7c <== NOT EXECUTED 2017b64: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED tvp->dtor = dtor; 2017b68: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== NOT EXECUTED _Thread_Enable_dispatch(); 2017b6c: 7f ff ff c0 call 2017a6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017b70: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017b74: 81 c7 e0 08 ret <== NOT EXECUTED 2017b78: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 2017b7c: 80 a0 a0 00 cmp %g2, 0 2017b80: 32 bf ff f7 bne,a 2017b5c 2017b84: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 2017b88: 11 00 80 e6 sethi %hi(0x2039800), %o0 2017b8c: 92 10 20 14 mov 0x14, %o1 2017b90: 7f ff c6 03 call 200939c <_Heap_Allocate> 2017b94: 90 12 23 5c or %o0, 0x35c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 2017b98: 80 a2 20 00 cmp %o0, 0 2017b9c: 32 80 00 06 bne,a 2017bb4 2017ba0: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 _Thread_Enable_dispatch(); 2017ba4: 7f ff ff b2 call 2017a6c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017ba8: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 2017bac: 81 c7 e0 08 ret <== NOT EXECUTED 2017bb0: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_NO_MEMORY; } new->gval = *ptr; 2017bb4: 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; 2017bb8: d0 26 21 80 st %o0, [ %i0 + 0x180 ] _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 2017bbc: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 2017bc0: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 2017bc4: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 2017bc8: c4 22 00 00 st %g2, [ %o0 ] the_thread->task_variables = new; _Thread_Enable_dispatch(); 2017bcc: 7f ff ff a8 call 2017a6c <_Thread_Enable_dispatch> 2017bd0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017bd4: 81 c7 e0 08 ret 2017bd8: 81 e8 00 00 restore 02017c10 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 2017c10: 9d e3 bf 90 save %sp, -112, %sp 2017c14: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 2017c18: 80 a6 60 00 cmp %i1, 0 2017c1c: 02 80 00 52 be 2017d64 2017c20: b0 10 20 09 mov 9, %i0 uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2017c24: 80 a2 60 00 cmp %o1, 0 2017c28: 12 80 00 0a bne 2017c50 2017c2c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017c30: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017c34: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> 2017c38: 84 00 a0 01 inc %g2 2017c3c: c4 20 63 10 st %g2, [ %g1 + 0x310 ] 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; 2017c40: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017c44: d0 00 63 f0 ld [ %g1 + 0x3f0 ], %o0 ! 2039bf0 <_Thread_Executing> 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; 2017c48: 10 80 00 19 b 2017cac 2017c4c: c0 27 bf f4 clr [ %fp + -12 ] 2017c50: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2017c54: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017c58: 18 80 00 06 bgu 2017c70 <== NOT EXECUTED 2017c5c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2017c60: 83 32 60 1b srl %o1, 0x1b, %g1 <== NOT EXECUTED 2017c64: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017c68: 02 80 00 05 be 2017c7c <== NOT EXECUTED 2017c6c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017c70: 90 10 20 00 clr %o0 <== NOT EXECUTED 2017c74: 10 80 00 0e b 2017cac <== NOT EXECUTED 2017c78: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017c7c: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017c80: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017c84: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017c88: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017c8c: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017c90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017c94: 12 80 00 04 bne 2017ca4 <== NOT EXECUTED 2017c98: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017c9c: 10 80 00 04 b 2017cac <== NOT EXECUTED 2017ca0: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017ca4: 7f ff c8 5a call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017ca8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 2017cac: c2 07 bf f4 ld [ %fp + -12 ], %g1 2017cb0: 80 a0 60 00 cmp %g1, 0 2017cb4: 22 80 00 07 be,a 2017cd0 2017cb8: f0 02 21 80 ld [ %o0 + 0x180 ], %i0 2017cbc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017cc0: 08 80 00 29 bleu 2017d64 <== NOT EXECUTED 2017cc4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017cc8: 81 c7 e0 08 ret <== NOT EXECUTED 2017ccc: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 2017cd0: 10 80 00 28 b 2017d70 2017cd4: 84 10 20 00 clr %g2 while (tvp) { if (tvp->ptr == ptr) { 2017cd8: 80 a0 40 19 cmp %g1, %i1 2017cdc: 32 80 00 24 bne,a 2017d6c 2017ce0: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED if (prev) 2017ce4: 80 a0 a0 00 cmp %g2, 0 2017ce8: 02 80 00 04 be 2017cf8 2017cec: c2 06 00 00 ld [ %i0 ], %g1 prev->next = tvp->next; 2017cf0: 10 80 00 03 b 2017cfc <== NOT EXECUTED 2017cf4: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 2017cf8: c2 22 21 80 st %g1, [ %o0 + 0x180 ] if (_Thread_Is_executing(the_thread)) { 2017cfc: 03 00 80 e6 sethi %hi(0x2039800), %g1 2017d00: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1 ! 2039bf0 <_Thread_Executing> 2017d04: 80 a2 00 01 cmp %o0, %g1 2017d08: 12 80 00 0c bne 2017d38 2017d0c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 if (tvp->dtor) 2017d10: 80 a0 a0 00 cmp %g2, 0 2017d14: 22 80 00 06 be,a 2017d2c 2017d18: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 2017d1c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2017d20: 9f c0 80 00 call %g2 <== NOT EXECUTED 2017d24: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 2017d28: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 2017d2c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2017d30: 10 80 00 07 b 2017d4c 2017d34: c2 20 80 00 st %g1, [ %g2 ] } else { if (tvp->dtor) 2017d38: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2017d3c: 02 80 00 05 be 2017d50 <== NOT EXECUTED 2017d40: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 2017d44: 9f c0 80 00 call %g2 <== NOT EXECUTED 2017d48: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2017d4c: 92 10 00 18 mov %i0, %o1 2017d50: 11 00 80 e6 sethi %hi(0x2039800), %o0 2017d54: 7f ff c5 b9 call 2009438 <_Heap_Free> 2017d58: 90 12 23 5c or %o0, 0x35c, %o0 ! 2039b5c <_Workspace_Area> } _Workspace_Free(tvp); _Thread_Enable_dispatch(); 2017d5c: 7f ff ff a0 call 2017bdc <_Thread_Enable_dispatch> 2017d60: b0 10 20 00 clr %i0 2017d64: 81 c7 e0 08 ret 2017d68: 81 e8 00 00 restore return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 2017d6c: f0 06 00 00 ld [ %i0 ], %i0 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 2017d70: 80 a6 20 00 cmp %i0, 0 2017d74: 32 bf ff d9 bne,a 2017cd8 2017d78: c2 06 20 04 ld [ %i0 + 4 ], %g1 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2017d7c: 7f ff ff 98 call 2017bdc <_Thread_Enable_dispatch> <== NOT EXECUTED 2017d80: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017d84: 81 c7 e0 08 ret <== NOT EXECUTED 2017d88: 81 e8 00 00 restore <== NOT EXECUTED 02017dc0 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 2017dc0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 2017dc4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2017dc8: 02 80 00 3f be 2017ec4 <== NOT EXECUTED 2017dcc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 2017dd0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 2017dd4: 02 80 00 3c be 2017ec4 <== NOT EXECUTED 2017dd8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED uint32_t the_api; uint32_t the_class; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 2017ddc: 12 80 00 0a bne 2017e04 <== NOT EXECUTED 2017de0: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2017de4: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 2017de8: c4 00 63 10 ld [ %g1 + 0x310 ], %g2 ! 2039b10 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2017dec: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2017df0: c4 20 63 10 st %g2, [ %g1 + 0x310 ] <== NOT EXECUTED 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; 2017df4: 03 00 80 e6 sethi %hi(0x2039800), %g1 <== NOT EXECUTED 2017df8: d0 00 63 f0 ld [ %g1 + 0x3f0 ], %o0 ! 2039bf0 <_Thread_Executing> <== NOT EXECUTED 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; 2017dfc: 10 80 00 19 b 2017e60 <== NOT EXECUTED 2017e00: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED 2017e04: 84 08 60 07 and %g1, 7, %g2 <== NOT EXECUTED tp = _Thread_Executing; goto done; } the_api = _Objects_Get_API( id ); if ( the_api && the_api > OBJECTS_APIS_LAST ) { 2017e08: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2017e0c: 18 80 00 06 bgu 2017e24 <== NOT EXECUTED 2017e10: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2017e14: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 2017e18: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017e1c: 02 80 00 05 be 2017e30 <== NOT EXECUTED 2017e20: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017e24: 90 10 20 00 clr %o0 <== NOT EXECUTED 2017e28: 10 80 00 0e b 2017e60 <== NOT EXECUTED 2017e2c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2017e30: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 2017e34: 05 00 80 e6 sethi %hi(0x2039800), %g2 <== NOT EXECUTED 2017e38: 84 10 a2 70 or %g2, 0x270, %g2 ! 2039a70 <_Objects_Information_table> <== NOT EXECUTED 2017e3c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== NOT EXECUTED 2017e40: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 2017e44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017e48: 12 80 00 04 bne 2017e58 <== NOT EXECUTED 2017e4c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; 2017e50: 10 80 00 04 b 2017e60 <== NOT EXECUTED 2017e54: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2017e58: 7f ff c7 ed call 2009e0c <_Objects_Get> <== NOT EXECUTED 2017e5c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 2017e60: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2017e64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017e68: 22 80 00 10 be,a 2017ea8 <== NOT EXECUTED 2017e6c: d0 02 21 80 ld [ %o0 + 0x180 ], %o0 <== NOT EXECUTED 2017e70: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2017e74: 08 80 00 0b bleu 2017ea0 <== NOT EXECUTED 2017e78: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2017e7c: 81 c7 e0 08 ret <== NOT EXECUTED 2017e80: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 2017e84: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2017e88: 32 80 00 08 bne,a 2017ea8 <== NOT EXECUTED 2017e8c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 2017e90: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 2017e94: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017e98: 7f ff ff bd call 2017d8c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017e9c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 2017ea0: 81 c7 e0 08 ret <== NOT EXECUTED 2017ea4: 81 e8 00 00 restore <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 2017ea8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017eac: 32 bf ff f6 bne,a 2017e84 <== NOT EXECUTED 2017eb0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 2017eb4: 7f ff ff b6 call 2017d8c <_Thread_Enable_dispatch> <== NOT EXECUTED 2017eb8: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED 2017ebc: 81 c7 e0 08 ret <== NOT EXECUTED 2017ec0: 81 e8 00 00 restore <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; 2017ec4: b0 10 20 09 mov 9, %i0 <== NOT EXECUTED } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2017ec8: 81 c7 e0 08 ret <== NOT EXECUTED 2017ecc: 81 e8 00 00 restore <== NOT EXECUTED 02003074 : int cbufsize, int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize; 2003074: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED 2003078: d0 20 60 9c st %o0, [ %g1 + 0x9c ] ! 2017c9c <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 200307c: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; return RTEMS_SUCCESSFUL; } 2003080: 90 10 20 00 clr %o0 <== NOT EXECUTED int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize; rtems_termios_raw_input_size = raw_input; 2003084: d2 20 60 a0 st %o1, [ %g1 + 0xa0 ] <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 2003088: 03 00 80 5f sethi %hi(0x2017c00), %g1 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 200308c: 81 c3 e0 08 retl <== NOT EXECUTED 2003090: d4 20 60 a4 st %o2, [ %g1 + 0xa4 ] ! 2017ca4 <== NOT EXECUTED 020046e8 : } } rtems_status_code rtems_termios_close (void *arg) { 20046e8: 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); 20046ec: 03 00 80 62 sethi %hi(0x2018800), %g1 20046f0: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 2018994 rtems_status_code rtems_termios_close (void *arg) { rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 20046f4: c2 06 00 00 ld [ %i0 ], %g1 rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 20046f8: 92 10 20 00 clr %o1 rtems_status_code rtems_termios_close (void *arg) { rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 20046fc: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2004700: 40 00 04 9c call 2005970 2004704: 94 10 20 00 clr %o2 if (sc != RTEMS_SUCCESSFUL) 2004708: 80 a2 20 00 cmp %o0, 0 200470c: 22 80 00 05 be,a 2004720 2004710: c2 04 20 08 ld [ %l0 + 8 ], %g1 rtems_fatal_error_occurred (sc); 2004714: 40 00 07 95 call 2006568 <== NOT EXECUTED 2004718: 01 00 00 00 nop <== NOT EXECUTED if (--tty->refcount == 0) { 200471c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 2004720: 82 00 7f ff add %g1, -1, %g1 2004724: 80 a0 60 00 cmp %g1, 0 2004728: 12 80 00 5b bne 2004894 200472c: c2 24 20 08 st %g1, [ %l0 + 8 ] if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 2004730: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 2004734: 03 00 80 61 sethi %hi(0x2018400), %g1 2004738: 82 10 61 dc or %g1, 0x1dc, %g1 ! 20185dc 200473c: 85 28 a0 05 sll %g2, 5, %g2 2004740: 84 00 80 01 add %g2, %g1, %g2 2004744: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2004748: 80 a0 60 00 cmp %g1, 0 200474c: 02 80 00 06 be 2004764 2004750: 01 00 00 00 nop /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 2004754: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004758: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED * default: just flush output buffer */ drainOutput (tty); } if (tty->device.outputUsesInterrupts 200475c: 10 80 00 05 b 2004770 <== NOT EXECUTED 2004760: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 2004764: 7f ff fd c5 call 2003e78 2004768: 90 10 00 10 mov %l0, %o0 } if (tty->device.outputUsesInterrupts 200476c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004770: 80 a0 60 02 cmp %g1, 2 2004774: 32 80 00 13 bne,a 20047c0 2004778: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 200477c: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED 2004780: 40 00 02 ad call 2005234 <== NOT EXECUTED 2004784: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 2004788: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200478c: 22 80 00 05 be,a 20047a0 <== NOT EXECUTED 2004790: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004794: 40 00 07 75 call 2006568 <== NOT EXECUTED 2004798: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_event_send( 200479c: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED 20047a0: 40 00 02 a5 call 2005234 <== NOT EXECUTED 20047a4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 20047a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20047ac: 22 80 00 05 be,a 20047c0 <== NOT EXECUTED 20047b0: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20047b4: 40 00 07 6d call 2006568 <== NOT EXECUTED 20047b8: 01 00 00 00 nop <== NOT EXECUTED } if (tty->device.lastClose) 20047bc: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED 20047c0: 80 a0 60 00 cmp %g1, 0 20047c4: 22 80 00 07 be,a 20047e0 20047c8: c2 04 00 00 ld [ %l0 ], %g1 (*tty->device.lastClose)(tty->major, tty->minor, arg); 20047cc: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 20047d0: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 20047d4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20047d8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED if (tty->forw == NULL) { 20047dc: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 20047e0: 80 a0 60 00 cmp %g1, 0 20047e4: 12 80 00 08 bne 2004804 20047e8: c4 04 20 04 ld [ %l0 + 4 ], %g2 rtems_termios_ttyTail = tty->back; 20047ec: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( rtems_termios_ttyTail != NULL ) { 20047f0: 80 a0 a0 00 cmp %g2, 0 20047f4: 02 80 00 05 be 2004808 20047f8: c4 20 61 98 st %g2, [ %g1 + 0x198 ] rtems_termios_ttyTail->forw = NULL; 20047fc: 10 80 00 03 b 2004808 <== NOT EXECUTED 2004800: c0 20 80 00 clr [ %g2 ] <== NOT EXECUTED } } else { tty->forw->back = tty->back; 2004804: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED } if (tty->back == NULL) { 2004808: c2 04 20 04 ld [ %l0 + 4 ], %g1 200480c: 80 a0 60 00 cmp %g1, 0 2004810: 12 80 00 08 bne 2004830 2004814: c4 04 00 00 ld [ %l0 ], %g2 rtems_termios_ttyHead = tty->forw; 2004818: 03 00 80 62 sethi %hi(0x2018800), %g1 if ( rtems_termios_ttyHead != NULL ) { 200481c: 80 a0 a0 00 cmp %g2, 0 2004820: 02 80 00 05 be 2004834 2004824: c4 20 61 9c st %g2, [ %g1 + 0x19c ] rtems_termios_ttyHead->back = NULL; 2004828: 10 80 00 03 b 2004834 <== NOT EXECUTED 200482c: c0 20 a0 04 clr [ %g2 + 4 ] <== NOT EXECUTED } } else { tty->back->forw = tty->forw; 2004830: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 2004834: 40 00 04 08 call 2005854 2004838: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 rtems_semaphore_delete (tty->osem); 200483c: 40 00 04 06 call 2005854 2004840: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 2004844: 40 00 04 04 call 2005854 2004848: d0 04 20 8c ld [ %l0 + 0x8c ], %o0 if ((tty->device.pollRead == NULL) || 200484c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 2004850: 80 a0 60 00 cmp %g1, 0 2004854: 02 80 00 06 be 200486c 2004858: 01 00 00 00 nop 200485c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004860: 80 a0 60 02 cmp %g1, 2 2004864: 12 80 00 04 bne 2004874 2004868: 01 00 00 00 nop (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 200486c: 40 00 03 fa call 2005854 <== NOT EXECUTED 2004870: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED free (tty->rawInBuf.theBuf); 2004874: 7f ff f6 62 call 20021fc 2004878: d0 04 20 58 ld [ %l0 + 0x58 ], %o0 free (tty->rawOutBuf.theBuf); 200487c: 7f ff f6 60 call 20021fc 2004880: d0 04 20 7c ld [ %l0 + 0x7c ], %o0 free (tty->cbuf); 2004884: 7f ff f6 5e call 20021fc 2004888: d0 04 20 1c ld [ %l0 + 0x1c ], %o0 free (tty); 200488c: 7f ff f6 5c call 20021fc 2004890: 90 10 00 10 mov %l0, %o0 } rtems_semaphore_release (rtems_termios_ttyMutex); 2004894: 03 00 80 62 sethi %hi(0x2018800), %g1 2004898: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 2018994 200489c: 40 00 04 fc call 2005c8c 20048a0: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 20048a4: 81 c7 e0 08 ret 20048a8: 81 e8 00 00 restore 02003298 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 2003298: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 200329c: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 20032a0: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2 <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 20032a4: 82 00 40 19 add %g1, %i1, %g1 <== NOT EXECUTED 20032a8: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 20032ac: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 20032b0: 12 80 00 0b bne 20032dc <== NOT EXECUTED 20032b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 20032b8: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED 20032bc: 40 00 07 de call 2005234 <== NOT EXECUTED 20032c0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 20032c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20032c8: 02 80 00 12 be 2003310 <== NOT EXECUTED 20032cc: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20032d0: 40 00 0c a6 call 2006568 <== NOT EXECUTED 20032d4: 01 00 00 00 nop <== NOT EXECUTED 20032d8: 30 80 00 0e b,a 2003310 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { 20032dc: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 20032e0: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 20032e4: 12 80 00 09 bne 2003308 <== NOT EXECUTED 20032e8: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 20032ec: c2 00 62 90 ld [ %g1 + 0x290 ], %g1 ! 2018690 <== NOT EXECUTED 20032f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20032f4: 02 80 00 07 be 2003310 <== NOT EXECUTED 20032f8: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 20032fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003300: 01 00 00 00 nop <== NOT EXECUTED 2003304: 30 80 00 03 b,a 2003310 <== NOT EXECUTED } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 2003308: 7f ff ff 69 call 20030ac <== NOT EXECUTED 200330c: 81 e8 00 00 restore <== NOT EXECUTED } } 2003310: 81 c7 e0 08 ret <== NOT EXECUTED 2003314: 81 e8 00 00 restore <== NOT EXECUTED 02003318 : * 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) { 2003318: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED char c; int dropped = 0; boolean flow_rcv = FALSE; /* TRUE, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 200331c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 2003320: 05 00 80 61 sethi %hi(0x2018400), %g2 <== NOT EXECUTED 2003324: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 2003328: 84 10 a1 dc or %g2, 0x1dc, %g2 <== NOT EXECUTED 200332c: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 2003330: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 2003334: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003338: 12 80 00 10 bne 2003378 <== NOT EXECUTED 200333c: a0 10 00 02 mov %g2, %l0 <== NOT EXECUTED 2003340: a6 10 20 00 clr %l3 <== NOT EXECUTED 2003344: ac 10 20 00 clr %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); 2003348: aa 06 20 30 add %i0, 0x30, %l5 <== 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, 200334c: 10 80 00 ac b 20035fc <== NOT EXECUTED 2003350: a8 06 20 4a add %i0, 0x4a, %l4 <== NOT EXECUTED boolean flow_rcv = FALSE; /* TRUE, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { c = *buf++; 2003354: d0 0e 40 00 ldub [ %i1 ], %o0 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 2003358: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 200335c: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED 2003360: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 2003364: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED boolean flow_rcv = FALSE; /* TRUE, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { c = *buf++; 2003368: b2 06 60 01 inc %i1 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 200336c: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED 2003370: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003374: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED int dropped = 0; boolean 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--) { 2003378: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED 200337c: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED 2003380: 32 bf ff f5 bne,a 2003354 <== NOT EXECUTED 2003384: 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 )) { 2003388: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED 200338c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003390: 12 80 00 a6 bne 2003628 <== NOT EXECUTED 2003394: a6 10 20 00 clr %l3 <== NOT EXECUTED 2003398: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED 200339c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20033a0: 22 80 00 a3 be,a 200362c <== NOT EXECUTED 20033a4: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 20033a8: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED 20033ac: 9f c0 40 00 call %g1 <== NOT EXECUTED 20033b0: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; 20033b4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20033b8: a6 10 20 00 clr %l3 <== NOT EXECUTED 20033bc: 10 80 00 9b b 2003628 <== NOT EXECUTED 20033c0: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED while (len--) { c = *buf++; /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 20033c4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20033c8: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 20033cc: 02 80 00 1b be 2003438 <== NOT EXECUTED 20033d0: 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]) { 20033d4: c4 0e 20 4a ldub [ %i0 + 0x4a ], %g2 <== NOT EXECUTED 20033d8: 83 2c a0 18 sll %l2, 0x18, %g1 <== NOT EXECUTED 20033dc: 87 38 60 18 sra %g1, 0x18, %g3 <== NOT EXECUTED 20033e0: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 20033e4: 12 80 00 0e bne 200341c <== NOT EXECUTED 20033e8: c2 0e 20 49 ldub [ %i0 + 0x49 ], %g1 <== NOT EXECUTED if (c == tty->termios.c_cc[VSTART]) { 20033ec: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED 20033f0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 20033f4: 12 80 00 05 bne 2003408 <== NOT EXECUTED 20033f8: 01 00 00 00 nop <== NOT EXECUTED /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 20033fc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003400: 10 80 00 04 b 2003410 <== NOT EXECUTED 2003404: 82 18 60 10 xor %g1, 0x10, %g1 <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 2003408: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 200340c: 82 10 60 10 or %g1, 0x10, %g1 <== NOT EXECUTED 2003410: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 2003414: 10 80 00 0c b 2003444 <== NOT EXECUTED 2003418: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = TRUE; } else if (c == tty->termios.c_cc[VSTART]) { 200341c: 82 08 60 ff and %g1, 0xff, %g1 <== NOT EXECUTED 2003420: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2003424: 12 80 00 06 bne 200343c <== NOT EXECUTED 2003428: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 200342c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003430: 10 bf ff f8 b 2003410 <== NOT EXECUTED 2003434: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED flow_rcv = TRUE; } } if (flow_rcv) { 2003438: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200343c: 02 80 00 1c be 20034ac <== NOT EXECUTED 2003440: 01 00 00 00 nop <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 2003444: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003448: 82 08 60 30 and %g1, 0x30, %g1 <== NOT EXECUTED 200344c: 80 a0 60 20 cmp %g1, 0x20 <== NOT EXECUTED 2003450: 32 80 00 6b bne,a 20035fc <== NOT EXECUTED 2003454: b2 06 60 01 inc %i1 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 2003458: 7f ff fa 41 call 2001d5c <== NOT EXECUTED 200345c: 01 00 00 00 nop <== NOT EXECUTED 2003460: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 2003464: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 2003468: 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; 200346c: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED 2003470: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 2003474: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003478: 02 80 00 09 be 200349c <== NOT EXECUTED 200347c: 01 00 00 00 nop <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 2003480: d2 06 20 84 ld [ %i0 + 0x84 ], %o1 <== NOT EXECUTED 2003484: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED 2003488: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 200348c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 2003490: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 2003494: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003498: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 200349c: 7f ff fa 34 call 2001d6c <== NOT EXECUTED 20034a0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 20034a4: 10 80 00 56 b 20035fc <== NOT EXECUTED 20034a8: b2 06 60 01 inc %i1 <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 20034ac: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED 20034b0: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED 20034b4: 40 00 48 14 call 2015504 <.urem> <== NOT EXECUTED 20034b8: 90 02 20 01 inc %o0 <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 20034bc: 7f ff fa 28 call 2001d5c <== NOT EXECUTED 20034c0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20034c4: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 20034c8: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 20034cc: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 20034d0: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED 20034d4: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED 20034d8: 40 00 48 0b call 2015504 <.urem> <== NOT EXECUTED 20034dc: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED 20034e0: c2 06 20 c0 ld [ %i0 + 0xc0 ], %g1 <== NOT EXECUTED 20034e4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 20034e8: 08 80 00 2d bleu 200359c <== NOT EXECUTED 20034ec: 01 00 00 00 nop <== NOT EXECUTED 20034f0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20034f4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 20034f8: 12 80 00 29 bne 200359c <== NOT EXECUTED 20034fc: 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; 2003500: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003504: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED 2003508: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 200350c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003510: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED 2003514: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED 2003518: 12 80 00 13 bne 2003564 <== NOT EXECUTED 200351c: 01 00 00 00 nop <== NOT EXECUTED == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || 2003520: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003524: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003528: 12 80 00 06 bne 2003540 <== NOT EXECUTED 200352c: 01 00 00 00 nop <== NOT EXECUTED 2003530: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED 2003534: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003538: 12 80 00 19 bne 200359c <== NOT EXECUTED 200353c: 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; 2003540: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003544: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 2003548: 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; 200354c: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003550: 92 10 00 14 mov %l4, %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; 2003554: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003558: 9f c0 80 00 call %g2 <== NOT EXECUTED 200355c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 2003560: 30 80 00 0f b,a 200359c <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 2003564: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003568: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED 200356c: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED 2003570: 12 80 00 0b bne 200359c <== NOT EXECUTED 2003574: 01 00 00 00 nop <== NOT EXECUTED == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 2003578: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 200357c: 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; 2003580: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED 2003584: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 2003588: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200358c: 02 80 00 04 be 200359c <== NOT EXECUTED 2003590: 01 00 00 00 nop <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 2003594: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003598: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 200359c: 7f ff f9 f4 call 2001d6c <== NOT EXECUTED 20035a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 20035a4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 20035a8: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 20035ac: 32 80 00 04 bne,a 20035bc <== NOT EXECUTED 20035b0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED dropped++; 20035b4: 10 80 00 11 b 20035f8 <== NOT EXECUTED 20035b8: a6 04 e0 01 inc %l3 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 20035bc: 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 )) { 20035c0: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; tty->rawInBuf.Tail = newTail; 20035c4: 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 )) { 20035c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20035cc: 32 80 00 0c bne,a 20035fc <== NOT EXECUTED 20035d0: b2 06 60 01 inc %i1 <== NOT EXECUTED 20035d4: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED 20035d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20035dc: 22 80 00 08 be,a 20035fc <== NOT EXECUTED 20035e0: b2 06 60 01 inc %i1 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 20035e4: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED 20035e8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20035ec: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; 20035f0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20035f4: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 20035f8: b2 06 60 01 inc %i1 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 20035fc: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED 2003600: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED 2003604: 12 bf ff 70 bne 20033c4 <== NOT EXECUTED 2003608: 01 00 00 00 nop <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 200360c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 2003610: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 2003614: 82 00 40 13 add %g1, %l3, %g1 <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 2003618: 40 00 09 9d call 2005c8c <== NOT EXECUTED 200361c: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED return dropped; } 2003620: 81 c7 e0 08 ret <== NOT EXECUTED 2003624: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED 2003628: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED 200362c: 81 c7 e0 08 ret <== NOT EXECUTED 2003630: 81 e8 00 00 restore <== NOT EXECUTED 02003028 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 2003028: 9d e3 bf 98 save %sp, -104, %sp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 200302c: 03 00 80 62 sethi %hi(0x2018800), %g1 2003030: c4 00 61 94 ld [ %g1 + 0x194 ], %g2 ! 2018994 2003034: 80 a0 a0 00 cmp %g2, 0 2003038: 12 80 00 0d bne 200306c 200303c: 98 10 61 94 or %g1, 0x194, %o4 sc = rtems_semaphore_create ( 2003040: 11 15 14 9b sethi %hi(0x54526c00), %o0 2003044: 92 10 20 01 mov 1, %o1 2003048: 90 12 21 69 or %o0, 0x169, %o0 200304c: 94 10 20 54 mov 0x54, %o2 2003050: 40 00 09 6e call 2005608 2003054: 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) 2003058: 80 a2 20 00 cmp %o0, 0 200305c: 02 80 00 04 be 200306c 2003060: 01 00 00 00 nop rtems_fatal_error_occurred (sc); 2003064: 40 00 0d 41 call 2006568 <== NOT EXECUTED 2003068: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200306c: 81 c7 e0 08 ret 2003070: 81 e8 00 00 restore 020042e0 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 20042e0: 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; 20042e4: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; rtems_status_code sc; args->ioctl_return = 0; 20042e8: 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; 20042ec: e2 00 60 28 ld [ %g1 + 0x28 ], %l1 <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 20042f0: 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); 20042f4: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED } } rtems_status_code rtems_termios_ioctl (void *arg) { 20042f8: 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); 20042fc: 92 10 20 00 clr %o1 <== NOT EXECUTED 2004300: 40 00 05 9c call 2005970 <== NOT EXECUTED 2004304: 94 10 20 00 clr %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 2004308: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 200430c: 22 80 00 05 be,a 2004320 <== NOT EXECUTED 2004310: c4 04 a0 04 ld [ %l2 + 4 ], %g2 <== NOT EXECUTED args->ioctl_return = sc; 2004314: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED 2004318: 81 c7 e0 08 ret <== NOT EXECUTED 200431c: 81 e8 00 00 restore <== NOT EXECUTED return sc; } switch (args->command) { 2004320: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2004324: 22 80 00 c0 be,a 2004624 <== NOT EXECUTED 2004328: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 200432c: 18 80 00 0b bgu 2004358 <== NOT EXECUTED 2004330: 03 10 01 19 sethi %hi(0x40046400), %g1 <== NOT EXECUTED 2004334: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 2004338: 22 80 00 2d be,a 20043ec <== NOT EXECUTED 200433c: d2 04 a0 08 ld [ %l2 + 8 ], %o1 <== NOT EXECUTED 2004340: 18 80 00 b2 bgu 2004608 <== NOT EXECUTED 2004344: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2004348: 32 80 00 18 bne,a 20043a8 <== NOT EXECUTED 200434c: 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; 2004350: 10 80 00 23 b 20043dc <== NOT EXECUTED 2004354: d0 04 a0 08 ld [ %l2 + 8 ], %o0 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 2004358: 82 10 62 7f or %g1, 0x27f, %g1 <== NOT EXECUTED 200435c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004360: 02 80 00 d0 be 20046a0 <== NOT EXECUTED 2004364: 01 00 00 00 nop <== NOT EXECUTED 2004368: 38 80 00 07 bgu,a 2004384 <== NOT EXECUTED 200436c: 03 10 01 1d sethi %hi(0x40047400), %g1 <== NOT EXECUTED 2004370: 80 a0 a0 05 cmp %g2, 5 <== NOT EXECUTED 2004374: 32 80 00 0d bne,a 20043a8 <== NOT EXECUTED 2004378: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 200437c: 10 80 00 a6 b 2004614 <== NOT EXECUTED 2004380: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 2004384: 82 10 60 1a or %g1, 0x1a, %g1 <== NOT EXECUTED 2004388: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 200438c: 02 80 00 c1 be 2004690 <== NOT EXECUTED 2004390: 03 20 01 1d sethi %hi(0x80047400), %g1 <== NOT EXECUTED 2004394: 82 10 60 1b or %g1, 0x1b, %g1 ! 8004741b <== NOT EXECUTED 2004398: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 200439c: 22 80 00 a6 be,a 2004634 <== NOT EXECUTED 20043a0: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 20043a4: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED 20043a8: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 20043ac: 82 10 61 dc or %g1, 0x1dc, %g1 ! 20185dc <== NOT EXECUTED 20043b0: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED 20043b4: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED 20043b8: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 <== NOT EXECUTED 20043bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20043c0: 02 80 00 c5 be 20046d4 <== NOT EXECUTED 20043c4: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 20043c8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20043cc: 9f c0 40 00 call %g1 <== NOT EXECUTED 20043d0: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { sc = rtems_termios_linesw[tty->t_line].l_open(tty); 20043d4: 10 80 00 c0 b 20046d4 <== NOT EXECUTED 20043d8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 20043dc: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED 20043e0: 40 00 29 d5 call 200eb34 <== NOT EXECUTED 20043e4: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED 20043e8: 30 80 00 bb b,a 20046d4 <== NOT EXECUTED break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 20043ec: 90 04 60 30 add %l1, 0x30, %o0 <== NOT EXECUTED 20043f0: 40 00 29 d1 call 200eb34 <== NOT EXECUTED 20043f4: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 20043f8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20043fc: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 2004400: 02 80 00 20 be 2004480 <== NOT EXECUTED 2004404: 01 00 00 00 nop <== NOT EXECUTED 2004408: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED 200440c: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED 2004410: 12 80 00 1c bne 2004480 <== NOT EXECUTED 2004414: 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); 2004418: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 200441c: 82 08 7d ef and %g1, -529, %g1 <== NOT EXECUTED 2004420: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 2004424: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004428: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 200442c: 02 80 00 15 be 2004480 <== NOT EXECUTED 2004430: 01 00 00 00 nop <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 2004434: 7f ff f6 4a call 2001d5c <== NOT EXECUTED 2004438: 01 00 00 00 nop <== NOT EXECUTED 200443c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 2004440: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 2004444: 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; 2004448: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED 200444c: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 2004450: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2004454: 02 80 00 09 be 2004478 <== NOT EXECUTED 2004458: 01 00 00 00 nop <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 200445c: d2 04 60 84 ld [ %l1 + 0x84 ], %o1 <== NOT EXECUTED 2004460: c2 04 60 7c ld [ %l1 + 0x7c ], %g1 <== NOT EXECUTED 2004464: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 <== NOT EXECUTED 2004468: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED 200446c: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 2004470: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004474: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 2004478: 7f ff f6 3d call 2001d6c <== NOT EXECUTED 200447c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 2004480: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004484: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED 2004488: 02 80 00 0c be 20044b8 <== NOT EXECUTED 200448c: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED 2004490: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED 2004494: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2004498: 12 80 00 08 bne 20044b8 <== NOT EXECUTED 200449c: 01 00 00 00 nop <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 20044a0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20044a4: 82 08 7b ff and %g1, -1025, %g1 <== NOT EXECUTED 20044a8: 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); 20044ac: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20044b0: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED 20044b4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && 20044b8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20044bc: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED 20044c0: 02 80 00 16 be 2004518 <== NOT EXECUTED 20044c4: c2 04 60 38 ld [ %l1 + 0x38 ], %g1 <== NOT EXECUTED 20044c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20044cc: 06 80 00 14 bl 200451c <== NOT EXECUTED 20044d0: 01 00 00 00 nop <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 20044d4: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20044d8: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED 20044dc: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && 20044e0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20044e4: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED 20044e8: 02 80 00 08 be 2004508 <== NOT EXECUTED 20044ec: 01 00 00 00 nop <== NOT EXECUTED 20044f0: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 20044f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20044f8: 02 80 00 04 be 2004508 <== NOT EXECUTED 20044fc: 01 00 00 00 nop <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 2004500: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004504: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 2004508: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 200450c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED 2004510: 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) { 2004514: c2 04 60 38 ld [ %l1 + 0x38 ], %g1 <== NOT EXECUTED 2004518: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200451c: 36 80 00 06 bge,a 2004534 <== NOT EXECUTED 2004520: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; 2004524: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004528: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED 200452c: 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) { 2004530: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED 2004534: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED 2004538: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 200453c: 22 80 00 06 be,a 2004554 <== NOT EXECUTED 2004540: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 2004544: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004548: 82 10 64 00 or %g1, 0x400, %g1 <== NOT EXECUTED 200454c: 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) { 2004550: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED 2004554: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED 2004558: 22 80 00 06 be,a 2004570 <== NOT EXECUTED 200455c: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 2004560: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004564: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED 2004568: 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) { 200456c: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED 2004570: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 2004574: 32 80 00 19 bne,a 20045d8 <== NOT EXECUTED 2004578: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { rtems_interval ticksPerSecond; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond); 200457c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 2004580: 40 00 02 40 call 2004e80 <== NOT EXECUTED 2004584: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 2004588: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED 200458c: e0 0c 60 46 ldub [ %l1 + 0x46 ], %l0 <== NOT EXECUTED 2004590: 40 00 42 f7 call 201516c <.umul> <== NOT EXECUTED 2004594: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2004598: 40 00 43 2f call 2015254 <.udiv> <== NOT EXECUTED 200459c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 20045a0: d0 24 60 54 st %o0, [ %l1 + 0x54 ] <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 20045a4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 20045a8: 02 80 00 08 be 20045c8 <== NOT EXECUTED 20045ac: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 20045b0: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; if (tty->termios.c_cc[VMIN]) 20045b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20045b8: 12 80 00 09 bne 20045dc <== NOT EXECUTED 20045bc: d0 24 60 70 st %o0, [ %l1 + 0x70 ] <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 20045c0: 10 80 00 0a b 20045e8 <== NOT EXECUTED 20045c4: d0 24 60 74 st %o0, [ %l1 + 0x74 ] <== NOT EXECUTED } else { if (tty->termios.c_cc[VMIN]) { 20045c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20045cc: 02 80 00 06 be 20045e4 <== NOT EXECUTED 20045d0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 20045d4: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 20045d8: c0 24 60 70 clr [ %l1 + 0x70 ] <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 20045dc: 10 80 00 03 b 20045e8 <== NOT EXECUTED 20045e0: c0 24 60 74 clr [ %l1 + 0x74 ] <== NOT EXECUTED } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 20045e4: c2 24 60 6c st %g1, [ %l1 + 0x6c ] <== NOT EXECUTED } } } if (tty->device.setAttributes) 20045e8: c2 04 60 a8 ld [ %l1 + 0xa8 ], %g1 <== NOT EXECUTED 20045ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20045f0: 02 80 00 39 be 20046d4 <== NOT EXECUTED 20045f4: 01 00 00 00 nop <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 20045f8: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED 20045fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004600: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED 2004604: 30 80 00 34 b,a 20046d4 <== NOT EXECUTED break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 2004608: 7f ff fe 1c call 2003e78 <== NOT EXECUTED 200460c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2004610: 30 80 00 31 b,a 20046d4 <== NOT EXECUTED break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 2004614: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] <== NOT EXECUTED 2004618: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200461c: 10 80 00 2e b 20046d4 <== NOT EXECUTED 2004620: c2 24 60 d8 st %g1, [ %l1 + 0xd8 ] <== NOT EXECUTED break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 2004624: c2 24 60 dc st %g1, [ %l1 + 0xdc ] <== NOT EXECUTED 2004628: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200462c: 10 80 00 2a b 20046d4 <== NOT EXECUTED 2004630: c2 24 60 e0 st %g1, [ %l1 + 0xe0 ] <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 2004634: 05 00 80 61 sethi %hi(0x2018400), %g2 <== NOT EXECUTED 2004638: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 200463c: a0 10 a1 dc or %g2, 0x1dc, %l0 <== NOT EXECUTED 2004640: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED 2004644: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED 2004648: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200464c: 22 80 00 06 be,a 2004664 <== NOT EXECUTED 2004650: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 2004654: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004658: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200465c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 2004660: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 2004664: 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); 2004668: c4 00 40 00 ld [ %g1 ], %g2 <== 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) { 200466c: 83 28 a0 05 sll %g2, 5, %g1 <== NOT EXECUTED 2004670: c2 04 00 01 ld [ %l0 + %g1 ], %g1 <== NOT EXECUTED 2004674: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004678: 02 80 00 17 be 20046d4 <== NOT EXECUTED 200467c: c4 24 60 cc st %g2, [ %l1 + 0xcc ] <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 2004680: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004684: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2004688: 10 80 00 13 b 20046d4 <== NOT EXECUTED 200468c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 2004690: c4 04 a0 08 ld [ %l2 + 8 ], %g2 <== NOT EXECUTED 2004694: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED 2004698: 10 80 00 0f b 20046d4 <== NOT EXECUTED 200469c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 20046a0: c4 04 60 60 ld [ %l1 + 0x60 ], %g2 <== NOT EXECUTED 20046a4: c2 04 60 5c ld [ %l1 + 0x5c ], %g1 <== NOT EXECUTED if ( rawnc < 0 ) 20046a8: 88 a0 80 01 subcc %g2, %g1, %g4 <== NOT EXECUTED 20046ac: 3c 80 00 05 bpos,a 20046c0 <== NOT EXECUTED 20046b0: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 20046b4: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 <== NOT EXECUTED 20046b8: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 20046bc: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED 20046c0: c4 04 60 24 ld [ %l1 + 0x24 ], %g2 <== NOT EXECUTED 20046c4: c6 04 a0 08 ld [ %l2 + 8 ], %g3 <== NOT EXECUTED 20046c8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 20046cc: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED 20046d0: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 20046d4: 40 00 05 6e call 2005c8c <== NOT EXECUTED 20046d8: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED args->ioctl_return = sc; 20046dc: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED return sc; } 20046e0: 81 c7 e0 08 ret <== NOT EXECUTED 20046e4: 81 e8 00 00 restore <== NOT EXECUTED 020048ac : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 20048ac: 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, 20048b0: 03 00 80 62 sethi %hi(0x2018800), %g1 20048b4: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 2018994 20048b8: 92 10 20 00 clr %o1 20048bc: 40 00 04 2d call 2005970 20048c0: 94 10 20 00 clr %o2 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 20048c4: a6 92 20 00 orcc %o0, 0, %l3 20048c8: 12 80 01 1c bne 2004d38 20048cc: 03 00 80 62 sethi %hi(0x2018800), %g1 return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 20048d0: 10 80 00 0a b 20048f8 20048d4: e0 00 61 9c ld [ %g1 + 0x19c ], %l0 ! 201899c if ((tty->major == major) && (tty->minor == minor)) 20048d8: 80 a0 40 18 cmp %g1, %i0 20048dc: 32 80 00 07 bne,a 20048f8 20048e0: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 20048e4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 20048e8: 80 a0 40 19 cmp %g1, %i1 20048ec: 22 80 00 ea be,a 2004c94 20048f0: c2 04 20 08 ld [ %l0 + 8 ], %g1 */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 20048f4: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 20048f8: 80 a4 20 00 cmp %l0, 0 20048fc: 32 bf ff f7 bne,a 20048d8 2004900: c2 04 20 0c ld [ %l0 + 0xc ], %g1 static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 2004904: 90 10 20 01 mov 1, %o0 2004908: 7f ff f6 fb call 20024f4 200490c: 92 10 20 e8 mov 0xe8, %o1 if (tty == NULL) { 2004910: a2 92 20 00 orcc %o0, 0, %l1 2004914: 02 80 00 0f be 2004950 2004918: 03 00 80 62 sethi %hi(0x2018800), %g1 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 200491c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004920: c2 00 60 a0 ld [ %g1 + 0xa0 ], %g1 ! 2017ca0 static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 2004924: a0 10 00 11 mov %l1, %l0 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 2004928: c2 24 60 64 st %g1, [ %l1 + 0x64 ] tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 200492c: d0 04 60 64 ld [ %l1 + 0x64 ], %o0 2004930: 7f ff f6 5b call 200229c 2004934: 01 00 00 00 nop if (tty->rawInBuf.theBuf == NULL) { 2004938: 80 a2 20 00 cmp %o0, 0 200493c: 12 80 00 08 bne 200495c 2004940: d0 24 60 58 st %o0, [ %l1 + 0x58 ] free(tty); 2004944: 7f ff f6 2e call 20021fc <== NOT EXECUTED 2004948: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 200494c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2004950: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 2018994 <== NOT EXECUTED 2004954: 10 80 00 f7 b 2004d30 <== NOT EXECUTED 2004958: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 200495c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004960: c2 00 60 a4 ld [ %g1 + 0xa4 ], %g1 ! 2017ca4 2004964: c2 24 60 88 st %g1, [ %l1 + 0x88 ] tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 2004968: d0 04 60 88 ld [ %l1 + 0x88 ], %o0 200496c: 7f ff f6 4c call 200229c 2004970: 01 00 00 00 nop if (tty->rawOutBuf.theBuf == NULL) { 2004974: 80 a2 20 00 cmp %o0, 0 2004978: 12 80 00 05 bne 200498c 200497c: d0 24 60 7c st %o0, [ %l1 + 0x7c ] free((void *)(tty->rawInBuf.theBuf)); 2004980: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED free(tty); rtems_semaphore_release (rtems_termios_ttyMutex); 2004984: 10 80 00 0c b 20049b4 <== NOT EXECUTED 2004988: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 200498c: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004990: 7f ff f6 43 call 200229c 2004994: d0 00 60 9c ld [ %g1 + 0x9c ], %o0 ! 2017c9c if (tty->cbuf == NULL) { 2004998: 80 a2 20 00 cmp %o0, 0 200499c: 12 80 00 0c bne 20049cc 20049a0: d0 24 60 1c st %o0, [ %l1 + 0x1c ] free((void *)(tty->rawOutBuf.theBuf)); 20049a4: d0 04 60 7c ld [ %l1 + 0x7c ], %o0 <== NOT EXECUTED 20049a8: 7f ff f6 15 call 20021fc <== NOT EXECUTED 20049ac: a6 10 20 1a mov 0x1a, %l3 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 20049b0: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED 20049b4: 7f ff f6 12 call 20021fc <== NOT EXECUTED 20049b8: 01 00 00 00 nop <== NOT EXECUTED free(tty); 20049bc: 7f ff f6 10 call 20021fc <== NOT EXECUTED 20049c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 20049c4: 10 80 00 da b 2004d2c <== NOT EXECUTED 20049c8: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED tty->tty_rcvwakeup = 0; /* * link tty */ tty->forw = rtems_termios_ttyHead; 20049cc: 07 00 80 62 sethi %hi(0x2018800), %g3 20049d0: c2 00 e1 9c ld [ %g3 + 0x19c ], %g1 ! 201899c return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 20049d4: c0 24 60 d4 clr [ %l1 + 0xd4 ] tty->tty_snd.sw_arg = NULL; 20049d8: c0 24 60 d8 clr [ %l1 + 0xd8 ] tty->tty_rcv.sw_pfn = NULL; 20049dc: c0 24 60 dc clr [ %l1 + 0xdc ] tty->tty_rcv.sw_arg = NULL; 20049e0: c0 24 60 e0 clr [ %l1 + 0xe0 ] tty->tty_rcvwakeup = 0; 20049e4: c0 24 60 e4 clr [ %l1 + 0xe4 ] /* * link tty */ tty->forw = rtems_termios_ttyHead; 20049e8: c2 24 40 00 st %g1, [ %l1 ] tty->back = NULL; if (rtems_termios_ttyHead != NULL) 20049ec: 80 a0 60 00 cmp %g1, 0 20049f0: 02 80 00 03 be 20049fc 20049f4: c0 24 60 04 clr [ %l1 + 4 ] rtems_termios_ttyHead->back = tty; 20049f8: e2 20 60 04 st %l1, [ %g1 + 4 ] <== NOT EXECUTED rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) 20049fc: 05 00 80 62 sethi %hi(0x2018800), %g2 2004a00: c2 00 a1 98 ld [ %g2 + 0x198 ], %g1 ! 2018998 2004a04: 80 a0 60 00 cmp %g1, 0 2004a08: 12 80 00 03 bne 2004a14 2004a0c: e0 20 e1 9c st %l0, [ %g3 + 0x19c ] rtems_termios_ttyTail = tty; 2004a10: e0 20 a1 98 st %l0, [ %g2 + 0x198 ] tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 2004a14: 25 00 80 5f sethi %hi(0x2017c00), %l2 2004a18: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 ! 2017ca8 2004a1c: 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; 2004a20: f2 24 20 10 st %i1, [ %l0 + 0x10 ] tty->major = major; 2004a24: f0 24 20 0c st %i0, [ %l0 + 0xc ] /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 2004a28: 90 12 21 00 or %o0, 0x100, %o0 2004a2c: 92 10 20 01 mov 1, %o1 2004a30: 90 10 40 08 or %g1, %o0, %o0 2004a34: 94 10 20 54 mov 0x54, %o2 2004a38: 96 10 20 00 clr %o3 2004a3c: 40 00 02 f3 call 2005608 2004a40: 98 04 20 14 add %l0, 0x14, %o4 rtems_build_name ('T', 'R', 'i', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) 2004a44: 80 a2 20 00 cmp %o0, 0 2004a48: 02 80 00 05 be 2004a5c 2004a4c: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 rtems_fatal_error_occurred (sc); 2004a50: 40 00 06 c6 call 2006568 <== NOT EXECUTED 2004a54: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_create ( 2004a58: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 <== NOT EXECUTED 2004a5c: 11 15 14 9b sethi %hi(0x54526c00), %o0 2004a60: 92 10 20 01 mov 1, %o1 2004a64: 90 12 23 00 or %o0, 0x300, %o0 2004a68: 94 10 20 54 mov 0x54, %o2 2004a6c: 90 10 40 08 or %g1, %o0, %o0 2004a70: 96 10 20 00 clr %o3 2004a74: 40 00 02 e5 call 2005608 2004a78: 98 04 20 18 add %l0, 0x18, %o4 rtems_build_name ('T', 'R', 'o', c), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) 2004a7c: 80 a2 20 00 cmp %o0, 0 2004a80: 02 80 00 05 be 2004a94 2004a84: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 rtems_fatal_error_occurred (sc); 2004a88: 40 00 06 b8 call 2006568 <== NOT EXECUTED 2004a8c: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_create ( 2004a90: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 <== NOT EXECUTED 2004a94: 11 15 14 9e sethi %hi(0x54527800), %o0 2004a98: 92 10 20 00 clr %o1 2004a9c: 90 10 40 08 or %g1, %o0, %o0 2004aa0: 94 10 20 20 mov 0x20, %o2 2004aa4: 96 10 20 00 clr %o3 2004aa8: 40 00 02 d8 call 2005608 2004aac: 98 04 20 8c add %l0, 0x8c, %o4 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 2004ab0: 80 a2 20 00 cmp %o0, 0 2004ab4: 22 80 00 05 be,a 2004ac8 2004ab8: c0 24 20 94 clr [ %l0 + 0x94 ] rtems_fatal_error_occurred (sc); 2004abc: 40 00 06 ab call 2006568 <== NOT EXECUTED 2004ac0: 01 00 00 00 nop <== NOT EXECUTED tty->rawOutBufState = rob_idle; 2004ac4: c0 24 20 94 clr [ %l0 + 0x94 ] <== NOT EXECUTED /* * Set callbacks */ tty->device = *callbacks; 2004ac8: 92 10 00 1b mov %i3, %o1 2004acc: 90 04 20 98 add %l0, 0x98, %o0 2004ad0: 40 00 28 19 call 200eb34 2004ad4: 94 10 20 20 mov 0x20, %o2 /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2004ad8: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004adc: 80 a0 60 02 cmp %g1, 2 2004ae0: 32 80 00 1f bne,a 2004b5c 2004ae4: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 sc = rtems_task_create ( 2004ae8: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 <== NOT EXECUTED 2004aec: 11 15 1e 15 sethi %hi(0x54785400), %o0 <== NOT EXECUTED 2004af0: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 2004af4: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 2004af8: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED 2004afc: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED 2004b00: 98 10 20 00 clr %o4 <== NOT EXECUTED 2004b04: 40 00 04 a8 call 2005da4 <== NOT EXECUTED 2004b08: 9a 04 20 c8 add %l0, 0xc8, %o5 <== NOT EXECUTED TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 2004b0c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004b10: 02 80 00 05 be 2004b24 <== NOT EXECUTED 2004b14: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004b18: 40 00 06 94 call 2006568 <== NOT EXECUTED 2004b1c: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_task_create ( 2004b20: c2 4c a0 a8 ldsb [ %l2 + 0xa8 ], %g1 <== NOT EXECUTED 2004b24: 11 14 9e 15 sethi %hi(0x52785400), %o0 <== NOT EXECUTED 2004b28: 92 10 20 09 mov 9, %o1 <== NOT EXECUTED 2004b2c: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 2004b30: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED 2004b34: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED 2004b38: 98 10 20 00 clr %o4 <== NOT EXECUTED 2004b3c: 40 00 04 9a call 2005da4 <== NOT EXECUTED 2004b40: 9a 04 20 c4 add %l0, 0xc4, %o5 <== NOT EXECUTED TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 2004b44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004b48: 22 80 00 05 be,a 2004b5c <== NOT EXECUTED 2004b4c: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004b50: 40 00 06 86 call 2006568 <== NOT EXECUTED 2004b54: 01 00 00 00 nop <== NOT EXECUTED } if ((tty->device.pollRead == NULL) || 2004b58: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 2004b5c: 80 a0 60 00 cmp %g1, 0 2004b60: 02 80 00 06 be 2004b78 2004b64: 03 00 80 5f sethi %hi(0x2017c00), %g1 2004b68: c2 04 60 b4 ld [ %l1 + 0xb4 ], %g1 2004b6c: 80 a0 60 02 cmp %g1, 2 2004b70: 12 80 00 10 bne 2004bb0 2004b74: 03 00 80 5f sethi %hi(0x2017c00), %g1 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 2004b78: c2 48 60 a8 ldsb [ %g1 + 0xa8 ], %g1 ! 2017ca8 <== NOT EXECUTED 2004b7c: 11 15 14 9c sethi %hi(0x54527000), %o0 <== NOT EXECUTED 2004b80: 92 10 20 00 clr %o1 <== NOT EXECUTED 2004b84: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED 2004b88: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED 2004b8c: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 2004b90: 96 10 20 00 clr %o3 <== NOT EXECUTED 2004b94: 40 00 02 9d call 2005608 <== NOT EXECUTED 2004b98: 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) 2004b9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004ba0: 02 80 00 04 be 2004bb0 <== NOT EXECUTED 2004ba4: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004ba8: 40 00 06 70 call 2006568 <== NOT EXECUTED 2004bac: 01 00 00 00 nop <== NOT EXECUTED 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; 2004bb0: c0 24 60 b8 clr [ %l1 + 0xb8 ] /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 2004bb4: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2004bb8: 09 00 80 5f sethi %hi(0x2017c00), %g4 2004bbc: c4 09 20 a8 ldub [ %g4 + 0xa8 ], %g2 ! 2017ca8 /* 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; 2004bc0: 83 30 60 01 srl %g1, 1, %g1 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'; 2004bc4: c0 2c 60 4c clrb [ %l1 + 0x4c ] /* 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; 2004bc8: c2 24 60 bc st %g1, [ %l1 + 0xbc ] 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'; 2004bcc: c0 2c 60 51 clrb [ %l1 + 0x51 ] 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; 2004bd0: c6 04 60 64 ld [ %l1 + 0x64 ], %g3 /* * Bump name characer */ if (c++ == 'z') 2004bd4: 84 00 a0 01 inc %g2 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 2004bd8: 03 00 00 09 sethi %hi(0x2400), %g1 tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2004bdc: c4 29 20 a8 stb %g2, [ %g4 + 0xa8 ] } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 2004be0: 82 10 61 02 or %g1, 0x102, %g1 2004be4: c2 24 60 30 st %g1, [ %l1 + 0x30 ] tty->termios.c_oflag = OPOST | ONLCR | XTABS; 2004be8: 03 00 00 06 sethi %hi(0x1800), %g1 2004bec: 82 10 60 05 or %g1, 5, %g1 ! 1805 2004bf0: c2 24 60 34 st %g1, [ %l1 + 0x34 ] tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 2004bf4: 82 10 28 bd mov 0x8bd, %g1 2004bf8: c2 24 60 38 st %g1, [ %l1 + 0x38 ] tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 2004bfc: 03 00 00 20 sethi %hi(0x8000), %g1 2004c00: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b 2004c04: c2 24 60 3c st %g1, [ %l1 + 0x3c ] tty->termios.c_cc[VINTR] = '\003'; 2004c08: 82 10 20 03 mov 3, %g1 2004c0c: c2 2c 60 41 stb %g1, [ %l1 + 0x41 ] tty->termios.c_cc[VQUIT] = '\034'; 2004c10: 82 10 20 1c mov 0x1c, %g1 2004c14: c2 2c 60 42 stb %g1, [ %l1 + 0x42 ] tty->termios.c_cc[VERASE] = '\177'; 2004c18: 82 10 20 7f mov 0x7f, %g1 2004c1c: c2 2c 60 43 stb %g1, [ %l1 + 0x43 ] tty->termios.c_cc[VKILL] = '\025'; 2004c20: 82 10 20 15 mov 0x15, %g1 2004c24: c2 2c 60 44 stb %g1, [ %l1 + 0x44 ] tty->termios.c_cc[VEOF] = '\004'; 2004c28: 82 10 20 04 mov 4, %g1 2004c2c: c2 2c 60 45 stb %g1, [ %l1 + 0x45 ] tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021'; 2004c30: 82 10 20 11 mov 0x11, %g1 2004c34: c2 2c 60 49 stb %g1, [ %l1 + 0x49 ] tty->termios.c_cc[VSTOP] = '\023'; 2004c38: 82 10 20 13 mov 0x13, %g1 2004c3c: c2 2c 60 4a stb %g1, [ %l1 + 0x4a ] tty->termios.c_cc[VSUSP] = '\032'; 2004c40: 82 10 20 1a mov 0x1a, %g1 2004c44: c2 2c 60 4b stb %g1, [ %l1 + 0x4b ] tty->termios.c_cc[VREPRINT] = '\022'; 2004c48: 82 10 20 12 mov 0x12, %g1 2004c4c: c2 2c 60 4d stb %g1, [ %l1 + 0x4d ] tty->termios.c_cc[VDISCARD] = '\017'; 2004c50: 82 10 20 0f mov 0xf, %g1 2004c54: c2 2c 60 4e stb %g1, [ %l1 + 0x4e ] tty->termios.c_cc[VWERASE] = '\027'; 2004c58: 82 10 20 17 mov 0x17, %g1 2004c5c: c2 2c 60 4f stb %g1, [ %l1 + 0x4f ] tty->termios.c_cc[VLNEXT] = '\026'; 2004c60: 82 10 20 16 mov 0x16, %g1 2004c64: c2 2c 60 50 stb %g1, [ %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; 2004c68: 83 28 e0 01 sll %g3, 1, %g1 2004c6c: 82 00 40 03 add %g1, %g3, %g1 2004c70: 83 30 60 02 srl %g1, 2, %g1 /* * Bump name characer */ if (c++ == 'z') 2004c74: 85 28 a0 18 sll %g2, 0x18, %g2 2004c78: 85 38 a0 18 sra %g2, 0x18, %g2 2004c7c: 80 a0 a0 7b cmp %g2, 0x7b 2004c80: 12 80 00 04 bne 2004c90 2004c84: c2 24 60 c0 st %g1, [ %l1 + 0xc0 ] c = 'a'; 2004c88: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED 2004c8c: c2 29 20 a8 stb %g1, [ %g4 + 0xa8 ] <== NOT EXECUTED } args->iop->data1 = tty; if (!tty->refcount++) { 2004c90: c2 04 20 08 ld [ %l0 + 8 ], %g1 */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 2004c94: c4 06 80 00 ld [ %i2 ], %g2 if (!tty->refcount++) { 2004c98: 82 00 60 01 inc %g1 */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 2004c9c: e0 20 a0 28 st %l0, [ %g2 + 0x28 ] if (!tty->refcount++) { 2004ca0: 80 a0 60 01 cmp %g1, 1 2004ca4: 12 80 00 21 bne 2004d28 2004ca8: c2 24 20 08 st %g1, [ %l0 + 8 ] if (tty->device.firstOpen) 2004cac: c2 04 20 98 ld [ %l0 + 0x98 ], %g1 2004cb0: 80 a0 60 00 cmp %g1, 0 2004cb4: 02 80 00 05 be 2004cc8 2004cb8: 90 10 00 18 mov %i0, %o0 (*tty->device.firstOpen)(major, minor, arg); 2004cbc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2004cc0: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004cc4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2004cc8: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004ccc: 80 a0 60 02 cmp %g1, 2 2004cd0: 12 80 00 17 bne 2004d2c 2004cd4: 03 00 80 62 sethi %hi(0x2018800), %g1 sc = rtems_task_start(tty->rxTaskId, 2004cd8: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED 2004cdc: 13 00 80 13 sethi %hi(0x2004c00), %o1 <== NOT EXECUTED 2004ce0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 2004ce4: 40 00 05 22 call 200616c <== NOT EXECUTED 2004ce8: 92 12 61 40 or %o1, 0x140, %o1 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 2004cec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004cf0: 22 80 00 05 be,a 2004d04 <== NOT EXECUTED 2004cf4: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004cf8: 40 00 06 1c call 2006568 <== NOT EXECUTED 2004cfc: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_task_start(tty->txTaskId, 2004d00: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED 2004d04: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 2004d08: 13 00 80 13 sethi %hi(0x2004c00), %o1 <== NOT EXECUTED 2004d0c: 40 00 05 18 call 200616c <== NOT EXECUTED 2004d10: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 2004db0 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 2004d14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004d18: 02 80 00 05 be 2004d2c <== NOT EXECUTED 2004d1c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004d20: 40 00 06 12 call 2006568 <== NOT EXECUTED 2004d24: 01 00 00 00 nop <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 2004d28: 03 00 80 62 sethi %hi(0x2018800), %g1 2004d2c: d0 00 61 94 ld [ %g1 + 0x194 ], %o0 ! 2018994 2004d30: 40 00 03 d7 call 2005c8c 2004d34: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } 2004d38: 81 c7 e0 08 ret 2004d3c: 91 e8 00 13 restore %g0, %l3, %o0 02003634 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 2003634: 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) { 2003638: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1 200363c: 80 a0 60 00 cmp %g1, 0 2003640: 12 80 00 08 bne 2003660 2003644: 92 10 00 18 mov %i0, %o1 (*tty->device.write)(tty->minor, (void *)buf, len); 2003648: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 200364c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1 2003650: 9f c0 40 00 call %g1 2003654: 94 10 00 19 mov %i1, %o2 2003658: 81 c7 e0 08 ret 200365c: 81 e8 00 00 restore return; } newHead = tty->rawOutBuf.Head; 2003660: e2 06 a0 80 ld [ %i2 + 0x80 ], %l1 <== NOT EXECUTED while (len) { 2003664: 10 80 00 3c b 2003754 <== NOT EXECUTED 2003668: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 200366c: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1 <== NOT EXECUTED 2003670: 40 00 47 a5 call 2015504 <.urem> <== NOT EXECUTED 2003674: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED rtems_interrupt_disable (level); 2003678: 7f ff f9 b9 call 2001d5c <== NOT EXECUTED 200367c: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED 2003680: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2003684: 30 80 00 10 b,a 20036c4 <== NOT EXECUTED while (newHead == tty->rawOutBuf.Tail) { tty->rawOutBufState = rob_wait; 2003688: c2 26 a0 94 st %g1, [ %i2 + 0x94 ] <== NOT EXECUTED rtems_interrupt_enable (level); 200368c: 7f ff f9 b8 call 2001d6c <== NOT EXECUTED 2003690: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 2003694: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0 <== NOT EXECUTED 2003698: 92 10 20 00 clr %o1 <== NOT EXECUTED 200369c: 40 00 08 b5 call 2005970 <== NOT EXECUTED 20036a0: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 20036a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20036a8: 02 80 00 04 be 20036b8 <== NOT EXECUTED 20036ac: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20036b0: 40 00 0b ae call 2006568 <== NOT EXECUTED 20036b4: 01 00 00 00 nop <== NOT EXECUTED rtems_interrupt_disable (level); 20036b8: 7f ff f9 a9 call 2001d5c <== NOT EXECUTED 20036bc: 01 00 00 00 nop <== NOT EXECUTED 20036c0: a0 10 00 08 mov %o0, %l0 <== 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) { 20036c4: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1 <== NOT EXECUTED 20036c8: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 20036cc: 02 bf ff ef be 2003688 <== NOT EXECUTED 20036d0: 82 10 20 02 mov 2, %g1 <== 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++; 20036d4: c6 06 a0 80 ld [ %i2 + 0x80 ], %g3 <== NOT EXECUTED 20036d8: c4 0e 00 00 ldub [ %i0 ], %g2 <== NOT EXECUTED 20036dc: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED 20036e0: c4 28 40 03 stb %g2, [ %g1 + %g3 ] <== NOT EXECUTED tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { 20036e4: c2 06 a0 94 ld [ %i2 + 0x94 ], %g1 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; 20036e8: e2 26 a0 80 st %l1, [ %i2 + 0x80 ] <== NOT EXECUTED if (tty->rawOutBufState == rob_idle) { 20036ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20036f0: 32 80 00 15 bne,a 2003744 <== NOT EXECUTED 20036f4: b0 06 20 01 inc %i0 <== NOT EXECUTED /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 20036f8: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED 20036fc: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 2003700: 12 80 00 0b bne 200372c <== NOT EXECUTED 2003704: 01 00 00 00 nop <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003708: d2 06 a0 84 ld [ %i2 + 0x84 ], %o1 <== NOT EXECUTED 200370c: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED 2003710: c4 06 a0 a4 ld [ %i2 + 0xa4 ], %g2 <== NOT EXECUTED 2003714: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 <== NOT EXECUTED 2003718: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 200371c: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003720: 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; 2003724: 10 80 00 06 b 200373c <== NOT EXECUTED 2003728: 82 10 20 01 mov 1, %g1 <== 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; 200372c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED 2003730: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED 2003734: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 2003738: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200373c: c2 26 a0 94 st %g1, [ %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++; 2003740: b0 06 20 01 inc %i0 <== NOT EXECUTED /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; } tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); 2003744: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2003748: 7f ff f9 89 call 2001d6c <== NOT EXECUTED 200374c: b2 06 7f ff add %i1, -1, %i1 <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 2003750: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2003754: 12 bf ff c6 bne 200366c <== NOT EXECUTED 2003758: 01 00 00 00 nop <== NOT EXECUTED 200375c: 81 c7 e0 08 ret <== NOT EXECUTED 2003760: 81 e8 00 00 restore <== NOT EXECUTED 02003ef4 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 2003ef4: 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; 2003ef8: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED uint32_t count = args->count; 2003efc: 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; 2003f00: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 <== NOT EXECUTED uint32_t count = args->count; char *buffer = args->buffer; 2003f04: 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); 2003f08: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 2003f0c: a8 10 00 18 mov %i0, %l4 <== 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); 2003f10: 92 10 20 00 clr %o1 <== NOT EXECUTED 2003f14: 40 00 06 97 call 2005970 <== NOT EXECUTED 2003f18: 94 10 20 00 clr %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 2003f1c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2003f20: 12 80 00 10 bne 2003f60 <== NOT EXECUTED 2003f24: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 2003f28: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 <== NOT EXECUTED 2003f2c: 82 10 61 dc or %g1, 0x1dc, %g1 <== NOT EXECUTED 2003f30: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED 2003f34: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED 2003f38: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED 2003f3c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003f40: 02 80 00 0a be 2003f68 <== NOT EXECUTED 2003f44: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 2003f48: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003f4c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2003f50: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); 2003f54: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED 2003f58: 40 00 07 4d call 2005c8c <== NOT EXECUTED 2003f5c: c0 24 20 e4 clr [ %l0 + 0xe4 ] <== NOT EXECUTED 2003f60: 81 c7 e0 08 ret <== NOT EXECUTED 2003f64: 81 e8 00 00 restore <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { 2003f68: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED 2003f6c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2003f70: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2003f74: 12 80 00 cc bne 20042a4 <== NOT EXECUTED 2003f78: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED tty->cindex = tty->ccount = 0; tty->read_start_column = tty->column; 2003f7c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED if (tty->device.pollRead != NULL 2003f80: 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; 2003f84: 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; 2003f88: c0 24 20 20 clr [ %l0 + 0x20 ] <== NOT EXECUTED tty->read_start_column = tty->column; if (tty->device.pollRead != NULL 2003f8c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003f90: 02 80 00 5a be 20040f8 <== NOT EXECUTED 2003f94: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED 2003f98: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED 2003f9c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003fa0: 32 80 00 57 bne,a 20040fc <== NOT EXECUTED 2003fa4: e2 04 20 74 ld [ %l0 + 0x74 ], %l1 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 2003fa8: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED 2003fac: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 2003fb0: 22 80 00 13 be,a 2003ffc <== NOT EXECUTED 2003fb4: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 2003fb8: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED 2003fbc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003fc0: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED if (n < 0) { 2003fc4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2003fc8: 16 80 00 06 bge 2003fe0 <== NOT EXECUTED 2003fcc: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED rtems_task_wake_after (1); 2003fd0: 40 00 08 a6 call 2006268 <== NOT EXECUTED 2003fd4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED { int n; if (tty->termios.c_lflag & ICANON) { for (;;) { n = (*tty->device.pollRead)(tty->minor); 2003fd8: 10 bf ff f9 b 2003fbc <== NOT EXECUTED 2003fdc: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED if (n < 0) { rtems_task_wake_after (1); } else { if (siproc (n, tty)) 2003fe0: 7f ff ff 64 call 2003d70 <== NOT EXECUTED 2003fe4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2003fe8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2003fec: 22 bf ff f4 be,a 2003fbc <== NOT EXECUTED 2003ff0: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 2003ff4: 10 80 00 ac b 20042a4 <== NOT EXECUTED 2003ff8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 2003ffc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004000: 12 80 00 0a bne 2004028 <== NOT EXECUTED 2004004: aa 07 bf f4 add %fp, -12, %l5 <== NOT EXECUTED 2004008: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED 200400c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004010: 02 80 00 07 be 200402c <== NOT EXECUTED 2004014: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 2004018: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 200401c: 40 00 03 99 call 2004e80 <== NOT EXECUTED 2004020: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED else { siproc (n, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 2004024: aa 07 bf f4 add %fp, -12, %l5 <== NOT EXECUTED } } else { if (!tty->termios.c_cc[VTIME]) break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 2004028: 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); 200402c: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED 2004030: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004034: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED if (n < 0) { 2004038: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200403c: 36 80 00 1d bge,a 20040b0 <== NOT EXECUTED 2004040: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 2004044: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED 2004048: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200404c: 02 80 00 0a be 2004074 <== NOT EXECUTED 2004050: c4 0c 20 46 ldub [ %l0 + 0x46 ], %g2 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 2004054: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2004058: 02 80 00 12 be 20040a0 <== NOT EXECUTED 200405c: 01 00 00 00 nop <== NOT EXECUTED 2004060: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2004064: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004068: 02 80 00 0e be 20040a0 <== NOT EXECUTED 200406c: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 2004070: 30 80 00 04 b,a 2004080 <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 2004074: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2004078: 02 80 00 8a be 20042a0 <== NOT EXECUTED 200407c: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 2004080: 40 00 03 80 call 2004e80 <== NOT EXECUTED 2004084: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 2004088: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 200408c: c4 1f bf f0 ldd [ %fp + -16 ], %g2 <== NOT EXECUTED 2004090: 84 20 80 03 sub %g2, %g3, %g2 <== NOT EXECUTED 2004094: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004098: 18 80 00 83 bgu 20042a4 <== NOT EXECUTED 200409c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED break; } } rtems_task_wake_after (1); 20040a0: 40 00 08 72 call 2006268 <== NOT EXECUTED 20040a4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); for (;;) { n = (*tty->device.pollRead)(tty->minor); 20040a8: 10 bf ff e2 b 2004030 <== NOT EXECUTED 20040ac: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED } } rtems_task_wake_after (1); } else { siproc (n, tty); 20040b0: 7f ff ff 30 call 2003d70 <== NOT EXECUTED 20040b4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 20040b8: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED 20040bc: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 20040c0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20040c4: 16 80 00 77 bge 20042a0 <== NOT EXECUTED 20040c8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 20040cc: 22 bf ff d9 be,a 2004030 <== NOT EXECUTED 20040d0: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED 20040d4: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED 20040d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20040dc: 22 bf ff d5 be,a 2004030 <== NOT EXECUTED 20040e0: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 20040e4: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 20040e8: 40 00 03 66 call 2004e80 <== NOT EXECUTED 20040ec: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); for (;;) { n = (*tty->device.pollRead)(tty->minor); 20040f0: 10 bf ff d0 b 2004030 <== NOT EXECUTED 20040f4: c2 04 20 a0 ld [ %l0 + 0xa0 ], %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; 20040f8: e2 04 20 74 ld [ %l0 + 0x74 ], %l1 <== NOT EXECUTED 20040fc: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 2004100: 2f 00 80 5f sethi %hi(0x2017c00), %l7 <== 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, 2004104: 10 80 00 4c b 2004234 <== NOT EXECUTED 2004108: aa 04 20 49 add %l0, 0x49, %l5 <== 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; 200410c: d0 04 20 5c ld [ %l0 + 0x5c ], %o0 <== NOT EXECUTED 2004110: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED 2004114: 40 00 44 fc call 2015504 <.urem> <== NOT EXECUTED 2004118: 90 02 20 01 inc %o0 <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 200411c: 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; 2004120: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 2004124: e2 08 40 08 ldub [ %g1 + %o0 ], %l1 <== NOT EXECUTED tty->rawInBuf.Head = newHead; 2004128: d0 24 20 5c st %o0, [ %l0 + 0x5c ] <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 200412c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2004130: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED 2004134: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED 2004138: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 200413c: 40 00 44 f2 call 2015504 <.urem> <== NOT EXECUTED 2004140: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED 2004144: c2 04 20 bc ld [ %l0 + 0xbc ], %g1 <== NOT EXECUTED 2004148: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 200414c: 3a 80 00 27 bcc,a 20041e8 <== NOT EXECUTED 2004150: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 2004154: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 2004158: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200415c: 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)) 2004160: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 2004164: 82 08 62 02 and %g1, 0x202, %g1 <== NOT EXECUTED 2004168: 80 a0 62 02 cmp %g1, 0x202 <== NOT EXECUTED 200416c: 12 80 00 11 bne 20041b0 <== NOT EXECUTED 2004170: 01 00 00 00 nop <== NOT EXECUTED 2004174: c2 04 20 94 ld [ %l0 + 0x94 ], %g1 <== NOT EXECUTED 2004178: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200417c: 22 80 00 07 be,a 2004198 <== NOT EXECUTED 2004180: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED 2004184: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 2004188: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 200418c: 02 80 00 09 be 20041b0 <== NOT EXECUTED 2004190: 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, 2004194: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED 2004198: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED 200419c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 20041a0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20041a4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 20041a8: 10 80 00 10 b 20041e8 <== NOT EXECUTED 20041ac: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 20041b0: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 20041b4: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED 20041b8: 22 80 00 0c be,a 20041e8 <== NOT EXECUTED 20041bc: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 20041c0: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 20041c4: 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; 20041c8: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED 20041cc: c2 24 20 b8 st %g1, [ %l0 + 0xb8 ] <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 20041d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20041d4: 22 80 00 05 be,a 20041e8 <== NOT EXECUTED 20041d8: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 20041dc: 9f c0 80 00 call %g2 <== NOT EXECUTED 20041e0: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 20041e4: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED 20041e8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 20041ec: 02 80 00 09 be 2004210 <== NOT EXECUTED 20041f0: 90 0c 60 ff and %l1, 0xff, %o0 <== NOT EXECUTED if (siproc (c, tty)) 20041f4: 7f ff fe df call 2003d70 <== NOT EXECUTED 20041f8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 20041fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004200: 32 80 00 0c bne,a 2004230 <== NOT EXECUTED 2004204: ac 10 20 00 clr %l6 <== NOT EXECUTED else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 2004208: 10 80 00 0b b 2004234 <== NOT EXECUTED 200420c: e2 04 20 70 ld [ %l0 + 0x70 ], %l1 <== NOT EXECUTED if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 2004210: 7f ff fe d8 call 2003d70 <== NOT EXECUTED 2004214: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 2004218: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED 200421c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2004220: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2004224: 26 80 00 04 bl,a 2004234 <== NOT EXECUTED 2004228: e2 04 20 70 ld [ %l0 + 0x70 ], %l1 <== NOT EXECUTED 200422c: ac 10 20 00 clr %l6 <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 2004230: e2 04 20 70 ld [ %l0 + 0x70 ], %l1 <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 2004234: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED 2004238: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200423c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004240: 02 80 00 07 be 200425c <== NOT EXECUTED 2004244: c2 05 e0 9c ld [ %l7 + 0x9c ], %g1 <== NOT EXECUTED 2004248: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 200424c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2004250: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004254: 06 bf ff ae bl 200410c <== NOT EXECUTED 2004258: 01 00 00 00 nop <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 200425c: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 2004260: 02 80 00 11 be 20042a4 <== NOT EXECUTED 2004264: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 2004268: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED 200426c: d2 04 20 6c ld [ %l0 + 0x6c ], %o1 <== NOT EXECUTED 2004270: 40 00 05 c0 call 2005970 <== NOT EXECUTED 2004274: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 2004278: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200427c: 02 bf ff ee be 2004234 <== NOT EXECUTED 2004280: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 2004284: 30 80 00 08 b,a 20042a4 <== NOT EXECUTED sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 2004288: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED count--; 200428c: a4 04 bf ff add %l2, -1, %l2 <== NOT EXECUTED sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 2004290: c2 08 40 02 ldub [ %g1 + %g2 ], %g1 <== NOT EXECUTED 2004294: c2 2c c0 00 stb %g1, [ %l3 ] <== NOT EXECUTED 2004298: c6 24 20 24 st %g3, [ %l0 + 0x24 ] <== NOT EXECUTED 200429c: a6 04 e0 01 inc %l3 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 20042a0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 20042a4: 22 80 00 08 be,a 20042c4 <== NOT EXECUTED 20042a8: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED 20042ac: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED 20042b0: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 20042b4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20042b8: 06 bf ff f4 bl 2004288 <== NOT EXECUTED 20042bc: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 20042c0: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED tty->tty_rcvwakeup = 0; 20042c4: 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; 20042c8: 82 20 40 12 sub %g1, %l2, %g1 <== NOT EXECUTED 20042cc: c2 25 20 14 st %g1, [ %l4 + 0x14 ] <== NOT EXECUTED tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); 20042d0: 40 00 06 6f call 2005c8c <== NOT EXECUTED 20042d4: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED return sc; } 20042d8: 81 c7 e0 08 ret <== NOT EXECUTED 20042dc: 81 e8 00 00 restore <== NOT EXECUTED 020030ac : * 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) { 20030ac: 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)) 20030b0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20030b4: 82 08 64 03 and %g1, 0x403, %g1 <== NOT EXECUTED 20030b8: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED 20030bc: 12 80 00 0f bne 20030f8 <== NOT EXECUTED 20030c0: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, 20030c4: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED 20030c8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 20030cc: 9f c0 40 00 call %g1 <== NOT EXECUTED 20030d0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 20030d4: 7f ff fb 22 call 2001d5c <== NOT EXECUTED 20030d8: 01 00 00 00 nop <== NOT EXECUTED tty->t_dqlen--; 20030dc: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 20030e0: 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--; 20030e4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 20030e8: 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--; 20030ec: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 20030f0: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED rtems_interrupt_enable(level); 20030f4: 30 80 00 12 b,a 200313c <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 20030f8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20030fc: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED 2003100: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2003104: 12 80 00 12 bne 200314c <== NOT EXECUTED 2003108: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED * FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor, 200310c: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED 2003110: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 2003114: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003118: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 200311c: 7f ff fb 10 call 2001d5c <== NOT EXECUTED 2003120: 01 00 00 00 nop <== NOT EXECUTED tty->t_dqlen--; 2003124: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 2003128: 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--; 200312c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 2003130: 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--; 2003134: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 2003138: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED rtems_interrupt_enable(level); 200313c: 7f ff fb 0c call 2001d6c <== NOT EXECUTED 2003140: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 2003144: 81 c7 e0 08 ret <== NOT EXECUTED 2003148: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 200314c: c4 06 20 80 ld [ %i0 + 0x80 ], %g2 <== NOT EXECUTED 2003150: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 <== NOT EXECUTED 2003154: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2003158: 12 80 00 0a bne 2003180 <== NOT EXECUTED 200315c: 01 00 00 00 nop <== NOT EXECUTED /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 2003160: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED 2003164: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2003168: 12 80 00 49 bne 200328c <== NOT EXECUTED 200316c: a2 10 20 00 clr %l1 <== NOT EXECUTED /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 2003170: 40 00 0a c7 call 2005c8c <== NOT EXECUTED 2003174: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 2003178: 81 c7 e0 08 ret <== NOT EXECUTED 200317c: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 2003180: 7f ff fa f7 call 2001d5c <== NOT EXECUTED 2003184: 01 00 00 00 nop <== NOT EXECUTED len = tty->t_dqlen; 2003188: e0 06 20 90 ld [ %i0 + 0x90 ], %l0 <== NOT EXECUTED tty->t_dqlen = 0; 200318c: c0 26 20 90 clr [ %i0 + 0x90 ] <== NOT EXECUTED rtems_interrupt_enable(level); 2003190: 7f ff fa f7 call 2001d6c <== NOT EXECUTED 2003194: 01 00 00 00 nop <== NOT EXECUTED newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 2003198: d0 06 20 84 ld [ %i0 + 0x84 ], %o0 <== NOT EXECUTED 200319c: d2 06 20 88 ld [ %i0 + 0x88 ], %o1 <== NOT EXECUTED 20031a0: 40 00 48 d9 call 2015504 <.urem> <== NOT EXECUTED 20031a4: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { 20031a8: 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; 20031ac: d0 26 20 84 st %o0, [ %i0 + 0x84 ] <== NOT EXECUTED if (tty->rawOutBufState == rob_wait) { 20031b0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20031b4: 12 80 00 04 bne 20031c4 <== NOT EXECUTED 20031b8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 20031bc: 40 00 0a b4 call 2005c8c <== NOT EXECUTED 20031c0: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { 20031c4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 20031c8: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 20031cc: 12 80 00 0b bne 20031f8 <== NOT EXECUTED 20031d0: 01 00 00 00 nop <== NOT EXECUTED nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 20031d4: c2 06 20 d4 ld [ %i0 + 0xd4 ], %g1 <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 20031d8: 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) { 20031dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20031e0: 02 80 00 2a be 2003288 <== NOT EXECUTED 20031e4: a2 10 20 00 clr %l1 <== NOT EXECUTED (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 20031e8: d2 06 20 d8 ld [ %i0 + 0xd8 ], %o1 <== NOT EXECUTED 20031ec: 9f c0 40 00 call %g1 <== NOT EXECUTED 20031f0: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED 20031f4: 30 80 00 25 b,a 2003288 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 20031f8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20031fc: 82 08 62 10 and %g1, 0x210, %g1 <== NOT EXECUTED 2003200: 80 a0 62 10 cmp %g1, 0x210 <== NOT EXECUTED 2003204: 12 80 00 0c bne 2003234 <== NOT EXECUTED 2003208: 01 00 00 00 nop <== NOT EXECUTED == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 200320c: 7f ff fa d4 call 2001d5c <== NOT EXECUTED 2003210: 01 00 00 00 nop <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 2003214: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 2003218: 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; 200321c: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 2003220: 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; 2003224: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ rtems_interrupt_enable(level); 2003228: 7f ff fa d1 call 2001d6c <== NOT EXECUTED 200322c: a2 10 20 00 clr %l1 <== NOT EXECUTED 2003230: 30 80 00 16 b,a 2003288 <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 2003234: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2003238: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 200323c: 08 80 00 05 bleu 2003250 <== NOT EXECUTED 2003240: 01 00 00 00 nop <== NOT EXECUTED nToSend = tty->rawOutBuf.Size - newTail; 2003244: c2 06 20 88 ld [ %i0 + 0x88 ], %g1 <== NOT EXECUTED else nToSend = tty->rawOutBuf.Head - newTail; 2003248: 10 80 00 04 b 2003258 <== NOT EXECUTED 200324c: a2 20 40 10 sub %g1, %l0, %l1 <== NOT EXECUTED 2003250: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2003254: a2 20 40 10 sub %g1, %l0, %l1 <== NOT EXECUTED /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 2003258: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 200325c: 80 88 66 00 btst 0x600, %g1 <== NOT EXECUTED 2003260: 32 80 00 02 bne,a 2003268 <== NOT EXECUTED 2003264: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)(tty->minor, 2003268: d2 06 20 7c ld [ %i0 + 0x7c ], %o1 <== NOT EXECUTED 200326c: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 2003270: 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*/ 2003274: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003278: 92 04 00 09 add %l0, %o1, %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*/ 200327c: c2 26 20 94 st %g1, [ %i0 + 0x94 ] <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003280: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003284: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 2003288: e0 26 20 84 st %l0, [ %i0 + 0x84 ] <== NOT EXECUTED } return nToSend; } 200328c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED 2003290: 81 c7 e0 08 ret <== NOT EXECUTED 2003294: 81 e8 00 00 restore <== NOT EXECUTED 02004d40 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 2004d40: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 2004d44: a2 07 bf f0 add %fp, -16, %l1 <== NOT EXECUTED if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( 2004d48: a0 07 bf f7 add %fp, -9, %l0 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 2004d4c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED 2004d50: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2004d54: 94 10 20 00 clr %o2 <== NOT EXECUTED 2004d58: 40 00 00 b3 call 2005024 <== NOT EXECUTED 2004d5c: 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) { 2004d60: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2004d64: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 2004d68: 22 80 00 07 be,a 2004d84 <== NOT EXECUTED 2004d6c: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED tty->rxTaskId = 0; 2004d70: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 2004d74: 40 00 04 6e call 2005f2c <== NOT EXECUTED 2004d78: 90 10 20 00 clr %o0 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 2004d7c: 10 bf ff f5 b 2004d50 <== NOT EXECUTED 2004d80: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 2004d84: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004d88: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED if (c != EOF) { 2004d8c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 2004d90: 02 bf ff ef be 2004d4c <== NOT EXECUTED 2004d94: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 2004d98: d0 2f bf f7 stb %o0, [ %fp + -9 ] <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 2004d9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2004da0: 7f ff f9 5e call 2003318 <== NOT EXECUTED 2004da4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 2004da8: 10 bf ff ea b 2004d50 <== NOT EXECUTED 2004dac: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED 02003094 : 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); 2003094: d0 02 20 c4 ld [ %o0 + 0xc4 ], %o0 <== NOT EXECUTED 2003098: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 200309c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20030a0: 40 00 08 65 call 2005234 <== NOT EXECUTED 20030a4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20030a8: 01 00 00 00 nop 02004db0 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 2004db0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 2004db4: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2004db8: a0 07 bf f4 add %fp, -12, %l0 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 2004dbc: a2 10 61 dc or %g1, 0x1dc, %l1 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2004dc0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2004dc4: 94 10 20 00 clr %o2 <== NOT EXECUTED 2004dc8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 2004dcc: 40 00 00 96 call 2005024 <== NOT EXECUTED 2004dd0: 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) { 2004dd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2004dd8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 2004ddc: 02 80 00 07 be 2004df8 <== NOT EXECUTED 2004de0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED tty->txTaskId = 0; 2004de4: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 2004de8: 40 00 04 51 call 2005f2c <== NOT EXECUTED 2004dec: 90 10 20 00 clr %o0 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2004df0: 10 bf ff f5 b 2004dc4 <== NOT EXECUTED 2004df4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 2004df8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 2004dfc: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 2004e00: 82 00 40 11 add %g1, %l1, %g1 <== NOT EXECUTED 2004e04: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED 2004e08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004e0c: 02 80 00 04 be 2004e1c <== NOT EXECUTED 2004e10: 01 00 00 00 nop <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 2004e14: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004e18: 01 00 00 00 nop <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 2004e1c: 7f ff f8 a4 call 20030ac <== NOT EXECUTED 2004e20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2004e24: 10 bf ff e8 b 2004dc4 <== NOT EXECUTED 2004e28: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 02003dbc : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 2003dbc: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 2003dc0: c2 06 00 00 ld [ %i0 ], %g1 rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2003dc4: 92 10 20 00 clr %o1 rtems_status_code rtems_termios_write (void *arg) { rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 2003dc8: e4 00 60 28 ld [ %g1 + 0x28 ], %l2 rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2003dcc: 94 10 20 00 clr %o2 2003dd0: 40 00 06 e8 call 2005970 2003dd4: d0 04 a0 18 ld [ %l2 + 0x18 ], %o0 if (sc != RTEMS_SUCCESSFUL) 2003dd8: a6 92 20 00 orcc %o0, 0, %l3 2003ddc: 12 80 00 25 bne 2003e70 2003de0: 03 00 80 61 sethi %hi(0x2018400), %g1 return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 2003de4: c4 04 a0 cc ld [ %l2 + 0xcc ], %g2 2003de8: 82 10 61 dc or %g1, 0x1dc, %g1 2003dec: 85 28 a0 05 sll %g2, 5, %g2 2003df0: 84 00 80 01 add %g2, %g1, %g2 2003df4: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 2003df8: 80 a0 60 00 cmp %g1, 0 2003dfc: 02 80 00 06 be 2003e14 2003e00: 92 10 00 18 mov %i0, %o1 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 2003e04: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003e08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2003e0c: 10 80 00 17 b 2003e68 <== NOT EXECUTED 2003e10: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED rtems_semaphore_release (tty->osem); return sc; } if (tty->termios.c_oflag & OPOST) { 2003e14: c2 04 a0 34 ld [ %l2 + 0x34 ], %g1 2003e18: d2 06 20 0c ld [ %i0 + 0xc ], %o1 2003e1c: 80 88 60 01 btst 1, %g1 2003e20: 02 80 00 0e be 2003e58 2003e24: d0 06 20 08 ld [ %i0 + 8 ], %o0 uint32_t count = args->count; 2003e28: a2 10 00 09 mov %o1, %l1 char *buffer = args->buffer; 2003e2c: 10 80 00 05 b 2003e40 2003e30: a0 10 00 08 mov %o0, %l0 while (count--) oproc (*buffer++, tty); 2003e34: 92 10 00 12 mov %l2, %o1 2003e38: 7f ff fe 4b call 2003764 2003e3c: 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--) 2003e40: a2 04 7f ff add %l1, -1, %l1 2003e44: 80 a4 7f ff cmp %l1, -1 2003e48: 32 bf ff fb bne,a 2003e34 2003e4c: d0 0c 00 00 ldub [ %l0 ], %o0 oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; 2003e50: 10 80 00 05 b 2003e64 2003e54: c2 06 20 0c ld [ %i0 + 0xc ], %g1 while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 2003e58: 7f ff fd f7 call 2003634 <== NOT EXECUTED 2003e5c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED args->bytes_moved = args->count; 2003e60: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 2003e64: c2 26 20 14 st %g1, [ %i0 + 0x14 ] } rtems_semaphore_release (tty->osem); 2003e68: 40 00 07 89 call 2005c8c 2003e6c: d0 04 a0 18 ld [ %l2 + 0x18 ], %o0 return sc; } 2003e70: 81 c7 e0 08 ret 2003e74: 91 e8 00 13 restore %g0, %l3, %o0 02012254 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 2012254: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012258: 21 00 80 cc sethi %hi(0x2033000), %l0 201225c: 92 10 00 18 mov %i0, %o1 2012260: 94 07 bf f4 add %fp, -12, %o2 2012264: 40 00 0a 13 call 2014ab0 <_Objects_Get> 2012268: 90 14 20 2c or %l0, 0x2c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 201226c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012270: 80 a0 60 00 cmp %g1, 0 2012274: 02 80 00 08 be 2012294 2012278: b0 10 00 08 mov %o0, %i0 201227c: 82 18 60 02 xor %g1, 2, %g1 2012280: 80 a0 00 01 cmp %g0, %g1 2012284: 82 60 20 00 subx %g0, 0, %g1 2012288: b0 08 60 15 and %g1, 0x15, %i0 201228c: 81 c7 e0 08 ret 2012290: 91 ee 20 04 restore %i0, 4, %o0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012294: a0 14 20 2c or %l0, 0x2c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012298: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 201229c: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 20122a0: 05 00 00 3f sethi %hi(0xfc00), %g2 20122a4: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 20122a8: 82 08 40 02 and %g1, %g2, %g1 20122ac: 80 a0 40 03 cmp %g1, %g3 20122b0: 38 80 00 06 bgu,a 20122c8 20122b4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 20122b8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 20122bc: 83 28 60 02 sll %g1, 2, %g1 20122c0: c0 20 80 01 clr [ %g2 + %g1 ] uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 20122c4: c0 26 20 0c clr [ %i0 + 0xc ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); (void) _Watchdog_Remove( &the_timer->Ticker ); 20122c8: 40 00 15 8d call 20178fc <_Watchdog_Remove> 20122cc: 90 06 20 10 add %i0, 0x10, %o0 RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 20122d0: 90 10 00 10 mov %l0, %o0 20122d4: 40 00 09 a1 call 2014958 <_Objects_Free> 20122d8: 92 10 00 18 mov %i0, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20122dc: 03 00 80 c9 sethi %hi(0x2032400), %g1 20122e0: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20325f0 <_Thread_Dispatch_disable_level> 20122e4: b0 10 20 00 clr %i0 20122e8: 84 00 bf ff add %g2, -1, %g2 20122ec: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 20122f0: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1 20122f4: 80 a0 60 00 cmp %g1, 0 20122f8: 12 80 00 04 bne 2012308 20122fc: 01 00 00 00 nop _Thread_Dispatch(); 2012300: 40 00 0e f1 call 2015ec4 <_Thread_Dispatch> 2012304: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012308: 81 c7 e0 08 ret 201230c: 81 e8 00 00 restore 02012344 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2012344: 9d e3 bf 90 save %sp, -112, %sp 2012348: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 201234c: 80 a6 60 00 cmp %i1, 0 2012350: 02 80 00 21 be 20123d4 2012354: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 2012358: 80 a6 a0 00 cmp %i2, 0 201235c: 02 80 00 1e be 20123d4 2012360: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012364: 11 00 80 cc sethi %hi(0x2033000), %o0 2012368: 92 10 00 12 mov %l2, %o1 201236c: 90 12 20 2c or %o0, 0x2c, %o0 2012370: 40 00 09 d0 call 2014ab0 <_Objects_Get> 2012374: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012378: c2 07 bf f4 ld [ %fp + -12 ], %g1 201237c: 80 a0 60 00 cmp %g1, 0 2012380: 02 80 00 08 be 20123a0 2012384: a0 10 00 08 mov %o0, %l0 2012388: 82 18 60 02 xor %g1, 2, %g1 201238c: 80 a0 00 01 cmp %g0, %g1 2012390: 82 60 20 00 subx %g0, 0, %g1 2012394: b0 08 60 15 and %g1, 0x15, %i0 2012398: 81 c7 e0 08 ret 201239c: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 20123a0: a2 02 20 10 add %o0, 0x10, %l1 20123a4: 40 00 15 56 call 20178fc <_Watchdog_Remove> 20123a8: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 20123ac: 7f ff e0 e5 call 200a740 20123b0: 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 ) { 20123b4: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 20123b8: 80 a0 60 00 cmp %g1, 0 20123bc: 22 80 00 08 be,a 20123dc 20123c0: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 20123c4: 7f ff e0 e3 call 200a750 <== NOT EXECUTED 20123c8: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 20123cc: 7f ff ff d1 call 2012310 <_Thread_Enable_dispatch> <== NOT EXECUTED 20123d0: 01 00 00 00 nop <== NOT EXECUTED 20123d4: 81 c7 e0 08 ret 20123d8: 81 e8 00 00 restore 20123dc: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 20123e0: 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; 20123e4: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20123e8: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 20123ec: 7f ff e0 d9 call 200a750 20123f0: b0 10 20 00 clr %i0 ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20123f4: 92 10 00 11 mov %l1, %o1 20123f8: 11 00 80 c9 sethi %hi(0x2032400), %o0 20123fc: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 20326f0 <_Watchdog_Ticks_chain> 2012400: 40 00 14 e7 call 201779c <_Watchdog_Insert> 2012404: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 2012408: 7f ff ff c2 call 2012310 <_Thread_Enable_dispatch> 201240c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012410: 81 c7 e0 08 ret 2012414: 81 e8 00 00 restore 020080ac : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 20080ac: 9d e3 bf 90 save %sp, -112, %sp 20080b0: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 20080b4: 80 a6 60 00 cmp %i1, 0 20080b8: 02 80 00 22 be 2008140 20080bc: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 20080c0: 11 00 80 7a sethi %hi(0x201e800), %o0 20080c4: 94 07 bf f4 add %fp, -12, %o2 20080c8: 40 00 07 66 call 2009e60 <_Objects_Get> 20080cc: 90 12 21 10 or %o0, 0x110, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20080d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20080d4: 80 a0 60 00 cmp %g1, 0 20080d8: 22 80 00 08 be,a 20080f8 20080dc: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 20080e0: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 20080e4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20080e8: 82 60 20 00 subx %g0, 0, %g1 <== NOT EXECUTED 20080ec: b0 08 60 15 and %g1, 0x15, %i0 <== NOT EXECUTED 20080f0: 81 c7 e0 08 ret <== NOT EXECUTED 20080f4: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 20080f8: c4 02 20 38 ld [ %o0 + 0x38 ], %g2 the_info->initial = the_timer->Ticker.initial; 20080fc: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 2008100: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 2008104: c4 26 40 00 st %g2, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 2008108: c2 26 60 08 st %g1, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 200810c: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 2008110: c2 26 60 0c st %g1, [ %i1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008114: 05 00 80 7a sethi %hi(0x201e800), %g2 2008118: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 ! 201eaf0 <_Thread_Dispatch_disable_level> 200811c: b0 10 20 00 clr %i0 2008120: 82 00 7f ff add %g1, -1, %g1 2008124: c2 20 a2 f0 st %g1, [ %g2 + 0x2f0 ] 2008128: c2 00 a2 f0 ld [ %g2 + 0x2f0 ], %g1 200812c: 80 a0 60 00 cmp %g1, 0 2008130: 12 80 00 04 bne 2008140 2008134: 01 00 00 00 nop _Thread_Dispatch(); 2008138: 40 00 0c 4f call 200b274 <_Thread_Dispatch> 200813c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008140: 81 c7 e0 08 ret 2008144: 81 e8 00 00 restore 02012b34 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 2012b34: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 2012b38: 92 10 20 00 clr %o1 2012b3c: 80 a6 3f ff cmp %i0, -1 2012b40: 02 80 00 07 be 2012b5c 2012b44: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 2012b48: 82 06 3f ff add %i0, -1, %g1 2012b4c: 80 a0 60 fe cmp %g1, 0xfe 2012b50: 18 80 00 48 bgu 2012c70 2012b54: a0 10 20 13 mov 0x13, %l0 2012b58: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2012b5c: 05 00 80 c9 sethi %hi(0x2032400), %g2 2012b60: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 20325f0 <_Thread_Dispatch_disable_level> 2012b64: 82 00 60 01 inc %g1 2012b68: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 2012b6c: 03 00 80 cc sethi %hi(0x2033000), %g1 2012b70: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 2033078 <_Timer_Server> 2012b74: 80 a0 60 00 cmp %g1, 0 2012b78: 02 80 00 06 be 2012b90 2012b7c: 19 00 00 20 sethi %hi(0x8000), %o4 _Thread_Enable_dispatch(); 2012b80: 7f ff ff a0 call 2012a00 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012b84: a0 10 20 0e mov 0xe, %l0 <== NOT EXECUTED _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2012b88: 81 c7 e0 08 ret <== NOT EXECUTED 2012b8c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * 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( 2012b90: 11 15 12 53 sethi %hi(0x54494c00), %o0 2012b94: 98 16 80 0c or %i2, %o4, %o4 2012b98: 90 12 21 45 or %o0, 0x145, %o0 2012b9c: 96 10 21 00 mov 0x100, %o3 2012ba0: 7f ff fa 0f call 20113dc 2012ba4: 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) { 2012ba8: a0 92 20 00 orcc %o0, 0, %l0 2012bac: 12 80 00 2f bne 2012c68 2012bb0: d0 07 bf f4 ld [ %fp + -12 ], %o0 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 2012bb4: 13 00 80 4a sethi %hi(0x2012800), %o1 2012bb8: 94 10 20 00 clr %o2 2012bbc: 7f ff fc 62 call 2011d44 2012bc0: 92 12 62 34 or %o1, 0x234, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2012bc4: a0 92 20 00 orcc %o0, 0, %l0 2012bc8: 12 80 00 28 bne 2012c68 2012bcc: 03 00 80 c9 sethi %hi(0x2032400), %g1 * * 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( 2012bd0: c8 07 bf f4 ld [ %fp + -12 ], %g4 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 2012bd4: 9a 10 60 a4 or %g1, 0xa4, %o5 2012bd8: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 2012bdc: 03 00 00 3f sethi %hi(0xfc00), %g1 2012be0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2012be4: 82 09 00 01 and %g4, %g1, %g1 2012be8: 80 a0 40 02 cmp %g1, %g2 2012bec: 18 80 00 05 bgu 2012c00 2012bf0: 86 10 20 00 clr %g3 return NULL; return information->local_table[ index ]; 2012bf4: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 2012bf8: 83 28 60 02 sll %g1, 2, %g1 2012bfc: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2012c00: 03 00 80 cc sethi %hi(0x2033000), %g1 2012c04: c6 20 60 78 st %g3, [ %g1 + 0x78 ] ! 2033078 <_Timer_Server> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012c08: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c0c: 82 10 60 f4 or %g1, 0xf4, %g1 ! 20324f4 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012c10: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012c14: 82 00 7f fc add %g1, -4, %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2012c18: c0 20 e0 6c clr [ %g3 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c1c: c0 20 e0 50 clr [ %g3 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 2012c20: c8 20 e0 68 st %g4, [ %g3 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012c24: 05 00 80 57 sethi %hi(0x2015c00), %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c28: c2 20 60 08 st %g1, [ %g1 + 8 ] 2012c2c: 84 10 a2 08 or %g2, 0x208, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2012c30: c0 20 60 04 clr [ %g1 + 4 ] 2012c34: c4 20 e0 64 st %g2, [ %g3 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2012c38: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c3c: 82 10 61 08 or %g1, 0x108, %g1 ! 2032508 <_Timer_Seconds_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2012c40: c2 20 7f fc st %g1, [ %g1 + -4 ] 2012c44: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2012c48: 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; 2012c4c: c0 20 60 04 clr [ %g1 + 4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c50: 03 00 80 c9 sethi %hi(0x2032400), %g1 2012c54: 82 10 61 10 or %g1, 0x110, %g1 ! 2032510 <_Timer_Seconds_timer> the_watchdog->routine = routine; 2012c58: c4 20 60 1c st %g2, [ %g1 + 0x1c ] the_watchdog->id = id; 2012c5c: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 2012c60: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012c64: c0 20 60 08 clr [ %g1 + 8 ] */ _Watchdog_Initialize( &_Timer_Server->Timer, _Thread_Delay_ended, id, NULL ); _Watchdog_Initialize( &_Timer_Seconds_timer, _Thread_Delay_ended, id, NULL ); _Thread_Enable_dispatch(); 2012c68: 7f ff ff 66 call 2012a00 <_Thread_Enable_dispatch> 2012c6c: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } 2012c70: b0 10 00 10 mov %l0, %i0 2012c74: 81 c7 e0 08 ret 2012c78: 81 e8 00 00 restore 020126c4 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126c4: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126c8: 25 00 80 cc sethi %hi(0x2033000), %l2 20126cc: c2 04 a0 78 ld [ %l2 + 0x78 ], %g1 ! 2033078 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20126d0: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20126d4: 80 a0 60 00 cmp %g1, 0 20126d8: 02 80 00 24 be 2012768 20126dc: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 20126e0: 80 a6 a0 00 cmp %i2, 0 20126e4: 02 80 00 21 be 2012768 20126e8: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 20126ec: 80 a6 60 00 cmp %i1, 0 20126f0: 02 80 00 1e be 2012768 20126f4: b0 10 20 0a mov 0xa, %i0 20126f8: 11 00 80 cc sethi %hi(0x2033000), %o0 20126fc: 92 10 00 13 mov %l3, %o1 2012700: 90 12 20 2c or %o0, 0x2c, %o0 2012704: 40 00 08 eb call 2014ab0 <_Objects_Get> 2012708: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 201270c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012710: 80 a0 60 00 cmp %g1, 0 2012714: 02 80 00 08 be 2012734 2012718: a0 10 00 08 mov %o0, %l0 201271c: 82 18 60 02 xor %g1, 2, %g1 2012720: 80 a0 00 01 cmp %g0, %g1 2012724: 82 60 20 00 subx %g0, 0, %g1 2012728: b0 08 60 15 and %g1, 0x15, %i0 201272c: 81 c7 e0 08 ret 2012730: 91 ee 20 04 restore %i0, 4, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012734: a2 02 20 10 add %o0, 0x10, %l1 2012738: 40 00 14 71 call 20178fc <_Watchdog_Remove> 201273c: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012740: 7f ff e0 00 call 200a740 2012744: 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 ) { 2012748: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 201274c: 80 a0 60 00 cmp %g1, 0 2012750: 02 80 00 08 be 2012770 2012754: 82 10 20 01 mov 1, %g1 _ISR_Enable( level ); 2012758: 7f ff df fe call 200a750 <== NOT EXECUTED 201275c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); 2012760: 7f ff ff cc call 2012690 <_Thread_Enable_dispatch> <== NOT EXECUTED 2012764: 01 00 00 00 nop <== NOT EXECUTED 2012768: 81 c7 e0 08 ret 201276c: 81 e8 00 00 restore * 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; 2012770: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2012774: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 2012778: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 201277c: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012780: 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; 2012784: 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 ); 2012788: 7f ff df f2 call 200a750 201278c: 21 00 80 c9 sethi %hi(0x2032400), %l0 _Timer_Server_stop_ticks_timer(); 2012790: d0 04 a0 78 ld [ %l2 + 0x78 ], %o0 2012794: 40 00 14 5a call 20178fc <_Watchdog_Remove> 2012798: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 201279c: 40 00 00 87 call 20129b8 <_Timer_Server_process_ticks_chain> 20127a0: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 20127a4: 90 14 20 f0 or %l0, 0xf0, %o0 20127a8: 40 00 13 fd call 201779c <_Watchdog_Insert> 20127ac: 92 10 00 11 mov %l1, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 20127b0: c4 04 20 f0 ld [ %l0 + 0xf0 ], %g2 20127b4: a0 14 20 f0 or %l0, 0xf0, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20127b8: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 20127bc: 80 a0 80 10 cmp %g2, %l0 20127c0: 02 80 00 08 be 20127e0 20127c4: c2 04 a0 78 ld [ %l2 + 0x78 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127c8: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127cc: 11 00 80 c9 sethi %hi(0x2032400), %o0 20127d0: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20127d4: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20127d8: 40 00 13 f1 call 201779c <_Watchdog_Insert> 20127dc: 90 12 22 f0 or %o0, 0x2f0, %o0 _Thread_Enable_dispatch(); 20127e0: 7f ff ff ac call 2012690 <_Thread_Enable_dispatch> 20127e4: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20127e8: 81 c7 e0 08 ret 20127ec: 81 e8 00 00 restore 02005ffc : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 2005ffc: 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) 2006000: 03 08 00 00 sethi %hi(0x20000000), %g1 <== NOT EXECUTED 2006004: a8 8e 00 01 andcc %i0, %g1, %l4 <== NOT EXECUTED 2006008: 02 80 00 10 be 2006048 <== NOT EXECUTED 200600c: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED { if (rtems_panic_in_progress++) 2006010: 07 00 80 9e sethi %hi(0x2027800), %g3 <== NOT EXECUTED 2006014: c2 00 e0 80 ld [ %g3 + 0x80 ], %g1 ! 2027880 <== NOT EXECUTED 2006018: 82 00 60 01 inc %g1 <== NOT EXECUTED 200601c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2006020: 02 80 00 06 be 2006038 <== NOT EXECUTED 2006024: c2 20 e0 80 st %g1, [ %g3 + 0x80 ] <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006028: 05 00 80 9e sethi %hi(0x2027800), %g2 <== NOT EXECUTED 200602c: c2 00 a2 50 ld [ %g2 + 0x250 ], %g1 ! 2027a50 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2006030: 82 00 60 01 inc %g1 <== NOT EXECUTED 2006034: c2 20 a2 50 st %g1, [ %g2 + 0x250 ] <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 2006038: c2 00 e0 80 ld [ %g3 + 0x80 ], %g1 <== NOT EXECUTED 200603c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006040: 34 80 00 59 bg,a 20061a4 <== NOT EXECUTED 2006044: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 2006048: 03 00 80 9a sethi %hi(0x2026800), %g1 <== NOT EXECUTED 200604c: c2 00 61 40 ld [ %g1 + 0x140 ], %g1 ! 2026940 <_impure_ptr> <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 2006050: a4 10 20 00 clr %l2 <== NOT EXECUTED /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 2006054: 40 00 43 0b call 2016c80 <== NOT EXECUTED 2006058: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 200605c: 03 1c 00 00 sethi %hi(0x70000000), %g1 <== NOT EXECUTED 2006060: a0 2c c0 01 andn %l3, %g1, %l0 <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 2006064: 03 10 00 00 sethi %hi(0x40000000), %g1 <== NOT EXECUTED 2006068: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED 200606c: 02 80 00 05 be 2006080 <== NOT EXECUTED 2006070: 23 00 80 9a sethi %hi(0x2026800), %l1 <== NOT EXECUTED local_errno = errno; 2006074: 40 00 42 a6 call 2016b0c <__errno> <== NOT EXECUTED 2006078: 01 00 00 00 nop <== NOT EXECUTED 200607c: e4 02 00 00 ld [ %o0 ], %l2 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 2006080: c2 04 61 40 ld [ %l1 + 0x140 ], %g1 <== NOT EXECUTED 2006084: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2006088: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 200608c: 40 00 5b 85 call 201cea0 <== NOT EXECUTED 2006090: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED if (status) 2006094: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2006098: 02 80 00 0c be 20060c8 <== NOT EXECUTED 200609c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 20060a0: c2 04 61 40 ld [ %l1 + 0x140 ], %g1 <== NOT EXECUTED 20060a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20060a8: 7f ff ff ce call 2005fe0 <== NOT EXECUTED 20060ac: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED 20060b0: 13 00 80 8a sethi %hi(0x2022800), %o1 <== NOT EXECUTED 20060b4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20060b8: 92 12 62 28 or %o1, 0x228, %o1 <== NOT EXECUTED 20060bc: 40 00 44 b2 call 2017384 <== NOT EXECUTED 20060c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20060c4: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED if (local_errno) 20060c8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 20060cc: 22 80 00 1c be,a 200613c <== NOT EXECUTED 20060d0: 23 00 80 9a sethi %hi(0x2026800), %l1 <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 20060d4: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 20060d8: 04 80 00 11 ble 200611c <== NOT EXECUTED 20060dc: 03 00 80 9a sethi %hi(0x2026800), %g1 <== NOT EXECUTED 20060e0: 40 00 50 8d call 201a314 <== NOT EXECUTED 20060e4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20060e8: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED 20060ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20060f0: 02 80 00 0b be 200611c <== NOT EXECUTED 20060f4: 03 00 80 9a sethi %hi(0x2026800), %g1 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 20060f8: c2 04 61 40 ld [ %l1 + 0x140 ], %g1 <== NOT EXECUTED 20060fc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2006100: 40 00 50 85 call 201a314 <== NOT EXECUTED 2006104: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED 2006108: 13 00 80 8a sethi %hi(0x2022800), %o1 <== NOT EXECUTED 200610c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2006110: 92 12 62 38 or %o1, 0x238, %o1 <== NOT EXECUTED 2006114: 10 80 00 07 b 2006130 <== NOT EXECUTED 2006118: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 200611c: c2 00 61 40 ld [ %g1 + 0x140 ], %g1 <== NOT EXECUTED 2006120: 13 00 80 8a sethi %hi(0x2022800), %o1 <== NOT EXECUTED 2006124: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2006128: 92 12 62 48 or %o1, 0x248, %o1 <== NOT EXECUTED 200612c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 2006130: 40 00 44 95 call 2017384 <== NOT EXECUTED 2006134: 23 00 80 9a sethi %hi(0x2026800), %l1 <== NOT EXECUTED 2006138: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 200613c: c2 04 61 40 ld [ %l1 + 0x140 ], %g1 <== NOT EXECUTED 2006140: 13 00 80 8c sethi %hi(0x2023000), %o1 <== NOT EXECUTED 2006144: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2006148: 40 00 44 8f call 2017384 <== NOT EXECUTED 200614c: 92 12 60 d0 or %o1, 0xd0, %o1 <== NOT EXECUTED (void) fflush(stderr); 2006150: c2 04 61 40 ld [ %l1 + 0x140 ], %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"); 2006154: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED (void) fflush(stderr); 2006158: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 200615c: 40 00 42 c9 call 2016c80 <== NOT EXECUTED 2006160: b0 04 00 18 add %l0, %i0, %i0 <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 2006164: 03 0c 00 00 sethi %hi(0x30000000), %g1 <== NOT EXECUTED 2006168: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED 200616c: 02 80 00 0e be 20061a4 <== NOT EXECUTED 2006170: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 2006174: 02 80 00 07 be 2006190 <== NOT EXECUTED 2006178: 90 10 20 00 clr %o0 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 200617c: 13 00 80 8a sethi %hi(0x2022800), %o1 <== NOT EXECUTED 2006180: 40 00 00 18 call 20061e0 <== NOT EXECUTED 2006184: 92 12 62 60 or %o1, 0x260, %o1 ! 2022a60 <== NOT EXECUTED _exit(local_errno); 2006188: 40 00 02 43 call 2006a94 <_exit> <== NOT EXECUTED 200618c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); 2006190: 13 00 80 8a sethi %hi(0x2022800), %o1 <== NOT EXECUTED 2006194: 40 00 00 13 call 20061e0 <== NOT EXECUTED 2006198: 92 12 62 78 or %o1, 0x278, %o1 ! 2022a78 <== NOT EXECUTED abort(); 200619c: 40 00 42 4e call 2016ad4 <== NOT EXECUTED 20061a0: 01 00 00 00 nop <== NOT EXECUTED } } return chars_written; } 20061a4: 81 c7 e0 08 ret <== NOT EXECUTED 20061a8: 81 e8 00 00 restore <== NOT EXECUTED 02015b64 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 2015b64: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 2015b68: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 <== NOT EXECUTED 2015b6c: a2 10 20 00 clr %l1 <== NOT EXECUTED 2015b70: a6 10 63 ff or %g1, 0x3ff, %l3 <== NOT EXECUTED 2015b74: a4 10 20 00 clr %l2 <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 2015b78: 2b 00 80 e1 sethi %hi(0x2038400), %l5 <== NOT EXECUTED limit++; continue; } sign = 1; } if (!isdigit(c)) 2015b7c: 29 00 80 e1 sethi %hi(0x2038400), %l4 <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 2015b80: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2015b84: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2015b88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015b8c: 16 80 00 07 bge 2015ba8 <== NOT EXECUTED 2015b90: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED 2015b94: d0 05 63 c0 ld [ %l5 + 0x3c0 ], %o0 <== NOT EXECUTED 2015b98: 40 00 3d c5 call 20252ac <__srget_r> <== NOT EXECUTED 2015b9c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2015ba0: 10 80 00 06 b 2015bb8 <== NOT EXECUTED 2015ba4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2015ba8: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 2015bac: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED 2015bb0: e0 08 40 00 ldub [ %g1 ], %l0 <== NOT EXECUTED 2015bb4: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED if (c == ':') 2015bb8: 80 a4 20 3a cmp %l0, 0x3a <== NOT EXECUTED 2015bbc: 02 80 00 20 be 2015c3c <== NOT EXECUTED 2015bc0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED break; if (sign == 0) { 2015bc4: 12 80 00 08 bne 2015be4 <== NOT EXECUTED 2015bc8: c2 05 23 b8 ld [ %l4 + 0x3b8 ], %g1 <== NOT EXECUTED if (c == '-') { 2015bcc: 80 a4 20 2d cmp %l0, 0x2d <== NOT EXECUTED 2015bd0: 12 80 00 05 bne 2015be4 <== NOT EXECUTED 2015bd4: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED sign = -1; limit++; 2015bd8: a6 04 e0 01 inc %l3 <== NOT EXECUTED 2015bdc: 10 bf ff e9 b 2015b80 <== NOT EXECUTED 2015be0: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED continue; } sign = 1; } if (!isdigit(c)) 2015be4: c2 08 40 10 ldub [ %g1 + %l0 ], %g1 <== NOT EXECUTED 2015be8: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED 2015bec: 02 80 00 1c be 2015c5c <== NOT EXECUTED 2015bf0: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 2015bf4: 40 00 6c de call 2030f6c <.udiv> <== NOT EXECUTED 2015bf8: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 2015bfc: 80 a4 40 08 cmp %l1, %o0 <== NOT EXECUTED 2015c00: 18 80 00 17 bgu 2015c5c <== NOT EXECUTED 2015c04: 01 00 00 00 nop <== NOT EXECUTED 2015c08: 12 80 00 08 bne 2015c28 <== NOT EXECUTED 2015c0c: a0 04 3f d0 add %l0, -48, %l0 <== NOT EXECUTED 2015c10: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 2015c14: 40 00 6d 82 call 203121c <.urem> <== NOT EXECUTED 2015c18: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 2015c1c: 80 a4 00 08 cmp %l0, %o0 <== NOT EXECUTED 2015c20: 18 80 00 0f bgu 2015c5c <== NOT EXECUTED 2015c24: 01 00 00 00 nop <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 2015c28: 85 2c 60 03 sll %l1, 3, %g2 <== NOT EXECUTED 2015c2c: 83 2c 60 01 sll %l1, 1, %g1 <== NOT EXECUTED 2015c30: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 2015c34: 10 bf ff d3 b 2015b80 <== NOT EXECUTED 2015c38: a2 04 00 01 add %l0, %g1, %l1 <== NOT EXECUTED } if (sign == 0) 2015c3c: 02 80 00 08 be 2015c5c <== NOT EXECUTED 2015c40: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED return 0; *val = i * sign; 2015c44: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2015c48: 40 00 6c 8f call 2030e84 <.umul> <== NOT EXECUTED 2015c4c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED 2015c50: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED 2015c54: 81 c7 e0 08 ret <== NOT EXECUTED 2015c58: 81 e8 00 00 restore <== NOT EXECUTED return 1; } 2015c5c: 81 c7 e0 08 ret <== NOT EXECUTED 2015c60: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02015c64 : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 2015c64: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED int c; *name = *bufp; 2015c68: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2015c6c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED for (;;) { c = getc(fp); 2015c70: 33 00 80 e1 sethi %hi(0x2038400), %i1 <== NOT EXECUTED 2015c74: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2015c78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2015c7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015c80: 16 80 00 07 bge 2015c9c <== NOT EXECUTED 2015c84: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED 2015c88: d0 06 63 c0 ld [ %i1 + 0x3c0 ], %o0 <== NOT EXECUTED 2015c8c: 40 00 3d 88 call 20252ac <__srget_r> <== NOT EXECUTED 2015c90: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED if (c == ':') { 2015c94: 10 80 00 07 b 2015cb0 <== NOT EXECUTED 2015c98: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED { int c; *name = *bufp; for (;;) { c = getc(fp); 2015c9c: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 2015ca0: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED 2015ca4: d0 08 40 00 ldub [ %g1 ], %o0 <== NOT EXECUTED 2015ca8: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED if (c == ':') { 2015cac: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED 2015cb0: 12 80 00 07 bne 2015ccc <== NOT EXECUTED 2015cb4: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED if (nlFlag) 2015cb8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2015cbc: 22 80 00 1a be,a 2015d24 <== NOT EXECUTED 2015cc0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED --(*nleft); } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; 2015cc4: 81 c7 e0 08 ret <== NOT EXECUTED 2015cc8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if (c == ':') { if (nlFlag) return 0; break; } if (c == '\n') { 2015ccc: 12 80 00 07 bne 2015ce8 <== NOT EXECUTED 2015cd0: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED if (!nlFlag) 2015cd4: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2015cd8: 32 80 00 13 bne,a 2015d24 <== NOT EXECUTED 2015cdc: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED --(*nleft); } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; 2015ce0: 81 c7 e0 08 ret <== NOT EXECUTED 2015ce4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if (c == '\n') { if (!nlFlag) return 0; break; } if (c == EOF) 2015ce8: 22 80 00 17 be,a 2015d44 <== NOT EXECUTED 2015cec: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; if (*nleft < 2) 2015cf0: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED 2015cf4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2015cf8: 28 80 00 13 bleu,a 2015d44 <== NOT EXECUTED 2015cfc: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; **bufp = c; 2015d00: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2015d04: d0 28 40 00 stb %o0, [ %g1 ] <== NOT EXECUTED ++(*bufp); 2015d08: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED --(*nleft); 2015d0c: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED if (c == EOF) return 0; if (*nleft < 2) return 0; **bufp = c; ++(*bufp); 2015d10: 82 00 60 01 inc %g1 <== NOT EXECUTED --(*nleft); 2015d14: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED if (c == EOF) return 0; if (*nleft < 2) return 0; **bufp = c; ++(*bufp); 2015d18: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED --(*nleft); 2015d1c: 10 bf ff d6 b 2015c74 <== NOT EXECUTED 2015d20: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED } **bufp = '\0'; 2015d24: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED ++(*bufp); 2015d28: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED --(*nleft); 2015d2c: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; ++(*bufp); 2015d30: 82 00 60 01 inc %g1 <== NOT EXECUTED --(*nleft); 2015d34: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; ++(*bufp); 2015d38: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED --(*nleft); 2015d3c: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED 2015d40: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return 1; } 2015d44: 81 c7 e0 08 ret <== NOT EXECUTED 2015d48: 81 e8 00 00 restore <== NOT EXECUTED 020051a4 : scandir(dirname, namelist, select, dcomp) const char *dirname; struct dirent ***namelist; int (*select)(struct dirent *); int (*dcomp)(const struct dirent **, const struct dirent **); { 20051a4: 9d e3 bf 48 save %sp, -184, %sp struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 20051a8: 7f ff fd c4 call 20048b8 20051ac: 90 10 00 18 mov %i0, %o0 20051b0: a8 92 20 00 orcc %o0, 0, %l4 20051b4: 02 80 00 69 be 2005358 20051b8: 92 10 3f ff mov -1, %o1 return(-1); if (fstat(dirp->dd_fd, &stb) < 0) 20051bc: d0 05 00 00 ld [ %l4 ], %o0 20051c0: a0 07 bf a8 add %fp, -88, %l0 20051c4: 40 00 22 4b call 200daf0 20051c8: 92 10 00 10 mov %l0, %o1 20051cc: 80 a2 20 00 cmp %o0, 0 20051d0: 06 80 00 50 bl 2005310 20051d4: d0 07 bf c8 ld [ %fp + -56 ], %o0 /* * estimate the array size by taking the size of the directory file * and dividing it by a multiple of the minimum size entry. */ arraysz = (stb.st_size / 24); 20051d8: 40 00 40 76 call 20153b0 <.div> 20051dc: 92 10 20 18 mov 0x18, %o1 names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); if (names == NULL) 20051e0: b0 10 20 00 clr %i0 /* * estimate the array size by taking the size of the directory file * and dividing it by a multiple of the minimum size entry. */ arraysz = (stb.st_size / 24); 20051e4: a6 10 00 08 mov %o0, %l3 names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 20051e8: 7f ff fb 19 call 2003e4c 20051ec: 91 2a 20 02 sll %o0, 2, %o0 if (names == NULL) 20051f0: a2 92 20 00 orcc %o0, 0, %l1 20051f4: 02 80 00 49 be 2005318 20051f8: aa 10 00 10 mov %l0, %l5 20051fc: 30 80 00 31 b,a 20052c0 goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { if (select != NULL && !(*select)(d)) 2005200: 22 80 00 08 be,a 2005220 2005204: d0 14 20 0a lduh [ %l0 + 0xa ], %o0 <== NOT EXECUTED 2005208: 9f c6 80 00 call %i2 200520c: 01 00 00 00 nop 2005210: 80 a2 20 00 cmp %o0, 0 2005214: 02 80 00 2b be 20052c0 2005218: 01 00 00 00 nop continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 200521c: d0 14 20 0a lduh [ %l0 + 0xa ], %o0 2005220: 90 02 20 04 add %o0, 4, %o0 2005224: 90 0a 3f fc and %o0, -4, %o0 2005228: 7f ff fb 09 call 2003e4c 200522c: 90 02 20 0c add %o0, 0xc, %o0 if (p == NULL) goto cleanup_and_bail; p->d_ino = d->d_ino; p->d_reclen = d->d_reclen; p->d_namlen = d->d_namlen; strncpy(p->d_name, d->d_name, p->d_namlen + 1); 2005230: 92 04 20 0c add %l0, 0xc, %o1 if (select != NULL && !(*select)(d)) continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 2005234: a4 10 00 08 mov %o0, %l2 if (p == NULL) 2005238: 80 a4 a0 00 cmp %l2, 0 200523c: 02 80 00 37 be 2005318 2005240: 90 02 20 0c add %o0, 0xc, %o0 goto cleanup_and_bail; p->d_ino = d->d_ino; p->d_reclen = d->d_reclen; p->d_namlen = d->d_namlen; 2005244: c6 14 20 0a lduh [ %l0 + 0xa ], %g3 * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); if (p == NULL) goto cleanup_and_bail; p->d_ino = d->d_ino; 2005248: c2 04 00 00 ld [ %l0 ], %g1 p->d_reclen = d->d_reclen; 200524c: c4 14 20 08 lduh [ %l0 + 8 ], %g2 p->d_namlen = d->d_namlen; strncpy(p->d_name, d->d_name, p->d_namlen + 1); 2005250: 95 28 e0 10 sll %g3, 0x10, %o2 * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); if (p == NULL) goto cleanup_and_bail; p->d_ino = d->d_ino; 2005254: c2 24 80 00 st %g1, [ %l2 ] p->d_reclen = d->d_reclen; 2005258: c4 34 a0 08 sth %g2, [ %l2 + 8 ] p->d_namlen = d->d_namlen; 200525c: c6 34 a0 0a sth %g3, [ %l2 + 0xa ] strncpy(p->d_name, d->d_name, p->d_namlen + 1); 2005260: 95 32 a0 10 srl %o2, 0x10, %o2 2005264: 40 00 36 b4 call 2012d34 2005268: 94 02 a0 01 inc %o2 /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { 200526c: b0 06 20 01 inc %i0 2005270: 80 a6 00 13 cmp %i0, %l3 2005274: 0a 80 00 11 bcs 20052b8 2005278: 83 2e 20 02 sll %i0, 2, %g1 if (fstat(dirp->dd_fd, &stb) < 0) 200527c: d0 05 00 00 ld [ %l4 ], %o0 <== NOT EXECUTED 2005280: 40 00 22 1c call 200daf0 <== NOT EXECUTED 2005284: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 2005288: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200528c: 06 80 00 23 bl 2005318 <== NOT EXECUTED 2005290: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED goto cleanup_and_bail; /* just might have grown */ arraysz = stb.st_size / 12; 2005294: 40 00 40 47 call 20153b0 <.div> <== NOT EXECUTED 2005298: d0 07 bf c8 ld [ %fp + -56 ], %o0 <== NOT EXECUTED 200529c: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, 20052a0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20052a4: 7f ff fb 35 call 2003f78 <== NOT EXECUTED 20052a8: 93 2c e0 02 sll %l3, 2, %o1 <== NOT EXECUTED arraysz * sizeof(struct dirent *)); if (names == NULL) 20052ac: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 20052b0: 02 80 00 1a be 2005318 <== NOT EXECUTED 20052b4: 83 2e 20 02 sll %i0, 2, %g1 <== NOT EXECUTED goto cleanup_and_bail; } names[nitems-1] = p; 20052b8: 82 00 40 11 add %g1, %l1, %g1 20052bc: e4 20 7f fc st %l2, [ %g1 + -4 ] arraysz = (stb.st_size / 24); names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { 20052c0: 7f ff ff 21 call 2004f44 20052c4: 90 10 00 14 mov %l4, %o0 20052c8: a0 92 20 00 orcc %o0, 0, %l0 20052cc: 12 bf ff cd bne 2005200 20052d0: 80 a6 a0 00 cmp %i2, 0 if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; } closedir(dirp); 20052d4: 7f ff f8 14 call 2003324 20052d8: 90 10 00 14 mov %l4, %o0 if (nitems && dcomp != NULL){ 20052dc: 80 a6 20 00 cmp %i0, 0 20052e0: 22 80 00 0a be,a 2005308 20052e4: e2 26 40 00 st %l1, [ %i1 ] <== NOT EXECUTED 20052e8: 80 a6 e0 00 cmp %i3, 0 20052ec: 02 80 00 06 be 2005304 20052f0: 96 10 00 1b mov %i3, %o3 qsort(names, nitems, sizeof(struct dirent *), dcomp); 20052f4: 90 10 00 11 mov %l1, %o0 20052f8: 92 10 00 18 mov %i0, %o1 20052fc: 40 00 33 5f call 2012078 2005300: 94 10 20 04 mov 4, %o2 } *namelist = names; 2005304: e2 26 40 00 st %l1, [ %i1 ] return(nitems); 2005308: 10 80 00 14 b 2005358 200530c: 92 10 00 18 mov %i0, %o1 2005310: a2 10 20 00 clr %l1 <== NOT EXECUTED 2005314: b0 10 20 00 clr %i0 <== NOT EXECUTED cleanup_and_bail: if ( dirp ) closedir( dirp ); 2005318: 7f ff f8 03 call 2003324 200531c: 90 10 00 14 mov %l4, %o0 if ( names ) { 2005320: 80 a4 60 00 cmp %l1, 0 2005324: 12 80 00 07 bne 2005340 2005328: a0 10 20 00 clr %l0 for (i=0; i < nitems; i++ ) free( names[i] ); free( names ); 200532c: 10 80 00 0b b 2005358 2005330: 92 10 3f ff mov -1, %o1 if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) free( names[i] ); 2005334: d0 00 40 11 ld [ %g1 + %l1 ], %o0 <== NOT EXECUTED 2005338: 7f ff fa 9d call 2003dac <== NOT EXECUTED 200533c: a0 04 20 01 inc %l0 <== NOT EXECUTED if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 2005340: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED 2005344: 12 bf ff fc bne 2005334 <== NOT EXECUTED 2005348: 83 2c 20 02 sll %l0, 2, %g1 <== NOT EXECUTED free( names[i] ); free( names ); 200534c: 7f ff fa 98 call 2003dac <== NOT EXECUTED 2005350: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2005354: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED } return(-1); } 2005358: 81 c7 e0 08 ret 200535c: 91 e8 00 09 restore %g0, %o1, %o0 02015d4c : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 2015d4c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 2015d50: 98 10 20 00 clr %o4 <== NOT EXECUTED FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 2015d54: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 2015d58: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 2015d5c: b4 07 a0 50 add %fp, 0x50, %i2 <== NOT EXECUTED 2015d60: b6 07 a0 4c add %fp, 0x4c, %i3 <== NOT EXECUTED 2015d64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015d68: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2015d6c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015d70: 7f ff ff bd call 2015c64 <== NOT EXECUTED 2015d74: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015d78: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015d7c: 02 80 00 42 be 2015e84 <== NOT EXECUTED 2015d80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015d84: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED 2015d88: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015d8c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015d90: 7f ff ff b5 call 2015c64 <== NOT EXECUTED 2015d94: 98 10 20 00 clr %o4 <== NOT EXECUTED 2015d98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015d9c: 02 80 00 3a be 2015e84 <== NOT EXECUTED 2015da0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015da4: 7f ff ff 70 call 2015b64 <== NOT EXECUTED 2015da8: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 2015dac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015db0: 02 80 00 35 be 2015e84 <== NOT EXECUTED 2015db4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015db8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015dbc: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015dc0: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED 2015dc4: 7f ff ff a8 call 2015c64 <== NOT EXECUTED 2015dc8: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED 2015dcc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015dd0: 02 80 00 2d be 2015e84 <== NOT EXECUTED 2015dd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2015dd8: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; grp->gr_gid = grgid; 2015ddc: c2 36 60 08 sth %g1, [ %i1 + 8 ] <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2015de0: 10 80 00 05 b 2015df4 <== NOT EXECUTED 2015de4: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED if(*cp == ',') memcount++; 2015de8: 82 18 60 2c xor %g1, 0x2c, %g1 <== NOT EXECUTED 2015dec: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2015df0: 86 60 ff ff subx %g3, -1, %g3 <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2015df4: c2 48 80 00 ldsb [ %g2 ], %g1 <== NOT EXECUTED 2015df8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015dfc: 12 bf ff fb bne 2015de8 <== NOT EXECUTED 2015e00: 84 00 a0 01 inc %g2 <== NOT EXECUTED } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 2015e04: c4 07 a0 50 ld [ %fp + 0x50 ], %g2 <== NOT EXECUTED 2015e08: 83 28 e0 02 sll %g3, 2, %g1 <== NOT EXECUTED 2015e0c: 82 00 60 13 add %g1, 0x13, %g1 <== NOT EXECUTED 2015e10: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2015e14: 0a 80 00 1c bcs 2015e84 <== NOT EXECUTED 2015e18: c2 07 a0 4c ld [ %fp + 0x4c ], %g1 <== NOT EXECUTED grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 2015e1c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 2015e20: 82 00 60 0f add %g1, 0xf, %g1 <== NOT EXECUTED 2015e24: 82 08 7f f0 and %g1, -16, %g1 <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 2015e28: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 2015e2c: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 2015e30: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2015e34: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 2015e38: 10 80 00 0a b 2015e60 <== NOT EXECUTED 2015e3c: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { if(*cp == ',') { 2015e40: 32 80 00 08 bne,a 2015e60 <== NOT EXECUTED 2015e44: 86 00 e0 01 inc %g3 <== NOT EXECUTED *cp = '\0'; 2015e48: c0 28 ff ff clrb [ %g3 + -1 ] <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 2015e4c: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED 2015e50: 83 29 20 02 sll %g4, 2, %g1 <== NOT EXECUTED 2015e54: 88 01 20 01 inc %g4 <== NOT EXECUTED 2015e58: c6 20 80 01 st %g3, [ %g2 + %g1 ] <== NOT EXECUTED 2015e5c: 86 00 e0 01 inc %g3 <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2015e60: c2 48 ff ff ldsb [ %g3 + -1 ], %g1 <== NOT EXECUTED 2015e64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2015e68: 32 bf ff f6 bne,a 2015e40 <== NOT EXECUTED 2015e6c: 80 a0 60 2c cmp %g1, 0x2c <== NOT EXECUTED if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 2015e70: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED 2015e74: 83 29 20 02 sll %g4, 2, %g1 <== NOT EXECUTED 2015e78: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED 2015e7c: 81 c7 e0 08 ret <== NOT EXECUTED 2015e80: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED return 1; } 2015e84: 81 c7 e0 08 ret <== NOT EXECUTED 2015e88: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02015ed4 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 2015ed4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 2015ed8: 98 10 20 00 clr %o4 <== NOT EXECUTED FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 2015edc: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 2015ee0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 2015ee4: b4 07 a0 50 add %fp, 0x50, %i2 <== NOT EXECUTED 2015ee8: b6 07 a0 4c add %fp, 0x4c, %i3 <== NOT EXECUTED 2015eec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015ef0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2015ef4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015ef8: 7f ff ff 5b call 2015c64 <== NOT EXECUTED 2015efc: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015f00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f04: 02 80 00 39 be 2015fe8 <== NOT EXECUTED 2015f08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f0c: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED 2015f10: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015f14: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015f18: 7f ff ff 53 call 2015c64 <== NOT EXECUTED 2015f1c: 98 10 20 00 clr %o4 <== NOT EXECUTED 2015f20: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f24: 02 80 00 31 be 2015fe8 <== NOT EXECUTED 2015f28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f2c: 7f ff ff 0e call 2015b64 <== NOT EXECUTED 2015f30: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 2015f34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f38: 02 80 00 2c be 2015fe8 <== NOT EXECUTED 2015f3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f40: 7f ff ff 09 call 2015b64 <== NOT EXECUTED 2015f44: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED 2015f48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f4c: 02 80 00 27 be 2015fe8 <== NOT EXECUTED 2015f50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f54: 92 06 60 0c add %i1, 0xc, %o1 <== NOT EXECUTED 2015f58: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015f5c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015f60: 7f ff ff 41 call 2015c64 <== NOT EXECUTED 2015f64: 98 10 20 00 clr %o4 <== NOT EXECUTED 2015f68: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f6c: 02 80 00 1f be 2015fe8 <== NOT EXECUTED 2015f70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f74: 92 06 60 10 add %i1, 0x10, %o1 <== NOT EXECUTED 2015f78: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015f7c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015f80: 7f ff ff 39 call 2015c64 <== NOT EXECUTED 2015f84: 98 10 20 00 clr %o4 <== NOT EXECUTED 2015f88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015f8c: 02 80 00 17 be 2015fe8 <== NOT EXECUTED 2015f90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015f94: 92 06 60 14 add %i1, 0x14, %o1 <== NOT EXECUTED 2015f98: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015f9c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015fa0: 7f ff ff 31 call 2015c64 <== NOT EXECUTED 2015fa4: 98 10 20 00 clr %o4 <== NOT EXECUTED 2015fa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015fac: 02 80 00 0f be 2015fe8 <== NOT EXECUTED 2015fb0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2015fb4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2015fb8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2015fbc: 92 06 60 18 add %i1, 0x18, %o1 <== NOT EXECUTED 2015fc0: 7f ff ff 29 call 2015c64 <== NOT EXECUTED 2015fc4: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED 2015fc8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015fcc: 02 80 00 07 be 2015fe8 <== NOT EXECUTED 2015fd0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) return 0; pwd->pw_uid = pwuid; 2015fd4: c2 36 60 08 sth %g1, [ %i1 + 8 ] <== NOT EXECUTED pwd->pw_gid = pwgid; 2015fd8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2015fdc: c2 36 60 0a sth %g1, [ %i1 + 0xa ] <== NOT EXECUTED 2015fe0: 81 c7 e0 08 ret <== NOT EXECUTED 2015fe4: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED return 1; } 2015fe8: 81 c7 e0 08 ret <== NOT EXECUTED 2015fec: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02006900 : */ int sched_get_priority_max( int policy ) { 2006900: 9d e3 bf 98 save %sp, -104, %sp switch ( policy ) { 2006904: 80 a6 20 03 cmp %i0, 3 2006908: 08 80 00 06 bleu 2006920 200690c: b0 10 20 fe mov 0xfe, %i0 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2006910: 40 00 25 2b call 200fdbc <__errno> <== NOT EXECUTED 2006914: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006918: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200691c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 2006920: 81 c7 e0 08 ret 2006924: 81 e8 00 00 restore 02006960 : int sched_getparam( pid_t pid, const struct sched_param *param ) { 2006960: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006964: 40 00 25 16 call 200fdbc <__errno> <== NOT EXECUTED 2006968: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200696c: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006970: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006974: 81 c7 e0 08 ret <== NOT EXECUTED 2006978: 81 e8 00 00 restore <== NOT EXECUTED 02006928 : */ int sched_getscheduler( pid_t pid ) { 2006928: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 200692c: 40 00 25 24 call 200fdbc <__errno> <== NOT EXECUTED 2006930: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006934: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006938: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 200693c: 81 c7 e0 08 ret <== NOT EXECUTED 2006940: 81 e8 00 00 restore <== NOT EXECUTED 02006998 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 2006998: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 200699c: 80 a6 20 00 cmp %i0, 0 20069a0: 02 80 00 0b be 20069cc 20069a4: 80 a6 60 00 cmp %i1, 0 20069a8: 7f ff f1 7c call 2002f98 20069ac: 01 00 00 00 nop 20069b0: 80 a6 00 08 cmp %i0, %o0 20069b4: 02 80 00 06 be 20069cc 20069b8: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 20069bc: 40 00 25 00 call 200fdbc <__errno> <== NOT EXECUTED 20069c0: 01 00 00 00 nop <== NOT EXECUTED 20069c4: 10 80 00 07 b 20069e0 <== NOT EXECUTED 20069c8: 82 10 20 03 mov 3, %g1 ! 3 <== NOT EXECUTED if ( !interval ) 20069cc: 12 80 00 08 bne 20069ec 20069d0: 03 00 80 71 sethi %hi(0x201c400), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); 20069d4: 40 00 24 fa call 200fdbc <__errno> <== NOT EXECUTED 20069d8: 01 00 00 00 nop <== NOT EXECUTED 20069dc: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 20069e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20069e4: 81 c7 e0 08 ret <== NOT EXECUTED 20069e8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 20069ec: d0 00 63 58 ld [ %g1 + 0x358 ], %o0 20069f0: 92 10 00 19 mov %i1, %o1 20069f4: 40 00 14 22 call 200ba7c <_Timespec_From_ticks> 20069f8: b0 10 20 00 clr %i0 return 0; } 20069fc: 81 c7 e0 08 ret 2006a00: 81 e8 00 00 restore 0200697c : int sched_setparam( pid_t pid, const struct sched_param *param ) { 200697c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006980: 40 00 25 0f call 200fdbc <__errno> <== NOT EXECUTED 2006984: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006988: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 200698c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006990: 81 c7 e0 08 ret <== NOT EXECUTED 2006994: 81 e8 00 00 restore <== NOT EXECUTED 02006944 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 2006944: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006948: 40 00 25 1d call 200fdbc <__errno> <== NOT EXECUTED 200694c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006950: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2006954: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2006958: 81 c7 e0 08 ret <== NOT EXECUTED 200695c: 81 e8 00 00 restore <== NOT EXECUTED 0200681c : */ int sem_close( sem_t *sem ) { 200681c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get ( sem_t *id, Objects_Locations *location ) { return (POSIX_Semaphore_Control *) 2006820: d2 06 00 00 ld [ %i0 ], %o1 2006824: 11 00 80 78 sethi %hi(0x201e000), %o0 2006828: 94 07 bf f4 add %fp, -12, %o2 200682c: 40 00 0b b7 call 2009708 <_Objects_Get> 2006830: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006834: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006838: 80 a0 60 01 cmp %g1, 1 200683c: 02 80 00 0d be 2006870 2006840: 01 00 00 00 nop 2006844: 2a 80 00 11 bcs,a 2006888 2006848: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200684c: 80 a0 60 02 cmp %g1, 2 2006850: 12 80 00 1e bne 20068c8 2006854: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2006858: 40 00 28 b0 call 2010b18 <__errno> 200685c: 01 00 00 00 nop 2006860: 82 10 20 16 mov 0x16, %g1 ! 16 2006864: c2 22 00 00 st %g1, [ %o0 ] 2006868: 10 80 00 1a b 20068d0 200686c: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006870: 40 00 10 6c call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006874: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006878: 40 00 01 78 call 2006e58 <== NOT EXECUTED 200687c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006880: 81 c7 e0 08 ret <== NOT EXECUTED 2006884: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 2006888: 82 00 7f ff add %g1, -1, %g1 _POSIX_Semaphore_Delete( the_semaphore ); 200688c: 40 00 20 3d call 200e980 <_POSIX_Semaphore_Delete> 2006890: c2 22 20 1c st %g1, [ %o0 + 0x1c ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006894: 05 00 80 77 sethi %hi(0x201dc00), %g2 2006898: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 201df50 <_Thread_Dispatch_disable_level> 200689c: 90 10 20 00 clr %o0 20068a0: 82 00 7f ff add %g1, -1, %g1 20068a4: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 20068a8: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 20068ac: 80 a0 60 00 cmp %g1, 0 20068b0: 32 80 00 09 bne,a 20068d4 20068b4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 20068b8: 40 00 10 5a call 200aa20 <_Thread_Dispatch> 20068bc: 01 00 00 00 nop 20068c0: 10 80 00 04 b 20068d0 20068c4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20068c8: 40 00 01 5a call 2006e30 <== NOT EXECUTED 20068cc: 01 00 00 00 nop <== NOT EXECUTED } 20068d0: b0 10 00 08 mov %o0, %i0 20068d4: 81 c7 e0 08 ret 20068d8: 81 e8 00 00 restore 02006910 : */ int sem_destroy( sem_t *sem ) { 2006910: 9d e3 bf 90 save %sp, -112, %sp 2006914: d2 06 00 00 ld [ %i0 ], %o1 2006918: 11 00 80 78 sethi %hi(0x201e000), %o0 200691c: 94 07 bf f4 add %fp, -12, %o2 2006920: 40 00 0b 7a call 2009708 <_Objects_Get> 2006924: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006928: c2 07 bf f4 ld [ %fp + -12 ], %g1 200692c: 80 a0 60 01 cmp %g1, 1 2006930: 02 80 00 08 be 2006950 2006934: 01 00 00 00 nop 2006938: 2a 80 00 0c bcs,a 2006968 200693c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006940: 80 a0 60 02 cmp %g1, 2 2006944: 12 80 00 1a bne 20069ac 2006948: 01 00 00 00 nop 200694c: 30 80 00 0c b,a 200697c case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2006950: 40 00 10 34 call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006954: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006958: 40 00 01 40 call 2006e58 <== NOT EXECUTED 200695c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006960: 81 c7 e0 08 ret <== NOT EXECUTED 2006964: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 2006968: 80 a0 60 01 cmp %g1, 1 200696c: 12 80 00 0a bne 2006994 2006970: 01 00 00 00 nop _Thread_Enable_dispatch(); 2006974: 7f ff ff da call 20068dc <_Thread_Enable_dispatch> <== NOT EXECUTED 2006978: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200697c: 40 00 28 67 call 2010b18 <__errno> 2006980: 01 00 00 00 nop 2006984: 82 10 20 16 mov 0x16, %g1 ! 16 2006988: c2 22 00 00 st %g1, [ %o0 ] 200698c: 10 80 00 0a b 20069b4 2006990: 90 10 3f ff mov -1, %o0 } _POSIX_Semaphore_Delete( the_semaphore ); 2006994: 40 00 1f fb call 200e980 <_POSIX_Semaphore_Delete> 2006998: 01 00 00 00 nop _Thread_Enable_dispatch(); 200699c: 7f ff ff d0 call 20068dc <_Thread_Enable_dispatch> 20069a0: 01 00 00 00 nop 20069a4: 10 80 00 04 b 20069b4 20069a8: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); 20069ac: 40 00 01 21 call 2006e30 <== NOT EXECUTED 20069b0: 01 00 00 00 nop <== NOT EXECUTED } 20069b4: b0 10 00 08 mov %o0, %i0 20069b8: 81 c7 e0 08 ret 20069bc: 81 e8 00 00 restore 020069c0 : int sem_getvalue( sem_t *sem, int *sval ) { 20069c0: 9d e3 bf 90 save %sp, -112, %sp 20069c4: d2 06 00 00 ld [ %i0 ], %o1 20069c8: 11 00 80 78 sethi %hi(0x201e000), %o0 20069cc: 94 07 bf f4 add %fp, -12, %o2 20069d0: 40 00 0b 4e call 2009708 <_Objects_Get> 20069d4: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 20069d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20069dc: 80 a0 60 01 cmp %g1, 1 20069e0: 02 80 00 0d be 2006a14 20069e4: 01 00 00 00 nop 20069e8: 2a 80 00 11 bcs,a 2006a2c 20069ec: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 20069f0: 80 a0 60 02 cmp %g1, 2 20069f4: 12 80 00 1c bne 2006a64 20069f8: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 20069fc: 40 00 28 47 call 2010b18 <__errno> 2006a00: 01 00 00 00 nop 2006a04: 82 10 20 16 mov 0x16, %g1 ! 16 2006a08: c2 22 00 00 st %g1, [ %o0 ] 2006a0c: 10 80 00 18 b 2006a6c 2006a10: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006a14: 40 00 10 03 call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006a18: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006a1c: 40 00 01 0f call 2006e58 <== NOT EXECUTED 2006a20: 01 00 00 00 nop <== NOT EXECUTED *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006a24: 81 c7 e0 08 ret <== NOT EXECUTED 2006a28: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 2006a2c: c2 26 40 00 st %g1, [ %i1 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006a30: 05 00 80 77 sethi %hi(0x201dc00), %g2 2006a34: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 ! 201df50 <_Thread_Dispatch_disable_level> 2006a38: 90 10 20 00 clr %o0 2006a3c: 82 00 7f ff add %g1, -1, %g1 2006a40: c2 20 a3 50 st %g1, [ %g2 + 0x350 ] 2006a44: c2 00 a3 50 ld [ %g2 + 0x350 ], %g1 2006a48: 80 a0 60 00 cmp %g1, 0 2006a4c: 32 80 00 09 bne,a 2006a70 2006a50: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006a54: 40 00 0f f3 call 200aa20 <_Thread_Dispatch> 2006a58: 01 00 00 00 nop 2006a5c: 10 80 00 04 b 2006a6c 2006a60: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006a64: 40 00 00 f3 call 2006e30 <== NOT EXECUTED 2006a68: 01 00 00 00 nop <== NOT EXECUTED } 2006a6c: b0 10 00 08 mov %o0, %i0 2006a70: 81 c7 e0 08 ret 2006a74: 81 e8 00 00 restore 02006a78 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 2006a78: 9d e3 bf 90 save %sp, -112, %sp 2006a7c: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 2006a80: 80 a6 20 00 cmp %i0, 0 2006a84: 12 80 00 08 bne 2006aa4 2006a88: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); 2006a8c: 40 00 28 23 call 2010b18 <__errno> <== NOT EXECUTED 2006a90: 01 00 00 00 nop <== NOT EXECUTED 2006a94: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2006a98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2006a9c: 10 80 00 0a b 2006ac4 <== NOT EXECUTED 2006aa0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED status = _POSIX_Semaphore_Create_support( 2006aa4: 90 10 20 00 clr %o0 2006aa8: 40 00 1f 6a call 200e850 <_POSIX_Semaphore_Create_support> 2006aac: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 2006ab0: 80 a2 3f ff cmp %o0, -1 2006ab4: 02 80 00 04 be 2006ac4 2006ab8: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 2006abc: c2 00 60 08 ld [ %g1 + 8 ], %g1 2006ac0: c2 26 00 00 st %g1, [ %i0 ] return status; } 2006ac4: 81 c7 e0 08 ret 2006ac8: 91 e8 00 08 restore %g0, %o0, %o0 02006c1c : */ int sem_post( sem_t *sem ) { 2006c1c: 9d e3 bf 90 save %sp, -112, %sp 2006c20: d2 06 00 00 ld [ %i0 ], %o1 2006c24: 11 00 80 78 sethi %hi(0x201e000), %o0 2006c28: 94 07 bf f4 add %fp, -12, %o2 2006c2c: 40 00 0a b7 call 2009708 <_Objects_Get> 2006c30: 90 12 22 d0 or %o0, 0x2d0, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006c34: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c38: 80 a0 60 01 cmp %g1, 1 2006c3c: 02 80 00 0d be 2006c70 2006c40: 01 00 00 00 nop 2006c44: 2a 80 00 11 bcs,a 2006c88 2006c48: d2 02 20 08 ld [ %o0 + 8 ], %o1 2006c4c: 80 a0 60 02 cmp %g1, 2 2006c50: 12 80 00 1e bne 2006cc8 2006c54: 01 00 00 00 nop case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2006c58: 40 00 27 b0 call 2010b18 <__errno> 2006c5c: 01 00 00 00 nop 2006c60: 82 10 20 16 mov 0x16, %g1 ! 16 2006c64: c2 22 00 00 st %g1, [ %o0 ] 2006c68: 10 80 00 1a b 2006cd0 2006c6c: 90 10 3f ff mov -1, %o0 case OBJECTS_REMOTE: _Thread_Dispatch(); 2006c70: 40 00 0f 6c call 200aa20 <_Thread_Dispatch> <== NOT EXECUTED 2006c74: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006c78: 40 00 00 78 call 2006e58 <== NOT EXECUTED 2006c7c: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006c80: 81 c7 e0 08 ret <== NOT EXECUTED 2006c84: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: _Thread_Dispatch(); return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 2006c88: 94 10 20 00 clr %o2 2006c8c: 40 00 07 a4 call 2008b1c <_CORE_semaphore_Surrender> 2006c90: 90 02 20 20 add %o0, 0x20, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006c94: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006c98: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level> 2006c9c: 90 10 20 00 clr %o0 2006ca0: 84 00 bf ff add %g2, -1, %g2 2006ca4: c4 20 63 50 st %g2, [ %g1 + 0x350 ] 2006ca8: c2 00 63 50 ld [ %g1 + 0x350 ], %g1 2006cac: 80 a0 60 00 cmp %g1, 0 2006cb0: 32 80 00 09 bne,a 2006cd4 2006cb4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006cb8: 40 00 0f 5a call 200aa20 <_Thread_Dispatch> 2006cbc: 01 00 00 00 nop 2006cc0: 10 80 00 04 b 2006cd0 2006cc4: 90 10 20 00 clr %o0 ! 0 #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006cc8: 40 00 00 5a call 2006e30 <== NOT EXECUTED 2006ccc: 01 00 00 00 nop <== NOT EXECUTED } 2006cd0: b0 10 00 08 mov %o0, %i0 2006cd4: 81 c7 e0 08 ret 2006cd8: 81 e8 00 00 restore 02015b00 : int setgid( gid_t gid ) { _POSIX_types_Gid = gid; 2015b00: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2015b04: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2037710 <== NOT EXECUTED 2015b08: d0 30 60 2a sth %o0, [ %g1 + 0x2a ] <== NOT EXECUTED return 0; } 2015b0c: 81 c3 e0 08 retl <== NOT EXECUTED 2015b10: 90 10 20 00 clr %o0 <== NOT EXECUTED 02016114 : return NULL; return &grent; } void setgrent(void) { 2016114: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED init_etc_passwd_group(); 2016118: 7f ff ff c8 call 2016038 <== NOT EXECUTED 201611c: 21 00 80 e3 sethi %hi(0x2038c00), %l0 <== NOT EXECUTED if (group_fp != NULL) 2016120: d0 04 23 bc ld [ %l0 + 0x3bc ], %o0 ! 2038fbc <== NOT EXECUTED 2016124: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016128: 22 80 00 05 be,a 201613c <== NOT EXECUTED 201612c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED fclose(group_fp); 2016130: 40 00 2f 69 call 2021ed4 <== NOT EXECUTED 2016134: 01 00 00 00 nop <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 2016138: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 201613c: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 2016140: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED 2016144: 40 00 31 62 call 20226cc <== NOT EXECUTED 2016148: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 201614c: d0 24 23 bc st %o0, [ %l0 + 0x3bc ] <== NOT EXECUTED } 2016150: 81 c7 e0 08 ret <== NOT EXECUTED 2016154: 81 e8 00 00 restore <== NOT EXECUTED 02016304 : return NULL; return &pwent; } void setpwent(void) { 2016304: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED init_etc_passwd_group(); 2016308: 7f ff ff 4c call 2016038 <== NOT EXECUTED 201630c: 21 00 80 e3 sethi %hi(0x2038c00), %l0 <== NOT EXECUTED if (passwd_fp != NULL) 2016310: d0 04 22 d4 ld [ %l0 + 0x2d4 ], %o0 ! 2038ed4 <== NOT EXECUTED 2016314: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016318: 22 80 00 05 be,a 201632c <== NOT EXECUTED 201631c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED fclose(passwd_fp); 2016320: 40 00 2e ed call 2021ed4 <== NOT EXECUTED 2016324: 01 00 00 00 nop <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 2016328: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED 201632c: 13 00 80 da sethi %hi(0x2036800), %o1 <== NOT EXECUTED 2016330: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED 2016334: 40 00 30 e6 call 20226cc <== NOT EXECUTED 2016338: 92 12 60 90 or %o1, 0x90, %o1 <== NOT EXECUTED 201633c: d0 24 22 d4 st %o0, [ %l0 + 0x2d4 ] <== NOT EXECUTED } 2016340: 81 c7 e0 08 ret <== NOT EXECUTED 2016344: 81 e8 00 00 restore <== NOT EXECUTED 02016504 : int setuid( uid_t uid ) { _POSIX_types_Uid = uid; 2016504: 03 00 80 dd sethi %hi(0x2037400), %g1 <== NOT EXECUTED 2016508: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 ! 2037710 <== NOT EXECUTED 201650c: d0 30 60 28 sth %o0, [ %g1 + 0x28 ] <== NOT EXECUTED return 0; } 2016510: 81 c3 e0 08 retl <== NOT EXECUTED 2016514: 90 10 20 00 clr %o0 <== NOT EXECUTED 02005ec8 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 2005ec8: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 2005ecc: 90 96 a0 00 orcc %i2, 0, %o0 2005ed0: 02 80 00 09 be 2005ef4 2005ed4: 85 2e 20 02 sll %i0, 2, %g2 *oact = _POSIX_signals_Vectors[ sig ]; 2005ed8: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED 2005edc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 2005ee0: 13 00 80 70 sethi %hi(0x201c000), %o1 <== NOT EXECUTED 2005ee4: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED 2005ee8: 92 12 60 e4 or %o1, 0xe4, %o1 <== NOT EXECUTED 2005eec: 40 00 27 ba call 200fdd4 <== NOT EXECUTED 2005ef0: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED if ( !sig ) 2005ef4: 80 a6 20 00 cmp %i0, 0 2005ef8: 02 80 00 08 be 2005f18 2005efc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2005f00: a0 06 3f ff add %i0, -1, %l0 2005f04: 80 a4 20 1f cmp %l0, 0x1f 2005f08: 18 80 00 04 bgu 2005f18 2005f0c: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 2005f10: 12 80 00 08 bne 2005f30 2005f14: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 2005f18: 40 00 25 c9 call 200f63c <__errno> 2005f1c: 01 00 00 00 nop 2005f20: 82 10 20 16 mov 0x16, %g1 ! 16 2005f24: c2 22 00 00 st %g1, [ %o0 ] 2005f28: 10 80 00 1f b 2005fa4 2005f2c: 82 10 3f ff mov -1, %g1 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 2005f30: 02 80 00 1d be 2005fa4 2005f34: 82 10 20 00 clr %g1 /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 2005f38: 7f ff f0 fe call 2002330 2005f3c: 01 00 00 00 nop 2005f40: a4 10 00 08 mov %o0, %l2 if ( act->sa_handler == SIG_DFL ) { 2005f44: c2 06 60 08 ld [ %i1 + 8 ], %g1 2005f48: b5 2e 20 04 sll %i0, 4, %i2 2005f4c: 80 a0 60 00 cmp %g1, 0 2005f50: b1 2e 20 02 sll %i0, 2, %i0 2005f54: 03 00 80 70 sethi %hi(0x201c000), %g1 2005f58: 12 80 00 08 bne 2005f78 2005f5c: a2 10 60 e4 or %g1, 0xe4, %l1 ! 201c0e4 <_POSIX_signals_Vectors> _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 2005f60: 82 26 80 18 sub %i2, %i0, %g1 <== NOT EXECUTED 2005f64: 13 00 80 6b sethi %hi(0x201ac00), %o1 <== NOT EXECUTED 2005f68: 90 00 40 11 add %g1, %l1, %o0 <== NOT EXECUTED 2005f6c: 92 12 61 e4 or %o1, 0x1e4, %o1 <== NOT EXECUTED 2005f70: 10 80 00 08 b 2005f90 <== NOT EXECUTED 2005f74: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 2005f78: 90 10 20 01 mov 1, %o0 2005f7c: 40 00 1d 99 call 200d5e0 <_POSIX_signals_Clear_process_signals> 2005f80: 91 2a 00 10 sll %o0, %l0, %o0 _POSIX_signals_Vectors[ sig ] = *act; 2005f84: 90 26 80 18 sub %i2, %i0, %o0 2005f88: 92 10 00 19 mov %i1, %o1 2005f8c: 90 02 00 11 add %o0, %l1, %o0 2005f90: 40 00 27 91 call 200fdd4 2005f94: 94 10 20 0c mov 0xc, %o2 } _ISR_Enable( level ); 2005f98: 7f ff f0 ea call 2002340 2005f9c: 90 10 00 12 mov %l2, %o0 2005fa0: 82 10 20 00 clr %g1 * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 2005fa4: 81 c7 e0 08 ret 2005fa8: 91 e8 00 01 restore %g0, %g1, %o0 02006324 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 2006324: 9d e3 bf 88 save %sp, -120, %sp * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 2006328: 80 a6 a0 00 cmp %i2, 0 200632c: 02 80 00 12 be 2006374 2006330: a6 10 20 00 clr %l3 if ( !_Timespec_Is_valid( timeout ) ) 2006334: 40 00 14 12 call 200b37c <_Timespec_Is_valid> 2006338: 90 10 00 1a mov %i2, %o0 200633c: 80 a2 20 00 cmp %o0, 0 2006340: 02 80 00 07 be 200635c 2006344: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 2006348: 40 00 14 32 call 200b410 <_Timespec_To_ticks> 200634c: 90 10 00 1a mov %i2, %o0 if ( !interval ) 2006350: a6 92 20 00 orcc %o0, 0, %l3 2006354: 12 80 00 09 bne 2006378 2006358: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( EINVAL ); 200635c: 40 00 26 71 call 200fd20 <__errno> 2006360: b0 10 3f ff mov -1, %i0 2006364: 82 10 20 16 mov 0x16, %g1 2006368: c2 22 00 00 st %g1, [ %o0 ] 200636c: 81 c7 e0 08 ret 2006370: 81 e8 00 00 restore /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 2006374: 80 a6 60 00 cmp %i1, 0 2006378: 02 80 00 03 be 2006384 200637c: a4 07 bf ec add %fp, -20, %l2 2006380: a4 10 00 19 mov %i1, %l2 the_thread = _Thread_Executing; 2006384: 29 00 80 70 sethi %hi(0x201c000), %l4 2006388: f4 05 23 90 ld [ %l4 + 0x390 ], %i2 ! 201c390 <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 200638c: 7f ff f0 aa call 2002634 2006390: f2 06 a1 74 ld [ %i2 + 0x174 ], %i1 2006394: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 2006398: c4 06 00 00 ld [ %i0 ], %g2 200639c: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 20063a0: 80 88 80 01 btst %g2, %g1 20063a4: 22 80 00 10 be,a 20063e4 20063a8: 03 00 80 72 sethi %hi(0x201c800), %g1 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 20063ac: 7f ff ff c4 call 20062bc <_POSIX_signals_Get_highest> 20063b0: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 20063b4: 94 10 00 12 mov %l2, %o2 /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 20063b8: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 20063bc: 96 10 20 00 clr %o3 20063c0: 90 10 00 19 mov %i1, %o0 /* API signals pending? */ _ISR_Disable( level ); if ( *set & api->signals_pending ) { /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 20063c4: d2 24 80 00 st %o1, [ %l2 ] _POSIX_signals_Clear_signals( 20063c8: 40 00 1e 6b call 200dd74 <_POSIX_signals_Clear_signals> 20063cc: 98 10 20 00 clr %o4 the_info->si_signo, the_info, FALSE, FALSE ); _ISR_Enable( level ); 20063d0: 7f ff f0 9d call 2002644 20063d4: 90 10 00 10 mov %l0, %o0 the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return the_info->si_signo; 20063d8: f0 04 80 00 ld [ %l2 ], %i0 FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 20063dc: 10 80 00 13 b 2006428 20063e0: c0 24 a0 08 clr [ %l2 + 8 ] return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 20063e4: c2 00 63 10 ld [ %g1 + 0x310 ], %g1 20063e8: 80 88 80 01 btst %g2, %g1 20063ec: 02 80 00 13 be 2006438 20063f0: 23 00 80 70 sethi %hi(0x201c000), %l1 signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 20063f4: 7f ff ff b2 call 20062bc <_POSIX_signals_Get_highest> 20063f8: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 20063fc: 94 10 00 12 mov %l2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 2006400: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 2006404: 96 10 20 01 mov 1, %o3 2006408: 90 10 00 19 mov %i1, %o0 200640c: 92 10 00 18 mov %i0, %o1 2006410: 40 00 1e 59 call 200dd74 <_POSIX_signals_Clear_signals> 2006414: 98 10 20 00 clr %o4 _ISR_Enable( level ); 2006418: 7f ff f0 8b call 2002644 200641c: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; 2006420: c0 24 a0 08 clr [ %l2 + 8 ] if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); _ISR_Enable( level ); the_info->si_signo = signo; 2006424: f0 24 80 00 st %i0, [ %l2 ] the_info->si_code = SI_USER; 2006428: 82 10 20 01 mov 1, %g1 200642c: c2 24 a0 04 st %g1, [ %l2 + 4 ] 2006430: 81 c7 e0 08 ret 2006434: 81 e8 00 00 restore rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006438: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 200643c: 84 10 3f ff mov -1, %g2 2006440: 82 00 60 01 inc %g1 2006444: c4 24 80 00 st %g2, [ %l2 ] 2006448: c2 24 62 b0 st %g1, [ %l1 + 0x2b0 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 200644c: 82 10 20 04 mov 4, %g1 2006450: c2 26 a0 34 st %g1, [ %i2 + 0x34 ] the_thread->Wait.option = *set; 2006454: c2 06 00 00 ld [ %i0 ], %g1 the_thread->Wait.return_argument = the_info; 2006458: e4 26 a0 28 st %l2, [ %i2 + 0x28 ] the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; 200645c: c2 26 a0 30 st %g1, [ %i2 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 2006460: 21 00 80 72 sethi %hi(0x201c800), %l0 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2006464: 82 10 20 01 mov 1, %g1 2006468: a0 14 22 d0 or %l0, 0x2d0, %l0 200646c: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] 2006470: c2 24 20 30 st %g1, [ %l0 + 0x30 ] the_thread->Wait.return_code = EINTR; the_thread->Wait.option = *set; the_thread->Wait.return_argument = the_info; _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 2006474: 7f ff f0 74 call 2002644 2006478: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 200647c: 90 10 00 10 mov %l0, %o0 2006480: 92 10 00 13 mov %l3, %o1 2006484: 15 00 80 2b sethi %hi(0x200ac00), %o2 2006488: 40 00 10 fd call 200a87c <_Thread_queue_Enqueue_with_handler> 200648c: 94 12 a1 14 or %o2, 0x114, %o2 ! 200ad14 <_Thread_queue_Timeout> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006490: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 2006494: 82 00 7f ff add %g1, -1, %g1 2006498: c2 24 62 b0 st %g1, [ %l1 + 0x2b0 ] 200649c: c2 04 62 b0 ld [ %l1 + 0x2b0 ], %g1 20064a0: 80 a0 60 00 cmp %g1, 0 20064a4: 32 80 00 05 bne,a 20064b8 20064a8: d2 04 80 00 ld [ %l2 ], %o1 <== NOT EXECUTED _Thread_Dispatch(); 20064ac: 40 00 0f 5d call 200a220 <_Thread_Dispatch> 20064b0: 01 00 00 00 nop /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, FALSE, FALSE ); 20064b4: d2 04 80 00 ld [ %l2 ], %o1 20064b8: 94 10 00 12 mov %l2, %o2 20064bc: 96 10 20 00 clr %o3 20064c0: 98 10 20 00 clr %o4 20064c4: 40 00 1e 2c call 200dd74 <_POSIX_signals_Clear_signals> 20064c8: 90 10 00 19 mov %i1, %o0 errno = _Thread_Executing->Wait.return_code; 20064cc: 40 00 26 15 call 200fd20 <__errno> 20064d0: 01 00 00 00 nop 20064d4: c2 05 23 90 ld [ %l4 + 0x390 ], %g1 20064d8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 20064dc: c2 22 00 00 st %g1, [ %o0 ] return the_info->si_signo; 20064e0: f0 04 80 00 ld [ %l2 ], %i0 } 20064e4: 81 c7 e0 08 ret 20064e8: 81 e8 00 00 restore 020080d8 : int sigwait( const sigset_t *set, int *sig ) { 20080d8: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 20080dc: 92 10 20 00 clr %o1 20080e0: 90 10 00 18 mov %i0, %o0 20080e4: 7f ff ff 86 call 2007efc 20080e8: 94 10 20 00 clr %o2 if ( status != -1 ) { 20080ec: 80 a2 3f ff cmp %o0, -1 20080f0: 02 80 00 07 be 200810c 20080f4: 80 a6 60 00 cmp %i1, 0 if ( sig ) 20080f8: 02 80 00 03 be 2008104 20080fc: b0 10 20 00 clr %i0 *sig = status; 2008100: d0 26 40 00 st %o0, [ %i1 ] 2008104: 81 c7 e0 08 ret 2008108: 81 e8 00 00 restore return 0; } return errno; 200810c: 40 00 26 4c call 2011a3c <__errno> <== NOT EXECUTED 2008110: 01 00 00 00 nop <== NOT EXECUTED 2008114: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 2008118: 81 c7 e0 08 ret <== NOT EXECUTED 200811c: 81 e8 00 00 restore <== NOT EXECUTED 02003d70 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 2003d70: 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)) { 2003d74: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 2003d78: 80 88 6e 78 btst 0xe78, %g1 <== NOT EXECUTED 2003d7c: 12 80 00 04 bne 2003d8c <== NOT EXECUTED 2003d80: b0 0e 20 ff and %i0, 0xff, %i0 <== 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); 2003d84: 7f ff ff 89 call 2003ba8 <== NOT EXECUTED 2003d88: 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); 2003d8c: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED 2003d90: 94 10 20 00 clr %o2 <== NOT EXECUTED 2003d94: 40 00 06 f7 call 2005970 <== NOT EXECUTED 2003d98: 92 10 20 00 clr %o1 <== NOT EXECUTED i = iproc (c, tty); 2003d9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2003da0: 7f ff ff 82 call 2003ba8 <== NOT EXECUTED 2003da4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2003da8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED rtems_semaphore_release (tty->osem); 2003dac: 40 00 07 b8 call 2005c8c <== NOT EXECUTED 2003db0: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 2003db4: 81 c7 e0 08 ret <== NOT EXECUTED 2003db8: 81 e8 00 00 restore <== NOT EXECUTED 020053e0 : int _STAT_NAME( const char *path, struct stat *buf ) { 20053e0: 9d e3 bf 88 save %sp, -120, %sp /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 20053e4: 80 a6 60 00 cmp %i1, 0 20053e8: 12 80 00 06 bne 2005400 20053ec: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EFAULT ); 20053f0: 40 00 72 63 call 2021d7c <__errno> 20053f4: b0 10 3f ff mov -1, %i0 20053f8: 10 80 00 1c b 2005468 20053fc: 82 10 20 0e mov 0xe, %g1 status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 2005400: a0 07 bf e8 add %fp, -24, %l0 2005404: 92 10 20 00 clr %o1 2005408: 94 10 00 10 mov %l0, %o2 200540c: 96 10 20 01 mov 1, %o3 2005410: 7f ff fa 21 call 2003c94 2005414: b0 10 3f ff mov -1, %i0 if ( status != 0 ) 2005418: 80 a2 20 00 cmp %o0, 0 200541c: 12 80 00 14 bne 200546c 2005420: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !loc.handlers->fstat_h ){ 2005424: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 2005428: 80 a0 60 00 cmp %g1, 0 200542c: 12 80 00 12 bne 2005474 2005430: 92 10 20 00 clr %o1 rtems_filesystem_freenode( &loc ); 2005434: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2005438: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200543c: 02 80 00 08 be 200545c <== NOT EXECUTED 2005440: 01 00 00 00 nop <== NOT EXECUTED 2005444: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2005448: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200544c: 02 80 00 04 be 200545c <== NOT EXECUTED 2005450: 01 00 00 00 nop <== NOT EXECUTED 2005454: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005458: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 200545c: 40 00 72 48 call 2021d7c <__errno> <== NOT EXECUTED 2005460: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005464: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2005468: c2 22 00 00 st %g1, [ %o0 ] 200546c: 81 c7 e0 08 ret 2005470: 81 e8 00 00 restore /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 2005474: 94 10 20 50 mov 0x50, %o2 2005478: 40 00 79 65 call 2023a0c 200547c: 90 10 00 19 mov %i1, %o0 status = (*loc.handlers->fstat_h)( &loc, buf ); 2005480: c2 07 bf ec ld [ %fp + -20 ], %g1 2005484: 92 10 00 19 mov %i1, %o1 2005488: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 200548c: 9f c0 40 00 call %g1 2005490: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2005494: c2 07 bf f0 ld [ %fp + -16 ], %g1 2005498: 80 a0 60 00 cmp %g1, 0 200549c: 02 bf ff f4 be 200546c 20054a0: b0 10 00 08 mov %o0, %i0 20054a4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20054a8: 80 a0 60 00 cmp %g1, 0 20054ac: 02 80 00 04 be 20054bc 20054b0: 01 00 00 00 nop 20054b4: 9f c0 40 00 call %g1 20054b8: 90 10 00 10 mov %l0, %o0 return status; } 20054bc: 81 c7 e0 08 ret 20054c0: 81 e8 00 00 restore 02004d2c : int symlink( const char *actualpath, const char *sympath ) { 2004d2c: 9d e3 bf 80 save %sp, -128, %sp rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 2004d30: c2 4e 40 00 ldsb [ %i1 ], %g1 2004d34: 80 a0 60 2f cmp %g1, 0x2f 2004d38: 02 80 00 07 be 2004d54 2004d3c: a0 10 00 18 mov %i0, %l0 2004d40: 80 a0 60 5c cmp %g1, 0x5c 2004d44: 02 80 00 04 be 2004d54 2004d48: 80 a0 60 00 cmp %g1, 0 2004d4c: 32 80 00 0a bne,a 2004d74 2004d50: 03 00 80 64 sethi %hi(0x2019000), %g1 2004d54: 03 00 80 64 sethi %hi(0x2019000), %g1 2004d58: d2 00 60 70 ld [ %g1 + 0x70 ], %o1 ! 2019070 2004d5c: 90 07 bf e4 add %fp, -28, %o0 2004d60: 92 02 60 14 add %o1, 0x14, %o1 2004d64: 40 00 31 8d call 2011398 2004d68: 94 10 20 10 mov 0x10, %o2 2004d6c: 10 80 00 08 b 2004d8c 2004d70: 82 10 20 01 mov 1, %g1 2004d74: d2 00 60 70 ld [ %g1 + 0x70 ], %o1 2004d78: 90 07 bf e4 add %fp, -28, %o0 2004d7c: 92 02 60 04 add %o1, 4, %o1 2004d80: 40 00 31 86 call 2011398 2004d84: 94 10 20 10 mov 0x10, %o2 2004d88: 82 10 20 00 clr %g1 result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 2004d8c: 90 06 40 01 add %i1, %g1, %o0 2004d90: c2 07 bf ec ld [ %fp + -20 ], %g1 2004d94: b2 07 bf e4 add %fp, -28, %i1 2004d98: c2 00 60 04 ld [ %g1 + 4 ], %g1 2004d9c: 94 07 bf f4 add %fp, -12, %o2 2004da0: 92 10 00 19 mov %i1, %o1 2004da4: 9f c0 40 00 call %g1 2004da8: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 2004dac: 80 a2 20 00 cmp %o0, 0 2004db0: 12 80 00 10 bne 2004df0 2004db4: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !loc.ops->symlink_h ) { 2004db8: c4 00 60 38 ld [ %g1 + 0x38 ], %g2 2004dbc: 80 a0 a0 00 cmp %g2, 0 2004dc0: 12 80 00 0e bne 2004df8 2004dc4: d4 07 bf f4 ld [ %fp + -12 ], %o2 rtems_filesystem_freenode( &loc ); 2004dc8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2004dcc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004dd0: 02 80 00 04 be 2004de0 <== NOT EXECUTED 2004dd4: 01 00 00 00 nop <== NOT EXECUTED 2004dd8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004ddc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2004de0: 40 00 2f 8d call 2010c14 <__errno> <== NOT EXECUTED 2004de4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2004de8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2004dec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2004df0: 81 c7 e0 08 ret 2004df4: 81 e8 00 00 restore } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 2004df8: 92 10 00 10 mov %l0, %o1 2004dfc: 9f c0 80 00 call %g2 2004e00: 90 10 00 19 mov %i1, %o0 rtems_filesystem_freenode( &loc ); 2004e04: c2 07 bf ec ld [ %fp + -20 ], %g1 2004e08: 80 a0 60 00 cmp %g1, 0 2004e0c: 02 bf ff f9 be 2004df0 2004e10: b0 10 00 08 mov %o0, %i0 2004e14: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2004e18: 80 a0 60 00 cmp %g1, 0 2004e1c: 02 80 00 04 be 2004e2c 2004e20: 01 00 00 00 nop 2004e24: 9f c0 40 00 call %g1 2004e28: 90 10 00 19 mov %i1, %o0 return result; } 2004e2c: 81 c7 e0 08 ret 2004e30: 81 e8 00 00 restore 02012514 : int tcgetattr( int fd, struct termios *tp ) { 2012514: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 2012518: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 201251c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2012520: 40 00 0e fc call 2016110 <== NOT EXECUTED 2012524: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2012528: 01 00 00 00 nop 0201252c : int tcsetattr( int fd, int opt, struct termios *tp ) { 201252c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED switch (opt) { 2012530: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2012534: 02 80 00 10 be 2012574 <== NOT EXECUTED 2012538: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED 201253c: 02 80 00 08 be 201255c <== NOT EXECUTED 2012540: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 2012544: 40 00 11 72 call 2016b0c <__errno> <== NOT EXECUTED 2012548: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201254c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2012550: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2012554: 81 c7 e0 08 ret <== NOT EXECUTED 2012558: 81 e8 00 00 restore <== NOT EXECUTED case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 201255c: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2012560: 40 00 0e ec call 2016110 <== NOT EXECUTED 2012564: 94 10 20 00 clr %o2 <== NOT EXECUTED 2012568: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201256c: 26 80 00 04 bl,a 201257c <== NOT EXECUTED 2012570: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 2012574: 40 00 0e e7 call 2016110 <== NOT EXECUTED 2012578: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED } } 201257c: 81 c7 e0 08 ret <== NOT EXECUTED 2012580: 81 e8 00 00 restore <== NOT EXECUTED 0200548c : #include long telldir( DIR *dirp ) { 200548c: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; if ( !dirp ) 2005490: 80 a6 20 00 cmp %i0, 0 2005494: 32 80 00 08 bne,a 20054b4 2005498: f0 06 00 00 ld [ %i0 ], %i0 rtems_set_errno_and_return_minus_one( EBADF ); 200549c: 40 00 2e e2 call 2011024 <__errno> <== NOT EXECUTED 20054a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20054a4: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 20054a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20054ac: 81 c7 e0 08 ret 20054b0: 81 e8 00 00 restore /* * Get the file control block structure associated with the * file descriptor */ iop = rtems_libio_iop( dirp->dd_fd ); 20054b4: 03 00 80 60 sethi %hi(0x2018000), %g1 20054b8: c2 00 63 bc ld [ %g1 + 0x3bc ], %g1 ! 20183bc 20054bc: 80 a6 00 01 cmp %i0, %g1 20054c0: 1a 80 00 0b bcc 20054ec 20054c4: 03 00 80 65 sethi %hi(0x2019400), %g1 20054c8: c6 00 62 40 ld [ %g1 + 0x240 ], %g3 ! 2019640 20054cc: 85 2e 20 02 sll %i0, 2, %g2 20054d0: 83 2e 20 04 sll %i0, 4, %g1 20054d4: 82 20 40 02 sub %g1, %g2, %g1 20054d8: 82 00 40 18 add %g1, %i0, %g1 20054dc: 83 28 60 02 sll %g1, 2, %g1 if (iop == NULL) 20054e0: 82 80 40 03 addcc %g1, %g3, %g1 20054e4: 32 bf ff f2 bne,a 20054ac 20054e8: f0 00 60 08 ld [ %g1 + 8 ], %i0 assert(0); 20054ec: 11 00 80 5e sethi %hi(0x2017800), %o0 <== NOT EXECUTED 20054f0: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED 20054f4: 90 12 20 f0 or %o0, 0xf0, %o0 <== NOT EXECUTED 20054f8: 15 00 80 5e sethi %hi(0x2017800), %o2 <== NOT EXECUTED 20054fc: 7f ff f7 3d call 20031f0 <__assert> <== NOT EXECUTED 2005500: 94 12 a1 40 or %o2, 0x140, %o2 ! 2017940 <== NOT EXECUTED 2005504: 82 10 20 00 clr %g1 <== NOT EXECUTED return (long)( iop->offset ); 2005508: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED } 200550c: 81 c7 e0 08 ret <== NOT EXECUTED 2005510: 81 e8 00 00 restore <== NOT EXECUTED 0200b1ec : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 200b1ec: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 200b1f0: 80 a6 20 01 cmp %i0, 1 200b1f4: 12 80 00 11 bne 200b238 200b1f8: 80 a6 60 00 cmp %i1, 0 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 200b1fc: 02 80 00 13 be 200b248 200b200: 05 00 80 8e sethi %hi(0x2023800), %g2 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 200b204: c2 06 40 00 ld [ %i1 ], %g1 200b208: 82 00 7f ff add %g1, -1, %g1 200b20c: 80 a0 60 01 cmp %g1, 1 200b210: 18 80 00 0a bgu 200b238 200b214: 01 00 00 00 nop ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 200b218: c2 06 60 04 ld [ %i1 + 4 ], %g1 200b21c: 80 a0 60 00 cmp %g1, 0 200b220: 02 80 00 06 be 200b238 200b224: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 200b228: 82 00 7f ff add %g1, -1, %g1 200b22c: 80 a0 60 1f cmp %g1, 0x1f 200b230: 08 80 00 06 bleu 200b248 200b234: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 200b238: 40 00 28 d7 call 2015594 <__errno> <== NOT EXECUTED 200b23c: 01 00 00 00 nop <== NOT EXECUTED 200b240: 10 80 00 10 b 200b280 <== NOT EXECUTED 200b244: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b248: c2 00 a1 50 ld [ %g2 + 0x150 ], %g1 200b24c: 82 00 60 01 inc %g1 200b250: c2 20 a1 50 st %g1, [ %g2 + 0x150 ] * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 200b254: 21 00 80 8f sethi %hi(0x2023c00), %l0 200b258: 40 00 0a b6 call 200dd30 <_Objects_Allocate> 200b25c: 90 14 21 1c or %l0, 0x11c, %o0 ! 2023d1c <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 200b260: b0 92 20 00 orcc %o0, 0, %i0 200b264: 12 80 00 0a bne 200b28c 200b268: 82 10 20 02 mov 2, %g1 _Thread_Enable_dispatch(); 200b26c: 7f ff fe d1 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200b270: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 200b274: 40 00 28 c8 call 2015594 <__errno> <== NOT EXECUTED 200b278: 01 00 00 00 nop <== NOT EXECUTED 200b27c: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 200b280: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b284: 81 c7 e0 08 ret <== NOT EXECUTED 200b288: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 200b28c: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 200b290: 03 00 80 8e sethi %hi(0x2023800), %g1 200b294: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 2023a30 <_Thread_Executing> if ( evp != NULL ) { 200b298: 80 a6 60 00 cmp %i1, 0 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; 200b29c: c2 00 60 08 ld [ %g1 + 8 ], %g1 if ( evp != NULL ) { 200b2a0: 02 80 00 08 be 200b2c0 200b2a4: c2 26 20 38 st %g1, [ %i0 + 0x38 ] ptimer->inf.sigev_notify = evp->sigev_notify; ptimer->inf.sigev_signo = evp->sigev_signo; ptimer->inf.sigev_value = evp->sigev_value; 200b2a8: c2 06 60 08 ld [ %i1 + 8 ], %g1 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; if ( evp != NULL ) { ptimer->inf.sigev_notify = evp->sigev_notify; 200b2ac: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 200b2b0: c6 06 60 04 ld [ %i1 + 4 ], %g3 ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; ptimer->thread_id = _Thread_Executing->Object.id; if ( evp != NULL ) { ptimer->inf.sigev_notify = evp->sigev_notify; 200b2b4: c4 26 20 40 st %g2, [ %i0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 200b2b8: c6 26 20 44 st %g3, [ %i0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 200b2bc: c2 26 20 48 st %g1, [ %i0 + 0x48 ] ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200b2c0: c2 06 20 08 ld [ %i0 + 8 ], %g1 200b2c4: 94 10 00 18 mov %i0, %o2 200b2c8: 90 14 21 1c or %l0, 0x11c, %o0 } ptimer->overrun = 0; 200b2cc: c0 26 20 68 clr [ %i0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 200b2d0: c0 26 20 5c clr [ %i0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 200b2d4: c0 26 20 60 clr [ %i0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 200b2d8: c0 26 20 54 clr [ %i0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 200b2dc: c0 26 20 58 clr [ %i0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200b2e0: c0 26 20 18 clr [ %i0 + 0x18 ] the_watchdog->routine = routine; 200b2e4: c0 26 20 2c clr [ %i0 + 0x2c ] the_watchdog->id = id; 200b2e8: c0 26 20 30 clr [ %i0 + 0x30 ] the_watchdog->user_data = user_data; 200b2ec: c0 26 20 34 clr [ %i0 + 0x34 ] 200b2f0: 13 00 00 3f sethi %hi(0xfc00), %o1 200b2f4: 92 12 63 ff or %o1, 0x3ff, %o1 ! ffff 200b2f8: 7f ff fe 9c call 200ad68 <_Objects_Set_local_object> 200b2fc: 92 08 40 09 and %g1, %o1, %o1 _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open(&_POSIX_Timer_Information, &ptimer->Object, (Objects_Name) 0); *timerid = ptimer->Object.id; 200b300: c2 06 20 08 ld [ %i0 + 8 ], %g1 if ( information->is_string ) /* _Objects_Copy_name_string( name, the_object->name ); */ the_object->name = name; else /* _Objects_Copy_name_raw( name, the_object->name, information->name_length ); */ the_object->name = name; 200b304: c0 26 20 0c clr [ %i0 + 0xc ] 200b308: c2 26 80 00 st %g1, [ %i2 ] _Thread_Enable_dispatch(); 200b30c: 7f ff fe a9 call 200adb0 <_Thread_Enable_dispatch> 200b310: b0 10 20 00 clr %i0 return 0; } 200b314: 81 c7 e0 08 ret 200b318: 81 e8 00 00 restore 0200aeb8 : */ int timer_delete( timer_t timerid ) { 200aeb8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED * because rtems_timer_delete stops the timer before deleting it. */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 200aebc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200aec0: 7f ff ff b4 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200aec4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200aec8: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200aecc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200aed0: 02 80 00 0b be 200aefc <== NOT EXECUTED 200aed4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200aed8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200aedc: 18 80 00 06 bgu 200aef4 <== NOT EXECUTED 200aee0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 200aee4: 40 00 29 ac call 2015594 <__errno> <== NOT EXECUTED 200aee8: 01 00 00 00 nop <== NOT EXECUTED 200aeec: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200aef0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200aef4: 81 c7 e0 08 ret <== NOT EXECUTED 200aef8: 81 e8 00 00 restore <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200aefc: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED 200af00: 94 10 20 00 clr %o2 <== NOT EXECUTED 200af04: 21 00 80 8f sethi %hi(0x2023c00), %l0 <== NOT EXECUTED 200af08: 13 00 00 3f sethi %hi(0xfc00), %o1 <== NOT EXECUTED 200af0c: 90 14 21 1c or %l0, 0x11c, %o0 <== NOT EXECUTED 200af10: 92 12 63 ff or %o1, 0x3ff, %o1 <== NOT EXECUTED 200af14: 7f ff ff 95 call 200ad68 <_Objects_Set_local_object> <== NOT EXECUTED 200af18: 92 08 40 09 and %g1, %o1, %o1 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); ptimer->state = POSIX_TIMER_STATE_FREE; 200af1c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED /* _Objects_Clear_name( the_object->name, information->name_length ); */ the_object->name = 0; 200af20: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED 200af24: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 200af28: 40 00 17 42 call 2010c30 <_Watchdog_Remove> <== NOT EXECUTED 200af2c: 90 06 20 10 add %i0, 0x10, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Timer_Free ( POSIX_Timer_Control *the_timer ) { _Objects_Free( &_POSIX_Timer_Information, &the_timer->Object ); 200af30: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200af34: 90 14 21 1c or %l0, 0x11c, %o0 <== NOT EXECUTED 200af38: 40 00 0c 80 call 200e138 <_Objects_Free> <== NOT EXECUTED 200af3c: b0 10 20 00 clr %i0 <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 200af40: 7f ff ff 9c call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200af44: 01 00 00 00 nop <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 200af48: 81 c7 e0 08 ret <== NOT EXECUTED 200af4c: 81 e8 00 00 restore <== NOT EXECUTED 0200ade4 : */ int timer_getoverrun( timer_t timerid ) { 200ade4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); 200ade8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200adec: 7f ff ff e9 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200adf0: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200adf4: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200adf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200adfc: 22 80 00 0b be,a 200ae28 <== NOT EXECUTED 200ae00: f0 02 20 68 ld [ %o0 + 0x68 ], %i0 <== NOT EXECUTED 200ae04: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ae08: 18 80 00 06 bgu 200ae20 <== NOT EXECUTED 200ae0c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 200ae10: 40 00 29 e1 call 2015594 <__errno> <== NOT EXECUTED 200ae14: 01 00 00 00 nop <== NOT EXECUTED 200ae18: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200ae1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200ae20: 81 c7 e0 08 ret <== NOT EXECUTED 200ae24: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: overrun = ptimer->overrun; ptimer->overrun = 0; _Thread_Enable_dispatch(); 200ae28: 7f ff ff e2 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200ae2c: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED return overrun; } return -1; /* unreached - only to remove warnings */ } 200ae30: 81 c7 e0 08 ret <== NOT EXECUTED 200ae34: 81 e8 00 00 restore <== NOT EXECUTED 0200ae38 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 200ae38: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; /* Reads the current time */ _TOD_Get( ¤t_time ); 200ae3c: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 200ae40: 40 00 0a 01 call 200d644 <_TOD_Get> <== NOT EXECUTED 200ae44: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); 200ae48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200ae4c: 7f ff ff d1 call 200ad90 <_POSIX_Timer_Get> <== NOT EXECUTED 200ae50: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED switch ( location ) { 200ae54: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200ae58: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ae5c: 02 80 00 0b be 200ae88 <== NOT EXECUTED 200ae60: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 200ae64: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200ae68: 18 80 00 06 bgu 200ae80 <== NOT EXECUTED 200ae6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); #endif case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 200ae70: 40 00 29 c9 call 2015594 <__errno> <== NOT EXECUTED 200ae74: 01 00 00 00 nop <== NOT EXECUTED 200ae78: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200ae7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200ae80: 81 c7 e0 08 ret <== NOT EXECUTED 200ae84: 81 e8 00 00 restore <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ _Timespec_Subtract( 200ae88: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200ae8c: 90 02 20 5c add %o0, 0x5c, %o0 <== NOT EXECUTED 200ae90: 40 00 16 2b call 201073c <_Timespec_Subtract> <== NOT EXECUTED 200ae94: 94 06 60 08 add %i1, 8, %o2 <== NOT EXECUTED &ptimer->timer_data.it_value, ¤t_time, &value->it_value ); value->it_interval = ptimer->timer_data.it_interval; 200ae98: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200ae9c: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED 200aea0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); 200aea4: b0 10 20 00 clr %i0 <== NOT EXECUTED 200aea8: 7f ff ff c2 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200aeac: c2 26 60 04 st %g1, [ %i1 + 4 ] <== NOT EXECUTED return 0; } return -1; /* unreached - only to remove warnings */ } 200aeb0: 81 c7 e0 08 ret <== NOT EXECUTED 200aeb4: 81 e8 00 00 restore <== NOT EXECUTED 0200afbc : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 200afbc: 9d e3 bf 90 save %sp, -112, %sp POSIX_Timer_Control *ptimer; Objects_Locations location; boolean activated; if ( value == NULL ) { 200afc0: 80 a6 a0 00 cmp %i2, 0 200afc4: 02 80 00 0c be 200aff4 200afc8: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); } /* First, it verifies if the structure "value" is correct */ if ( ( value->it_value.tv_nsec > TOD_NANOSECONDS_PER_SECOND ) || 200afcc: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 200afd0: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 200afd4: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 200afd8: 80 a0 80 01 cmp %g2, %g1 200afdc: 18 80 00 06 bgu 200aff4 200afe0: 80 a6 60 04 cmp %i1, 4 rtems_set_errno_and_return_minus_one( EINVAL ); } /* XXX check for seconds in the past */ if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 200afe4: 02 80 00 0a be 200b00c 200afe8: 80 a6 60 00 cmp %i1, 0 200afec: 02 80 00 08 be 200b00c 200aff0: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); 200aff4: 40 00 29 68 call 2015594 <__errno> <== NOT EXECUTED 200aff8: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200affc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200b000: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b004: 81 c7 e0 08 ret <== NOT EXECUTED 200b008: 81 e8 00 00 restore <== NOT EXECUTED /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 200b00c: 7f ff ff 61 call 200ad90 <_POSIX_Timer_Get> 200b010: 92 07 bf f4 add %fp, -12, %o1 switch ( location ) { 200b014: c2 07 bf f4 ld [ %fp + -12 ], %g1 /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 200b018: a0 10 00 08 mov %o0, %l0 switch ( location ) { 200b01c: 80 a0 60 00 cmp %g1, 0 200b020: 12 bf ff f9 bne 200b004 200b024: b0 10 3f ff mov -1, %i0 case OBJECTS_ERROR: return -1; case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( value->it_value.tv_sec == 0 && value->it_value.tv_nsec == 0 ) { 200b028: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200b02c: 80 a0 60 00 cmp %g1, 0 200b030: 12 80 00 15 bne 200b084 200b034: 80 a6 60 00 cmp %i1, 0 200b038: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED 200b03c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b040: 12 80 00 11 bne 200b084 <== NOT EXECUTED 200b044: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 200b048: 40 00 16 fa call 2010c30 <_Watchdog_Remove> <== NOT EXECUTED 200b04c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 200b050: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 200b054: 02 80 00 05 be 200b068 <== NOT EXECUTED 200b058: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED *ovalue = ptimer->timer_data; 200b05c: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 200b060: 40 00 2b 33 call 2015d2c <== NOT EXECUTED 200b064: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = *value; 200b068: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 200b06c: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 200b070: 40 00 2b 2f call 2015d2c <== NOT EXECUTED 200b074: 90 04 20 54 add %l0, 0x54, %o0 <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 200b078: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 200b07c: 10 80 00 31 b 200b140 <== NOT EXECUTED 200b080: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* absolute or relative? */ switch (flags) { 200b084: 02 80 00 15 be 200b0d8 200b088: 80 a6 60 04 cmp %i1, 4 200b08c: 12 80 00 31 bne 200b150 <== NOT EXECUTED 200b090: 11 00 80 8e sethi %hi(0x2023800), %o0 <== NOT EXECUTED case TIMER_ABSTIME: /* The fire time is absolute: use "rtems_time_fire_when" */ /* First, it converts from struct itimerspec to rtems_time_of_day */ _Watchdog_Initialize( 200b094: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200b098: c0 24 20 18 clr [ %l0 + 0x18 ] <== NOT EXECUTED the_watchdog->routine = routine; the_watchdog->id = id; 200b09c: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200b0a0: 03 00 80 8e sethi %hi(0x2023800), %g1 <== NOT EXECUTED 200b0a4: c4 00 62 0c ld [ %g1 + 0x20c ], %g2 ! 2023a0c <_TOD_Now> <== NOT EXECUTED 200b0a8: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 200b0ac: e0 24 20 34 st %l0, [ %l0 + 0x34 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200b0b0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 200b0b4: c2 24 20 1c st %g1, [ %l0 + 0x1c ] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200b0b8: 03 00 80 2c sethi %hi(0x200b000), %g1 <== NOT EXECUTED 200b0bc: 82 10 61 70 or %g1, 0x170, %g1 ! 200b170 <_POSIX_Timer_TSR> <== NOT EXECUTED 200b0c0: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 200b0c4: 90 12 22 44 or %o0, 0x244, %o0 <== NOT EXECUTED 200b0c8: 40 00 16 82 call 2010ad0 <_Watchdog_Insert> <== NOT EXECUTED 200b0cc: 92 04 20 10 add %l0, 0x10, %o1 <== NOT EXECUTED return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 200b0d0: 10 80 00 0f b 200b10c <== NOT EXECUTED 200b0d4: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED break; /* The fire time is relative: use "rtems_time_fire_after" */ case POSIX_TIMER_RELATIVE: /* First, convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_value ); 200b0d8: 40 00 15 ad call 201078c <_Timespec_To_ticks> 200b0dc: 90 06 a0 08 add %i2, 8, %o0 activated = _Watchdog_Insert_ticks_helper( 200b0e0: d4 04 20 08 ld [ %l0 + 8 ], %o2 break; /* The fire time is relative: use "rtems_time_fire_after" */ case POSIX_TIMER_RELATIVE: /* First, convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_value ); 200b0e4: 92 10 00 08 mov %o0, %o1 200b0e8: d0 24 20 64 st %o0, [ %l0 + 0x64 ] activated = _Watchdog_Insert_ticks_helper( 200b0ec: 17 00 80 2c sethi %hi(0x200b000), %o3 200b0f0: 90 04 20 10 add %l0, 0x10, %o0 200b0f4: 96 12 e1 70 or %o3, 0x170, %o3 200b0f8: 7f ff ff 96 call 200af50 <_Watchdog_Insert_ticks_helper> 200b0fc: 98 10 00 10 mov %l0, %o4 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 200b100: 80 a2 20 00 cmp %o0, 0 200b104: 02 80 00 0f be 200b140 200b108: 80 a6 e0 00 cmp %i3, 0 return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 200b10c: 02 80 00 05 be 200b120 200b110: 90 10 00 1b mov %i3, %o0 *ovalue = ptimer->timer_data; 200b114: 92 04 20 54 add %l0, 0x54, %o1 <== NOT EXECUTED 200b118: 40 00 2b 05 call 2015d2c <== NOT EXECUTED 200b11c: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED ptimer->timer_data = *value; 200b120: 92 10 00 1a mov %i2, %o1 200b124: 94 10 20 10 mov 0x10, %o2 200b128: 40 00 2b 01 call 2015d2c 200b12c: 90 04 20 54 add %l0, 0x54, %o0 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 200b130: 82 10 20 03 mov 3, %g1 _TOD_Get( &ptimer->time ); 200b134: 90 04 20 6c add %l0, 0x6c, %o0 200b138: 40 00 09 43 call 200d644 <_TOD_Get> 200b13c: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] _Thread_Enable_dispatch(); 200b140: 7f ff ff 1c call 200adb0 <_Thread_Enable_dispatch> 200b144: b0 10 20 00 clr %i0 200b148: 81 c7 e0 08 ret 200b14c: 81 e8 00 00 restore return 0; } _Thread_Enable_dispatch(); 200b150: 7f ff ff 18 call 200adb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 200b154: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200b158: 40 00 29 0f call 2015594 <__errno> <== NOT EXECUTED 200b15c: 01 00 00 00 nop <== NOT EXECUTED 200b160: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200b164: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return -1; /* unreached - only to remove warnings */ } 200b168: 81 c7 e0 08 ret <== NOT EXECUTED 200b16c: 81 e8 00 00 restore <== NOT EXECUTED 02016c38 : */ char *ttyname( int fd ) { 2016c38: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 2016c3c: 21 00 80 de sethi %hi(0x2037800), %l0 <== NOT EXECUTED 2016c40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2016c44: 94 10 24 06 mov 0x406, %o2 <== NOT EXECUTED 2016c48: 92 14 20 80 or %l0, 0x80, %o1 <== NOT EXECUTED 2016c4c: 7f ff ff ba call 2016b34 <== NOT EXECUTED 2016c50: b0 14 20 80 or %l0, 0x80, %i0 <== NOT EXECUTED 2016c54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016c58: 32 80 00 02 bne,a 2016c60 <== NOT EXECUTED 2016c5c: b0 10 20 00 clr %i0 <== NOT EXECUTED return ttyname_buf; return NULL; } 2016c60: 81 c7 e0 08 ret <== NOT EXECUTED 2016c64: 81 e8 00 00 restore <== NOT EXECUTED 02016b34 : int ttyname_r( int fd, char *name, int namesize ) { 2016b34: 9d e3 be d0 save %sp, -304, %sp <== NOT EXECUTED DIR *dp; struct stat dsb; char *rval; /* Must be a terminal. */ if (tcgetattr (fd, &tty) < 0) 2016b38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2016b3c: 7f ff ff e2 call 2016ac4 <== NOT EXECUTED 2016b40: 92 07 bf d4 add %fp, -44, %o1 <== NOT EXECUTED 2016b44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016b48: 06 80 00 14 bl 2016b98 <== NOT EXECUTED 2016b4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) 2016b50: 40 00 23 6f call 201f90c <== NOT EXECUTED 2016b54: 92 07 bf 80 add %fp, -128, %o1 <== NOT EXECUTED 2016b58: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016b5c: 12 80 00 0f bne 2016b98 <== NOT EXECUTED 2016b60: c2 17 bf 8c lduh [ %fp + -116 ], %g1 <== NOT EXECUTED 2016b64: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED 2016b68: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 2016b6c: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED 2016b70: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2016b74: 12 80 00 09 bne 2016b98 <== NOT EXECUTED 2016b78: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED for (rval = NULL; (dirp = readdir (dp)) != NULL ;) { if (dirp->d_ino != sb.st_ino) continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 2016b7c: a0 06 60 05 add %i1, 5, %l0 <== NOT EXECUTED /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) 2016b80: 90 12 21 28 or %o0, 0x128, %o0 <== NOT EXECUTED 2016b84: 7f ff fe 90 call 20165c4 <== NOT EXECUTED 2016b88: a2 07 bf 30 add %fp, -208, %l1 <== NOT EXECUTED 2016b8c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2016b90: 12 80 00 20 bne 2016c10 <== NOT EXECUTED 2016b94: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); 2016b98: 40 00 2c 79 call 2021d7c <__errno> <== NOT EXECUTED 2016b9c: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2016ba0: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 2016ba4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016ba8: 81 c7 e0 08 ret <== NOT EXECUTED 2016bac: 81 e8 00 00 restore <== NOT EXECUTED for (rval = NULL; (dirp = readdir (dp)) != NULL ;) { if (dirp->d_ino != sb.st_ino) 2016bb0: c2 07 bf 88 ld [ %fp + -120 ], %g1 <== NOT EXECUTED 2016bb4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2016bb8: 12 80 00 16 bne 2016c10 <== NOT EXECUTED 2016bbc: 92 02 20 0c add %o0, 0xc, %o1 <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 2016bc0: 40 00 3b 75 call 2025994 <== NOT EXECUTED 2016bc4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 2016bc8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2016bcc: 7f ff ba 05 call 20053e0 <== NOT EXECUTED 2016bd0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2016bd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016bd8: 12 80 00 0e bne 2016c10 <== NOT EXECUTED 2016bdc: c4 07 bf 80 ld [ %fp + -128 ], %g2 <== NOT EXECUTED 2016be0: c2 07 bf 30 ld [ %fp + -208 ], %g1 <== NOT EXECUTED 2016be4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2016be8: 12 80 00 0a bne 2016c10 <== NOT EXECUTED 2016bec: c4 07 bf 84 ld [ %fp + -124 ], %g2 <== NOT EXECUTED 2016bf0: c2 07 bf 34 ld [ %fp + -204 ], %g1 <== NOT EXECUTED 2016bf4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2016bf8: 12 80 00 06 bne 2016c10 <== NOT EXECUTED 2016bfc: c4 07 bf 88 ld [ %fp + -120 ], %g2 <== NOT EXECUTED 2016c00: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED 2016c04: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2016c08: 02 80 00 08 be 2016c28 <== NOT EXECUTED 2016c0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) rtems_set_errno_and_return_minus_one(EBADF); for (rval = NULL; (dirp = readdir (dp)) != NULL ;) 2016c10: 7f ff ff 23 call 201689c <== NOT EXECUTED 2016c14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2016c18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2016c1c: 32 bf ff e5 bne,a 2016bb0 <== NOT EXECUTED 2016c20: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 2016c24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2016c28: 7f ff f9 d1 call 201536c <== NOT EXECUTED 2016c2c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2016c30: 81 c7 e0 08 ret <== NOT EXECUTED 2016c34: 81 e8 00 00 restore <== NOT EXECUTED 02016c84 : #include int unlink( const char *path ) { 2016c84: 9d e3 bf 88 save %sp, -120, %sp /* * Get the node to be unlinked. */ result = rtems_filesystem_evaluate_path( path, 0, &loc, FALSE ); 2016c88: 92 10 20 00 clr %o1 2016c8c: 90 10 00 18 mov %i0, %o0 2016c90: a0 07 bf e8 add %fp, -24, %l0 2016c94: 96 10 20 00 clr %o3 2016c98: 7f ff b3 ff call 2003c94 2016c9c: 94 10 00 10 mov %l0, %o2 if ( result != 0 ) 2016ca0: 80 a2 20 00 cmp %o0, 0 2016ca4: 32 80 00 17 bne,a 2016d00 2016ca8: b0 10 3f ff mov -1, %i0 return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 2016cac: 90 10 20 02 mov 2, %o0 2016cb0: 7f ff b3 cc call 2003be0 2016cb4: 92 10 00 10 mov %l0, %o1 if (result != 0 && errno != ENOTSUP) { 2016cb8: 80 a2 20 00 cmp %o0, 0 2016cbc: 02 80 00 13 be 2016d08 2016cc0: c2 07 bf f0 ld [ %fp + -16 ], %g1 2016cc4: 40 00 2c 2e call 2021d7c <__errno> <== NOT EXECUTED 2016cc8: 01 00 00 00 nop <== NOT EXECUTED 2016ccc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2016cd0: 80 a0 60 86 cmp %g1, 0x86 <== NOT EXECUTED 2016cd4: 02 80 00 0d be 2016d08 <== NOT EXECUTED 2016cd8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2016cdc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016ce0: 02 80 00 08 be 2016d00 <== NOT EXECUTED 2016ce4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2016ce8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2016cec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016cf0: 02 80 00 04 be 2016d00 <== NOT EXECUTED 2016cf4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016cf8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2016cfc: 01 00 00 00 nop <== NOT EXECUTED 2016d00: 81 c7 e0 08 ret 2016d04: 81 e8 00 00 restore return -1; } if ( !loc.ops->node_type_h ) { 2016d08: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 2016d0c: 80 a0 a0 00 cmp %g2, 0 2016d10: 12 80 00 07 bne 2016d2c 2016d14: a0 07 bf e8 add %fp, -24, %l0 rtems_filesystem_freenode( &loc ); 2016d18: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2016d1c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016d20: 12 80 00 1d bne 2016d94 <== NOT EXECUTED 2016d24: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED 2016d28: 30 80 00 1d b,a 2016d9c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 2016d2c: 9f c0 80 00 call %g2 2016d30: 90 10 00 10 mov %l0, %o0 2016d34: 80 a2 20 01 cmp %o0, 1 2016d38: 12 80 00 0f bne 2016d74 2016d3c: c2 07 bf f0 ld [ %fp + -16 ], %g1 rtems_filesystem_freenode( &loc ); 2016d40: 80 a0 60 00 cmp %g1, 0 2016d44: 02 80 00 08 be 2016d64 2016d48: 01 00 00 00 nop 2016d4c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2016d50: 80 a0 60 00 cmp %g1, 0 2016d54: 02 80 00 04 be 2016d64 2016d58: 01 00 00 00 nop 2016d5c: 9f c0 40 00 call %g1 2016d60: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( EISDIR ); 2016d64: 40 00 2c 06 call 2021d7c <__errno> 2016d68: b0 10 3f ff mov -1, %i0 2016d6c: 10 80 00 0f b 2016da8 2016d70: 82 10 20 15 mov 0x15, %g1 } if ( !loc.ops->unlink_h ) { 2016d74: c4 00 60 0c ld [ %g1 + 0xc ], %g2 2016d78: 80 a0 a0 00 cmp %g2, 0 2016d7c: 12 80 00 0e bne 2016db4 2016d80: 01 00 00 00 nop rtems_filesystem_freenode( &loc ); 2016d84: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2016d88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2016d8c: 02 80 00 04 be 2016d9c <== NOT EXECUTED 2016d90: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2016d94: 9f c0 40 00 call %g1 <== NOT EXECUTED 2016d98: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2016d9c: 40 00 2b f8 call 2021d7c <__errno> <== NOT EXECUTED 2016da0: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2016da4: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2016da8: c2 22 00 00 st %g1, [ %o0 ] 2016dac: 81 c7 e0 08 ret 2016db0: 81 e8 00 00 restore } result = (*loc.ops->unlink_h)( &loc ); 2016db4: 9f c0 80 00 call %g2 2016db8: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2016dbc: c2 07 bf f0 ld [ %fp + -16 ], %g1 2016dc0: 80 a0 60 00 cmp %g1, 0 2016dc4: 02 bf ff cf be 2016d00 2016dc8: b0 10 00 08 mov %o0, %i0 2016dcc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2016dd0: 80 a0 60 00 cmp %g1, 0 2016dd4: 02 80 00 06 be 2016dec 2016dd8: 01 00 00 00 nop 2016ddc: 9f c0 40 00 call %g1 2016de0: 90 10 00 10 mov %l0, %o0 2016de4: 81 c7 e0 08 ret 2016de8: 81 e8 00 00 restore return result; } 2016dec: 81 c7 e0 08 ret <== NOT EXECUTED 2016df0: 81 e8 00 00 restore <== NOT EXECUTED 02006c90 : */ int unmount( const char *path ) { 2006c90: 9d e3 bf 88 save %sp, -120, %sp * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, 0x0, &loc, TRUE ) ) 2006c94: 92 10 20 00 clr %o1 2006c98: a2 07 bf e8 add %fp, -24, %l1 2006c9c: 90 10 00 18 mov %i0, %o0 2006ca0: 94 10 00 11 mov %l1, %o2 2006ca4: 7f ff f1 88 call 20032c4 2006ca8: 96 10 20 01 mov 1, %o3 2006cac: 80 a2 20 00 cmp %o0, 0 2006cb0: 12 80 00 6a bne 2006e58 2006cb4: e0 07 bf f4 ld [ %fp + -12 ], %l0 /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 2006cb8: c2 07 bf e8 ld [ %fp + -24 ], %g1 2006cbc: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 2006cc0: 80 a0 80 01 cmp %g2, %g1 2006cc4: 02 80 00 0f be 2006d00 2006cc8: c6 07 bf f0 ld [ %fp + -16 ], %g3 rtems_filesystem_freenode( &loc ); 2006ccc: 80 a0 e0 00 cmp %g3, 0 2006cd0: 02 80 00 08 be 2006cf0 2006cd4: 01 00 00 00 nop 2006cd8: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2006cdc: 80 a0 60 00 cmp %g1, 0 2006ce0: 02 80 00 04 be 2006cf0 2006ce4: 01 00 00 00 nop 2006ce8: 9f c0 40 00 call %g1 2006cec: 90 10 00 11 mov %l1, %o0 rtems_set_errno_and_return_minus_one( EACCES ); 2006cf0: 40 00 27 c9 call 2010c14 <__errno> 2006cf4: 01 00 00 00 nop 2006cf8: 10 80 00 21 b 2006d7c 2006cfc: 82 10 20 0d mov 0xd, %g1 ! d /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 2006d00: 80 a0 e0 00 cmp %g3, 0 2006d04: 22 80 00 09 be,a 2006d28 2006d08: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 2006d0c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2006d10: 80 a0 60 00 cmp %g1, 0 2006d14: 22 80 00 05 be,a 2006d28 2006d18: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 2006d1c: 9f c0 40 00 call %g1 2006d20: 90 10 00 11 mov %l1, %o0 /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 2006d24: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006d28: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 2006d2c: 80 a0 60 00 cmp %g1, 0 2006d30: 02 80 00 07 be 2006d4c 2006d34: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 2006d38: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2006d3c: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 2006d40: 80 a0 60 00 cmp %g1, 0 2006d44: 32 80 00 06 bne,a 2006d5c 2006d48: 03 00 80 64 sethi %hi(0x2019000), %g1 rtems_set_errno_and_return_minus_one( ENOTSUP ); 2006d4c: 40 00 27 b2 call 2010c14 <__errno> <== NOT EXECUTED 2006d50: 01 00 00 00 nop <== NOT EXECUTED 2006d54: 10 80 00 0a b 2006d7c <== NOT EXECUTED 2006d58: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED * that made the current node thread based instead * of system based? I thought it was but it doesn't * look like it in this version. */ if ( rtems_filesystem_current.mt_entry == mt_entry ) 2006d5c: c2 00 60 70 ld [ %g1 + 0x70 ], %g1 2006d60: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 2006d64: 80 a0 40 10 cmp %g1, %l0 2006d68: 12 80 00 08 bne 2006d88 2006d6c: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EBUSY ); 2006d70: 40 00 27 a9 call 2010c14 <__errno> 2006d74: 01 00 00 00 nop 2006d78: 82 10 20 10 mov 0x10, %g1 ! 10 2006d7c: c2 22 00 00 st %g1, [ %o0 ] 2006d80: 81 c7 e0 08 ret 2006d84: 91 e8 3f ff restore %g0, -1, %o0 /* * Verify there are no file systems below the path specified */ if ( file_systems_below_this_mountpoint( path, fs_root_loc, mt_entry ) != 0 ) 2006d88: 92 04 20 18 add %l0, 0x18, %o1 2006d8c: 7f ff ff b1 call 2006c50 2006d90: 94 10 00 10 mov %l0, %o2 2006d94: 80 a2 20 00 cmp %o0, 0 2006d98: 12 bf ff f6 bne 2006d70 2006d9c: 01 00 00 00 nop * Run the file descriptor table to determine if there are any file * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) 2006da0: 7f ff f2 23 call 200362c 2006da4: 90 10 00 10 mov %l0, %o0 2006da8: 80 a2 20 01 cmp %o0, 1 2006dac: 02 bf ff f1 be 2006d70 2006db0: 01 00 00 00 nop * Allow the file system being unmounted on to do its cleanup. * If it fails it will set the errno to the approprate value * and the fileystem will not be modified. */ if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 ) 2006db4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006db8: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 2006dbc: 9f c0 40 00 call %g1 2006dc0: 90 10 00 10 mov %l0, %o0 2006dc4: 80 a2 20 00 cmp %o0, 0 2006dc8: 12 80 00 24 bne 2006e58 2006dcc: 01 00 00 00 nop * NOTE: Fatal error is called in a case which should never happen * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ 2006dd0: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 2006dd4: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 2006dd8: 9f c0 40 00 call %g1 2006ddc: 90 10 00 10 mov %l0, %o0 2006de0: 80 a2 20 00 cmp %o0, 0 2006de4: 02 80 00 0c be 2006e14 2006de8: 01 00 00 00 nop if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 2006dec: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 2006df0: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 <== NOT EXECUTED 2006df4: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006df8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2006dfc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006e00: 02 80 00 16 be 2006e58 <== NOT EXECUTED 2006e04: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 2006e08: 40 00 05 b0 call 20084c8 <== NOT EXECUTED 2006e0c: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED 2006e10: 30 bf ff dc b,a 2006d80 <== NOT EXECUTED /* * Extract the mount table entry from the chain */ Chain_Extract( ( Chain_Node * ) mt_entry ); 2006e14: 40 00 06 78 call 20087f4 <_Chain_Extract> 2006e18: 90 10 00 10 mov %l0, %o0 /* * Free the memory node that was allocated in mount * Free the memory associated with the extracted mount table entry. */ rtems_filesystem_freenode( fs_mount_loc ); 2006e1c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006e20: 80 a0 60 00 cmp %g1, 0 2006e24: 02 80 00 09 be 2006e48 2006e28: 90 10 00 10 mov %l0, %o0 2006e2c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2006e30: 80 a0 60 00 cmp %g1, 0 2006e34: 02 80 00 05 be 2006e48 2006e38: 01 00 00 00 nop 2006e3c: 9f c0 40 00 call %g1 2006e40: 90 04 20 08 add %l0, 8, %o0 free( mt_entry ); 2006e44: 90 10 00 10 mov %l0, %o0 2006e48: 7f ff f3 14 call 2003a98 2006e4c: b0 10 20 00 clr %i0 2006e50: 81 c7 e0 08 ret 2006e54: 81 e8 00 00 restore return 0; } 2006e58: 81 c7 e0 08 ret 2006e5c: 91 e8 3f ff restore %g0, -1, %o0 02009190 : int usleep( useconds_t useconds ) { 2009190: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 2009194: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 2009198: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200919c: 7f ff e1 77 call 2001778 <.udiv> <== NOT EXECUTED 20091a0: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 20091a4: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED { struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 20091a8: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 20091ac: 40 00 5b 7c call 201ff9c <.urem> <== NOT EXECUTED 20091b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20091b4: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 20091b8: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 20091bc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 20091c0: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 20091c4: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED nanosleep( &tp, &tm ); 20091c8: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 20091cc: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED nanosleep( &tp, &tm ); 20091d0: 40 00 25 34 call 20126a0 <== NOT EXECUTED 20091d4: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 20091d8: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED 20091dc: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 20091e0: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED 20091e4: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED 20091e8: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 20091ec: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 20091f0: b1 28 60 06 sll %g1, 6, %i0 <== NOT EXECUTED 20091f4: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED 20091f8: 7f ff e1 62 call 2001780 <.div> <== NOT EXECUTED 20091fc: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED 2009200: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 2009204: 81 c7 e0 08 ret <== NOT EXECUTED 2009208: 91 ea 00 18 restore %o0, %i0, %o0 <== NOT EXECUTED 02006908 : int utime( const char *path, const struct utimbuf *times ) { 2006908: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t temp_loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, TRUE ) ) 200690c: 92 10 20 00 clr %o1 2006910: 90 10 00 18 mov %i0, %o0 2006914: a0 07 bf e8 add %fp, -24, %l0 2006918: 96 10 20 01 mov 1, %o3 200691c: 94 10 00 10 mov %l0, %o2 2006920: 7f ff f1 55 call 2002e74 2006924: b0 10 3f ff mov -1, %i0 2006928: 80 a2 20 00 cmp %o0, 0 200692c: 12 80 00 10 bne 200696c 2006930: c2 07 bf f0 ld [ %fp + -16 ], %g1 return -1; if ( !temp_loc.ops->utime_h ){ 2006934: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 2006938: 80 a0 a0 00 cmp %g2, 0 200693c: 32 80 00 0e bne,a 2006974 2006940: d4 06 60 04 ld [ %i1 + 4 ], %o2 rtems_filesystem_freenode( &temp_loc ); 2006944: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2006948: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200694c: 02 80 00 04 be 200695c <== NOT EXECUTED 2006950: 01 00 00 00 nop <== NOT EXECUTED 2006954: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006958: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 200695c: 40 00 28 84 call 2010b6c <__errno> <== NOT EXECUTED 2006960: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006964: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2006968: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200696c: 81 c7 e0 08 ret 2006970: 81 e8 00 00 restore } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 2006974: d2 06 40 00 ld [ %i1 ], %o1 2006978: 9f c0 80 00 call %g2 200697c: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &temp_loc ); 2006980: c2 07 bf f0 ld [ %fp + -16 ], %g1 2006984: 80 a0 60 00 cmp %g1, 0 2006988: 02 bf ff f9 be 200696c 200698c: b0 10 00 08 mov %o0, %i0 2006990: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2006994: 80 a0 60 00 cmp %g1, 0 2006998: 02 80 00 04 be 20069a8 200699c: 01 00 00 00 nop 20069a0: 9f c0 40 00 call %g1 20069a4: 90 10 00 10 mov %l0, %o0 return result; } 20069a8: 81 c7 e0 08 ret 20069ac: 81 e8 00 00 restore 02002d44 : | Arguments: as in printf: fmt - format string, ... - unnamed arguments. | Returns: Nothing. +--------------------------------------------------------------------------*/ void vprintk(const char *fmt, va_list ap) { 2002d44: 9d e3 bf 80 save %sp, -128, %sp for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++){ BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 2002d48: 03 00 80 5b sethi %hi(0x2016c00), %g1 printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 2002d4c: 2d 00 80 5e sethi %hi(0x2017800), %l6 for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++){ BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 2002d50: b4 10 60 00 mov %g1, %i2 if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); 2002d54: ba 07 bf e4 add %fp, -28, %i5 num = n ; } toPrint[count++] = num; 2002d58: b6 07 bf f8 add %fp, -8, %i3 for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++){ 2002d5c: 10 80 00 9f b 2002fd8 2002d60: b8 07 bf e2 add %fp, -30, %i4 lflag = 0; base = 0; sign = 0; width = 0; lead = ' '; if (*fmt == '%') 2002d64: 12 80 00 9b bne 2002fd0 2002d68: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 { fmt++; 2002d6c: b0 06 20 01 inc %i0 if (*fmt == '0' ) { 2002d70: c2 4e 00 00 ldsb [ %i0 ], %g1 2002d74: 80 a0 60 30 cmp %g1, 0x30 2002d78: 12 80 00 04 bne 2002d88 2002d7c: ae 10 20 20 mov 0x20, %l7 lead = '0'; fmt++; 2002d80: b0 06 20 01 inc %i0 2002d84: ae 10 20 30 mov 0x30, %l7 2002d88: 10 80 00 08 b 2002da8 2002d8c: a0 10 20 00 clr %l0 } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; width += (*fmt - '0'); 2002d90: 85 38 60 18 sra %g1, 0x18, %g2 fmt++; 2002d94: b0 06 20 01 inc %i0 if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; 2002d98: 83 2c 20 01 sll %l0, 1, %g1 width += (*fmt - '0'); 2002d9c: 84 00 bf d0 add %g2, -48, %g2 if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; 2002da0: 82 00 40 03 add %g1, %g3, %g1 width += (*fmt - '0'); 2002da4: a0 00 80 01 add %g2, %g1, %l0 fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 2002da8: d0 0e 00 00 ldub [ %i0 ], %o0 width *= 10; 2002dac: 87 2c 20 03 sll %l0, 3, %g3 fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 2002db0: 82 02 3f d0 add %o0, -48, %g1 2002db4: 82 08 60 ff and %g1, 0xff, %g1 2002db8: 80 a0 60 09 cmp %g1, 9 2002dbc: 08 bf ff f5 bleu 2002d90 2002dc0: 83 2a 20 18 sll %o0, 0x18, %g1 width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') 2002dc4: 83 38 60 18 sra %g1, 0x18, %g1 2002dc8: 80 a0 60 6c cmp %g1, 0x6c 2002dcc: 12 80 00 04 bne 2002ddc 2002dd0: aa 10 00 10 mov %l0, %l5 { lflag = 1; c = *++fmt; 2002dd4: b0 06 20 01 inc %i0 2002dd8: d0 0e 00 00 ldub [ %i0 ], %o0 } switch (c) 2002ddc: 83 2a 20 18 sll %o0, 0x18, %g1 2002de0: 83 38 60 18 sra %g1, 0x18, %g1 2002de4: 80 a0 60 64 cmp %g1, 0x64 2002de8: 02 80 00 2c be 2002e98 2002dec: a8 10 20 0a mov 0xa, %l4 2002df0: 14 80 00 16 bg 2002e48 2002df4: 80 a0 60 70 cmp %g1, 0x70 2002df8: 80 a0 60 4f cmp %g1, 0x4f <== NOT EXECUTED 2002dfc: 02 80 00 3e be 2002ef4 <== NOT EXECUTED 2002e00: a8 10 20 08 mov 8, %l4 <== NOT EXECUTED 2002e04: 14 80 00 09 bg 2002e28 <== NOT EXECUTED 2002e08: 80 a0 60 58 cmp %g1, 0x58 <== NOT EXECUTED 2002e0c: 80 a0 60 44 cmp %g1, 0x44 <== NOT EXECUTED 2002e10: 02 80 00 21 be 2002e94 <== NOT EXECUTED 2002e14: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED 2002e18: 12 80 00 33 bne 2002ee4 <== NOT EXECUTED 2002e1c: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 <== NOT EXECUTED { case 'o': case 'O': base = 8; sign = 0; break; 2002e20: 10 80 00 1e b 2002e98 <== NOT EXECUTED 2002e24: a8 10 20 0a mov 0xa, %l4 <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) 2002e28: 02 80 00 32 be 2002ef0 <== NOT EXECUTED 2002e2c: 80 a0 60 63 cmp %g1, 0x63 <== NOT EXECUTED 2002e30: 02 80 00 29 be 2002ed4 <== NOT EXECUTED 2002e34: 80 a0 60 55 cmp %g1, 0x55 <== NOT EXECUTED 2002e38: 12 80 00 2b bne 2002ee4 <== NOT EXECUTED 2002e3c: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 <== NOT EXECUTED { case 'o': case 'O': base = 8; sign = 0; break; case 'i': case 'I': case 'd': case 'D': base = 10; sign = 1; break; 2002e40: 10 80 00 2d b 2002ef4 <== NOT EXECUTED 2002e44: a8 10 20 0a mov 0xa, %l4 <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) 2002e48: 02 80 00 2a be 2002ef0 2002e4c: 80 a0 60 70 cmp %g1, 0x70 2002e50: 14 80 00 09 bg 2002e74 2002e54: 80 a0 60 75 cmp %g1, 0x75 2002e58: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED 2002e5c: 02 80 00 0e be 2002e94 <== NOT EXECUTED 2002e60: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED 2002e64: 12 80 00 20 bne 2002ee4 <== NOT EXECUTED 2002e68: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 <== NOT EXECUTED 2002e6c: 10 80 00 22 b 2002ef4 <== NOT EXECUTED 2002e70: a8 10 20 08 mov 8, %l4 <== NOT EXECUTED 2002e74: 02 80 00 0b be 2002ea0 2002e78: 80 a0 60 78 cmp %g1, 0x78 2002e7c: 02 80 00 1d be 2002ef0 2002e80: 80 a0 60 73 cmp %g1, 0x73 2002e84: 32 80 00 18 bne,a 2002ee4 2002e88: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 <== NOT EXECUTED case 'd': case 'D': base = 10; sign = 1; break; case 'u': case 'U': base = 10; sign = 0; break; case 'x': case 'X': base = 16; sign = 0; break; case 'p': base = 16; sign = 0; break; case 's': for (str = va_arg(ap, char *); *str; str++) 2002e8c: 10 80 00 07 b 2002ea8 2002e90: e0 06 40 00 ld [ %i1 ], %l0 lflag = 1; c = *++fmt; } switch (c) { case 'o': case 'O': base = 8; sign = 0; break; 2002e94: a8 10 20 0a mov 0xa, %l4 <== NOT EXECUTED 2002e98: 10 80 00 18 b 2002ef8 2002e9c: 84 10 20 01 mov 1, %g2 case 'i': case 'I': case 'd': case 'D': base = 10; sign = 1; break; 2002ea0: 10 80 00 15 b 2002ef4 <== NOT EXECUTED 2002ea4: a8 10 20 0a mov 0xa, %l4 <== NOT EXECUTED case 'u': case 'U': base = 10; sign = 0; break; case 'x': case 'X': base = 16; sign = 0; break; case 'p': base = 16; sign = 0; break; case 's': for (str = va_arg(ap, char *); *str; str++) 2002ea8: 10 80 00 06 b 2002ec0 2002eac: d0 4c 00 00 ldsb [ %l0 ], %o0 BSP_output_char(*str); 2002eb0: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 2002eb4: 9f c0 40 00 call %g1 2002eb8: 01 00 00 00 nop case 'd': case 'D': base = 10; sign = 1; break; case 'u': case 'U': base = 10; sign = 0; break; case 'x': case 'X': base = 16; sign = 0; break; case 'p': base = 16; sign = 0; break; case 's': for (str = va_arg(ap, char *); *str; str++) 2002ebc: d0 4c 00 00 ldsb [ %l0 ], %o0 2002ec0: 80 a2 20 00 cmp %o0, 0 2002ec4: 12 bf ff fb bne 2002eb0 2002ec8: a0 04 20 01 inc %l0 2002ecc: 10 80 00 49 b 2002ff0 2002ed0: b2 06 60 04 add %i1, 4, %i1 BSP_output_char(*str); break; case 'c': BSP_output_char(va_arg(ap, int)); 2002ed4: d0 4e 60 03 ldsb [ %i1 + 3 ], %o0 <== NOT EXECUTED 2002ed8: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 <== NOT EXECUTED 2002edc: 10 80 00 3d b 2002fd0 <== NOT EXECUTED 2002ee0: b2 06 60 04 add %i1, 4, %i1 <== NOT EXECUTED break; default: BSP_output_char(c); 2002ee4: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 2002ee8: 10 80 00 3a b 2002fd0 <== NOT EXECUTED 2002eec: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED 2002ef0: a8 10 20 10 mov 0x10, %l4 2002ef4: 84 10 20 00 clr %g2 2002ef8: 82 06 60 04 add %i1, 4, %g1 break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 2002efc: e2 06 40 00 ld [ %i1 ], %l1 { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 2002f00: 80 a0 a0 01 cmp %g2, 1 2002f04: 12 80 00 05 bne 2002f18 2002f08: b2 10 00 01 mov %g1, %i1 2002f0c: 80 a4 60 00 cmp %l1, 0 2002f10: 06 80 00 04 bl 2002f20 2002f14: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 2002f18: 10 80 00 08 b 2002f38 2002f1c: aa 10 00 10 mov %l0, %l5 BSP_output_char('-'); 2002f20: 9f c0 40 00 call %g1 <== NOT EXECUTED 2002f24: 90 10 20 2d mov 0x2d, %o0 <== NOT EXECUTED num = -num; if (maxwidth) maxwidth--; 2002f28: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2002f2c: 02 80 00 03 be 2002f38 <== NOT EXECUTED 2002f30: a2 20 00 11 neg %l1 <== NOT EXECUTED 2002f34: aa 04 3f ff add %l0, -1, %l5 <== NOT EXECUTED 2002f38: 10 80 00 08 b 2002f58 2002f3c: a6 10 20 00 clr %l3 } count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); 2002f40: 40 00 48 8b call 201516c <.umul> 2002f44: 92 10 00 14 mov %l4, %o1 2002f48: 90 24 40 08 sub %l1, %o0, %o0 2002f4c: a2 10 00 10 mov %l0, %l1 2002f50: d0 2c c0 1d stb %o0, [ %l3 + %i5 ] 2002f54: a6 10 00 12 mov %l2, %l3 num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 2002f58: 90 10 00 11 mov %l1, %o0 2002f5c: 92 10 00 14 mov %l4, %o1 2002f60: 40 00 48 bd call 2015254 <.udiv> 2002f64: a4 04 e0 01 add %l3, 1, %l2 2002f68: a0 92 20 00 orcc %o0, 0, %l0 2002f6c: 32 bf ff f5 bne,a 2002f40 2002f70: 90 10 00 10 mov %l0, %o0 toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; 2002f74: 82 06 c0 13 add %i3, %l3, %g1 for (n=maxwidth ; n > count; n-- ) 2002f78: a0 10 00 15 mov %l5, %l0 count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; 2002f7c: e2 28 7f ec stb %l1, [ %g1 + -20 ] for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); 2002f80: 10 80 00 05 b 2002f94 2002f84: a2 10 00 17 mov %l7, %l1 toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 2002f88: a0 04 3f ff add %l0, -1, %l0 BSP_output_char(lead); 2002f8c: 9f c0 40 00 call %g1 2002f90: 90 10 00 11 mov %l1, %o0 toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 2002f94: 80 a4 00 12 cmp %l0, %l2 2002f98: 18 bf ff fc bgu 2002f88 2002f9c: c2 05 a0 94 ld [ %l6 + 0x94 ], %g1 2002fa0: 82 04 bf ff add %l2, -1, %g1 2002fa4: 10 80 00 05 b 2002fb8 2002fa8: a0 07 40 01 add %i5, %g1, %l0 BSP_output_char(lead); for (n = 0; n < count; n++){ BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 2002fac: c4 05 a0 94 ld [ %l6 + 0x94 ], %g2 2002fb0: 9f c0 80 00 call %g2 2002fb4: d0 4e 80 01 ldsb [ %i2 + %g1 ], %o0 2002fb8: a0 04 3f ff add %l0, -1, %l0 toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++){ 2002fbc: 80 a4 00 1c cmp %l0, %i4 2002fc0: 32 bf ff fb bne,a 2002fac 2002fc4: c2 4c 20 01 ldsb [ %l0 + 1 ], %g1 vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 2002fc8: 10 80 00 04 b 2002fd8 2002fcc: b0 06 20 01 inc %i0 printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 2002fd0: 9f c0 40 00 call %g1 2002fd4: b0 06 20 01 inc %i0 vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 2002fd8: d0 4e 00 00 ldsb [ %i0 ], %o0 2002fdc: 80 a2 20 00 cmp %o0, 0 2002fe0: 12 bf ff 61 bne 2002d64 2002fe4: 80 a2 20 25 cmp %o0, 0x25 2002fe8: 81 c7 e0 08 ret 2002fec: 81 e8 00 00 restore 2002ff0: 10 bf ff fa b 2002fd8 2002ff4: b0 06 20 01 inc %i0 0201637c : ssize_t write( int fd, const void *buffer, size_t count ) { 201637c: 9d e3 bf 98 save %sp, -104, %sp ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2016380: 03 00 80 5d sethi %hi(0x2017400), %g1 2016384: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 201779c ssize_t write( int fd, const void *buffer, size_t count ) { 2016388: 92 10 00 19 mov %i1, %o1 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 201638c: 80 a6 00 01 cmp %i0, %g1 2016390: 1a 80 00 0e bcc 20163c8 2016394: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 2016398: 03 00 80 62 sethi %hi(0x2018800), %g1 201639c: c6 00 61 20 ld [ %g1 + 0x120 ], %g3 ! 2018920 20163a0: 85 2e 20 02 sll %i0, 2, %g2 20163a4: 83 2e 20 04 sll %i0, 4, %g1 20163a8: 82 20 40 02 sub %g1, %g2, %g1 20163ac: 82 00 40 18 add %g1, %i0, %g1 20163b0: 83 28 60 02 sll %g1, 2, %g1 20163b4: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 20163b8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 20163bc: 80 88 61 00 btst 0x100, %g1 20163c0: 12 80 00 06 bne 20163d8 20163c4: 80 a6 60 00 cmp %i1, 0 20163c8: 7f ff e0 06 call 200e3e0 <__errno> <== NOT EXECUTED 20163cc: 01 00 00 00 nop <== NOT EXECUTED 20163d0: 10 80 00 14 b 2016420 <== NOT EXECUTED 20163d4: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 20163d8: 02 80 00 07 be 20163f4 20163dc: 80 a6 a0 00 cmp %i2, 0 rtems_libio_check_count( count ); 20163e0: 02 80 00 1b be 201644c 20163e4: 90 10 20 00 clr %o0 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 20163e8: 80 88 60 04 btst 4, %g1 20163ec: 32 80 00 06 bne,a 2016404 20163f0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 20163f4: 7f ff df fb call 200e3e0 <__errno> <== NOT EXECUTED 20163f8: 01 00 00 00 nop <== NOT EXECUTED 20163fc: 10 80 00 09 b 2016420 <== NOT EXECUTED 2016400: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 2016404: c2 00 60 0c ld [ %g1 + 0xc ], %g1 2016408: 80 a0 60 00 cmp %g1, 0 201640c: 12 80 00 08 bne 201642c 2016410: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 2016414: 7f ff df f3 call 200e3e0 <__errno> <== NOT EXECUTED 2016418: 01 00 00 00 nop <== NOT EXECUTED 201641c: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2016420: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016424: 10 80 00 0a b 201644c <== NOT EXECUTED 2016428: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 201642c: 9f c0 40 00 call %g1 2016430: 90 10 00 18 mov %i0, %o0 if ( rc > 0 ) 2016434: 80 a2 20 00 cmp %o0, 0 2016438: 04 80 00 05 ble 201644c 201643c: 01 00 00 00 nop iop->offset += rc; 2016440: c2 06 20 08 ld [ %i0 + 8 ], %g1 2016444: 82 00 40 08 add %g1, %o0, %g1 2016448: c2 26 20 08 st %g1, [ %i0 + 8 ] return rc; } 201644c: 81 c7 e0 08 ret 2016450: 91 e8 00 08 restore %g0, %o0, %o0