02016214 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 2016214: 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(); 2016218: 40 00 06 f4 call 2017de8 201621c: f0 06 00 00 ld [ %i0 ], %i0 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 2016220: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1 2016224: 91 2a 20 10 sll %o0, 0x10, %o0 2016228: 91 32 20 10 srl %o0, 0x10, %o0 201622c: 80 a2 00 01 cmp %o0, %g1 2016230: 02 80 00 04 be 2016240 2016234: 80 a2 20 00 cmp %o0, 0 2016238: 12 80 00 0c bne 2016268 <== NOT EXECUTED 201623c: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 2016240: f2 36 20 38 sth %i1, [ %i0 + 0x38 ] jnode->st_gid = group; 2016244: f4 36 20 3a sth %i2, [ %i0 + 0x3a ] IMFS_update_ctime( jnode ); 2016248: 90 07 bf f0 add %fp, -16, %o0 201624c: 7f ff b7 a7 call 20040e8 2016250: 92 10 20 00 clr %o1 2016254: c2 07 bf f0 ld [ %fp + -16 ], %g1 2016258: 84 10 20 00 clr %g2 201625c: c2 26 20 44 st %g1, [ %i0 + 0x44 ] return 0; } 2016260: 81 c7 e0 08 ret 2016264: 91 e8 00 02 restore %g0, %g2, %o0 #if defined(RTEMS_POSIX_API) st_uid = geteuid(); if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) rtems_set_errno_and_return_minus_one( EPERM ); 2016268: 40 00 3d 6c call 2025818 <__errno> <== NOT EXECUTED 201626c: 01 00 00 00 nop <== NOT EXECUTED 2016270: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 2016274: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 2016278: 10 bf ff fa b 2016260 <== NOT EXECUTED 201627c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 0200e2c0 : IMFS_jnode_types_t type, char *name, mode_t mode, IMFS_types_union *info ) { 200e2c0: 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 ) 200e2c4: a6 96 20 00 orcc %i0, 0, %l3 200e2c8: 02 80 00 03 be 200e2d4 200e2cc: a4 10 20 00 clr %l2 parent = parent_loc->node_access; 200e2d0: e4 04 c0 00 ld [ %l3 ], %l2 /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 200e2d4: 90 10 20 01 mov 1, %o0 200e2d8: 92 10 20 5c mov 0x5c, %o1 200e2dc: 7f ff d0 ce call 2002614 200e2e0: b0 10 20 00 clr %i0 if ( !node ) 200e2e4: a2 92 20 00 orcc %o0, 0, %l1 200e2e8: 02 80 00 24 be 200e378 200e2ec: 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 ); 200e2f0: 92 10 00 1a mov %i2, %o1 200e2f4: 94 10 20 20 mov 0x20, %o2 /* * Fill in the basic information */ node->st_nlink = 1; 200e2f8: c2 34 60 30 sth %g1, [ %l1 + 0x30 ] node->type = type; 200e2fc: f2 24 60 48 st %i1, [ %l1 + 0x48 ] strncpy( node->name, name, IMFS_NAME_MAX ); 200e300: 40 00 08 b8 call 20105e0 200e304: 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; 200e308: 05 00 80 62 sethi %hi(0x2018800), %g2 200e30c: c6 00 a3 08 ld [ %g2 + 0x308 ], %g3 ! 2018b08 /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 200e310: 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; 200e314: c2 10 e0 24 lduh [ %g3 + 0x24 ], %g1 200e318: 82 2e c0 01 andn %i3, %g1, %g1 #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); 200e31c: 7f ff f8 1a call 200c384 200e320: c2 34 60 2e sth %g1, [ %l1 + 0x2e ] node->st_gid = getegid(); 200e324: 7f ff f8 14 call 200c374 200e328: d0 34 60 38 sth %o0, [ %l1 + 0x38 ] /* * Now set all the times. */ gettimeofday( &tv, 0 ); 200e32c: 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(); 200e330: d0 34 60 3a sth %o0, [ %l1 + 0x3a ] /* * Now set all the times. */ gettimeofday( &tv, 0 ); 200e334: 7f ff f8 18 call 200c394 200e338: 90 07 bf f0 add %fp, -16, %o0 node->stat_atime = (time_t) tv.tv_sec; 200e33c: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * Set the type specific information */ switch (type) { 200e340: 80 a6 60 06 cmp %i1, 6 gettimeofday( &tv, 0 ); node->stat_atime = (time_t) tv.tv_sec; node->stat_mtime = (time_t) tv.tv_sec; node->stat_ctime = (time_t) tv.tv_sec; 200e344: c2 24 60 44 st %g1, [ %l1 + 0x44 ] * Now set all the times. */ gettimeofday( &tv, 0 ); node->stat_atime = (time_t) tv.tv_sec; 200e348: c2 24 60 3c st %g1, [ %l1 + 0x3c ] /* * Set the type specific information */ switch (type) { 200e34c: 08 80 00 0d bleu 200e380 200e350: c2 24 60 40 st %g1, [ %l1 + 0x40 ] node->info.file.doubly_indirect = 0; node->info.file.triply_indirect = 0; break; default: assert(0); 200e354: 11 00 80 5f sethi %hi(0x2017c00), %o0 <== NOT EXECUTED 200e358: 15 00 80 5f sethi %hi(0x2017c00), %o2 <== NOT EXECUTED 200e35c: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED 200e360: 94 12 a0 e8 or %o2, 0xe8, %o2 <== NOT EXECUTED 200e364: 7f ff cf 12 call 2001fac <__assert> <== NOT EXECUTED 200e368: 92 10 20 77 mov 0x77, %o1 <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 200e36c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 200e370: 12 80 00 13 bne 200e3bc <== NOT EXECUTED 200e374: 90 04 a0 4c add %l2, 0x4c, %o0 <== NOT EXECUTED node->st_ino = ++fs_info->ino_count; } return node; } 200e378: 81 c7 e0 08 ret 200e37c: 81 e8 00 00 restore /* * Set the type specific information */ switch (type) { 200e380: 83 2e 60 02 sll %i1, 2, %g1 200e384: 05 00 80 38 sethi %hi(0x200e000), %g2 200e388: 84 10 a2 a4 or %g2, 0x2a4, %g2 ! 200e2a4 200e38c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 200e390: 81 c0 c0 00 jmp %g3 200e394: 01 00 00 00 nop node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 200e398: c0 24 60 4c clr [ %l1 + 0x4c ] <== NOT EXECUTED node->info.linearfile.direct = 0; 200e39c: c0 24 60 50 clr [ %l1 + 0x50 ] <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 200e3a0: c0 24 60 4c clr [ %l1 + 0x4c ] node->info.file.indirect = 0; 200e3a4: c0 24 60 50 clr [ %l1 + 0x50 ] node->info.file.doubly_indirect = 0; 200e3a8: c0 24 60 54 clr [ %l1 + 0x54 ] node->info.file.triply_indirect = 0; 200e3ac: c0 24 60 58 clr [ %l1 + 0x58 ] /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 200e3b0: 80 a4 a0 00 cmp %l2, 0 200e3b4: 02 bf ff f1 be 200e378 200e3b8: 90 04 a0 4c add %l2, 0x4c, %o0 Chain_Append( &parent->info.directory.Entries, &node->Node ); 200e3bc: 7f ff e2 83 call 2006dc8 <_Chain_Append> 200e3c0: 92 10 00 11 mov %l1, %o1 node->Parent = parent; fs_info = parent_loc->mt_entry->fs_info; 200e3c4: 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; 200e3c8: e4 24 60 08 st %l2, [ %l1 + 8 ] fs_info = parent_loc->mt_entry->fs_info; 200e3cc: c6 00 60 2c ld [ %g1 + 0x2c ], %g3 node->st_ino = ++fs_info->ino_count; 200e3d0: c4 00 c0 00 ld [ %g3 ], %g2 200e3d4: 84 00 a0 01 inc %g2 200e3d8: c4 20 c0 00 st %g2, [ %g3 ] 200e3dc: c4 24 60 34 st %g2, [ %l1 + 0x34 ] } return node; } 200e3e0: 81 c7 e0 08 ret 200e3e4: 81 e8 00 00 restore case IMFS_HARD_LINK: node->info.hard_link.link_node = info->hard_link.link_node; break; case IMFS_SYM_LINK: sym_name = calloc( 1, strlen( info->sym_link.name ) + 1 ); 200e3e8: 40 00 08 14 call 2010438 200e3ec: d0 07 00 00 ld [ %i4 ], %o0 200e3f0: 92 02 20 01 add %o0, 1, %o1 200e3f4: 7f ff d0 88 call 2002614 200e3f8: 90 10 20 01 mov 1, %o0 strcpy( sym_name, info->sym_link.name ); 200e3fc: d2 07 00 00 ld [ %i4 ], %o1 200e400: 40 00 07 ee call 20103b8 200e404: a0 10 00 08 mov %o0, %l0 node->info.sym_link.name = sym_name; 200e408: 10 bf ff ea b 200e3b0 200e40c: e0 24 60 4c st %l0, [ %l1 + 0x4c ] 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; 200e410: c2 07 00 00 ld [ %i4 ], %g1 200e414: 10 bf ff e7 b 200e3b0 200e418: c2 24 60 4c st %g1, [ %l1 + 0x4c ] node->info.sym_link.name = sym_name; break; case IMFS_DEVICE: node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; 200e41c: 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; 200e420: c4 07 00 00 ld [ %i4 ], %g2 node->info.device.minor = info->device.minor; 200e424: 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; 200e428: 10 bf ff e2 b 200e3b0 200e42c: c4 24 60 4c st %g2, [ %l1 + 0x4c ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 200e430: 82 04 60 50 add %l1, 0x50, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200e434: 84 04 60 4c add %l1, 0x4c, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 200e438: 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); 200e43c: c2 24 60 4c st %g1, [ %l1 + 0x4c ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200e440: 10 bf ff dc b 200e3b0 200e444: c4 24 60 54 st %g2, [ %l1 + 0x54 ] 02003af4 : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 2003af4: 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 ); 2003af8: 80 a6 20 00 cmp %i0, 0 2003afc: 02 80 00 3a be 2003be4 2003b00: 11 00 80 7a sethi %hi(0x201e800), %o0 assert( level >= 0 ); 2003b04: 80 a6 60 00 cmp %i1, 0 2003b08: 06 80 00 30 bl 2003bc8 2003b0c: 11 00 80 7a sethi %hi(0x201e800), %o0 assert( the_directory->type == IMFS_DIRECTORY ); 2003b10: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2003b14: 80 a0 60 01 cmp %g1, 1 2003b18: 02 80 00 07 be 2003b34 2003b1c: 11 00 80 7a sethi %hi(0x201e800), %o0 2003b20: 15 00 80 7a sethi %hi(0x201e800), %o2 <== NOT EXECUTED 2003b24: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED 2003b28: 94 12 a3 f0 or %o2, 0x3f0, %o2 <== NOT EXECUTED 2003b2c: 40 00 01 e0 call 20042ac <__assert> <== NOT EXECUTED 2003b30: 92 10 20 83 mov 0x83, %o1 <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 2003b34: e2 06 20 4c ld [ %i0 + 0x4c ], %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2003b38: b0 06 20 50 add %i0, 0x50, %i0 !_Chain_Is_tail( the_chain, the_node ); 2003b3c: 80 a4 40 18 cmp %l1, %i0 2003b40: 02 80 00 1c be 2003bb0 2003b44: 03 00 80 7b sethi %hi(0x201ec00), %g1 2003b48: 25 00 80 83 sethi %hi(0x2020c00), %l2 2003b4c: a6 10 60 18 or %g1, 0x18, %l3 for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 2003b50: a8 06 60 01 add %i1, 1, %l4 !_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++ ) 2003b54: 80 a6 60 00 cmp %i1, 0 2003b58: 06 80 00 0c bl 2003b88 2003b5c: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 2003b60: a0 10 20 00 clr %l0 fprintf(stdout, "...." ); 2003b64: 90 10 00 13 mov %l3, %o0 2003b68: d6 00 60 08 ld [ %g1 + 8 ], %o3 2003b6c: 92 10 20 01 mov 1, %o1 2003b70: 40 00 43 11 call 20147b4 2003b74: 94 10 20 04 mov 4, %o2 !_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++ ) 2003b78: a0 04 20 01 inc %l0 2003b7c: 80 a6 40 10 cmp %i1, %l0 2003b80: 16 bf ff f9 bge 2003b64 2003b84: c2 04 a0 e0 ld [ %l2 + 0xe0 ], %g1 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 2003b88: 7f ff ff 7e call 2003980 2003b8c: 90 10 00 11 mov %l1, %o0 if ( the_jnode->type == IMFS_DIRECTORY ) 2003b90: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 2003b94: 80 a0 60 01 cmp %g1, 1 2003b98: 22 80 00 08 be,a 2003bb8 2003b9c: 90 10 00 11 mov %l1, %o0 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 ) { 2003ba0: e2 04 40 00 ld [ %l1 ], %l1 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 ); 2003ba4: 80 a4 40 18 cmp %l1, %i0 2003ba8: 12 bf ff ec bne 2003b58 2003bac: 80 a6 60 00 cmp %i1, 0 2003bb0: 81 c7 e0 08 ret 2003bb4: 81 e8 00 00 restore for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 2003bb8: 7f ff ff cf call 2003af4 2003bbc: 92 10 00 14 mov %l4, %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 ) { 2003bc0: 10 bf ff f9 b 2003ba4 2003bc4: e2 04 40 00 ld [ %l1 ], %l1 IMFS_jnode_t *the_jnode; int i; assert( the_directory ); assert( level >= 0 ); 2003bc8: 15 00 80 7a sethi %hi(0x201e800), %o2 <== NOT EXECUTED 2003bcc: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED 2003bd0: 94 12 a3 e0 or %o2, 0x3e0, %o2 <== NOT EXECUTED 2003bd4: 40 00 01 b6 call 20042ac <__assert> <== NOT EXECUTED 2003bd8: 92 10 20 81 mov 0x81, %o1 <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 2003bdc: 10 bf ff ce b 2003b14 <== NOT EXECUTED 2003be0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED Chain_Node *the_node; Chain_Control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 2003be4: 15 00 80 7a sethi %hi(0x201e800), %o2 <== NOT EXECUTED 2003be8: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED 2003bec: 94 12 a3 d0 or %o2, 0x3d0, %o2 <== NOT EXECUTED 2003bf0: 40 00 01 af call 20042ac <__assert> <== NOT EXECUTED 2003bf4: 92 10 20 7f mov 0x7f, %o1 <== NOT EXECUTED assert( level >= 0 ); 2003bf8: 10 bf ff c4 b 2003b08 <== NOT EXECUTED 2003bfc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 0200b3ec : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200b3ec: 9d e3 bf 70 save %sp, -144, %sp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 200b3f0: e2 06 80 00 ld [ %i2 ], %l1 int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200b3f4: 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; 200b3f8: a4 10 20 00 clr %l2 200b3fc: a8 07 bf d3 add %fp, -45, %l4 200b400: aa 07 bf f4 add %fp, -12, %l5 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200b404: 2d 00 80 62 sethi %hi(0x2018800), %l6 * 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 ); 200b408: 90 04 c0 12 add %l3, %l2, %o0 200b40c: 92 10 00 14 mov %l4, %o1 200b410: 40 00 01 f4 call 200bbe0 200b414: 94 10 00 15 mov %l5, %o2 i += len; if ( !pathloc->node_access ) 200b418: c6 06 80 00 ld [ %i2 ], %g3 * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); 200b41c: a0 10 00 08 mov %o0, %l0 i += len; if ( !pathloc->node_access ) 200b420: 80 a0 e0 00 cmp %g3, 0 200b424: 02 80 00 4c be 200b554 200b428: c2 07 bf f4 ld [ %fp + -12 ], %g1 rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 200b42c: 80 a2 20 00 cmp %o0, 0 200b430: 12 80 00 11 bne 200b474 200b434: a4 04 80 01 add %l2, %g1, %l2 * new fs root node and let let the mounted filesystem set the handlers. * * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { 200b438: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 200b43c: 80 a0 60 01 cmp %g1, 1 200b440: 22 80 00 52 be,a 200b588 200b444: c6 00 e0 58 ld [ %g3 + 0x58 ], %g3 return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 200b448: 7f ff ff 92 call 200b290 200b44c: 90 10 00 1a mov %i2, %o0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 200b450: 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 ); 200b454: b0 10 00 08 mov %o0, %i0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 200b458: 7f ff ff ac call 200b308 200b45c: 90 10 00 1a mov %i2, %o0 200b460: 80 a2 20 00 cmp %o0, 0 200b464: 02 80 00 6b be 200b610 200b468: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); return result; } 200b46c: 81 c7 e0 08 ret 200b470: 81 e8 00 00 restore /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 200b474: c2 04 60 48 ld [ %l1 + 0x48 ], %g1 200b478: 80 a0 60 01 cmp %g1, 1 200b47c: 02 80 00 3c be 200b56c 200b480: 90 10 00 1a mov %i2, %o0 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; switch( type ) { 200b484: 80 a4 20 03 cmp %l0, 3 200b488: 02 80 00 21 be 200b50c 200b48c: a2 10 00 03 mov %g3, %l1 200b490: 80 a4 20 04 cmp %l0, 4 200b494: 02 80 00 18 be 200b4f4 200b498: 80 a4 20 02 cmp %l0, 2 200b49c: 02 80 00 06 be 200b4b4 200b4a0: 80 a4 20 04 cmp %l0, 4 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 200b4a4: 12 bf ff da bne 200b40c 200b4a8: 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 ) { 200b4ac: 10 bf ff e4 b 200b43c <== NOT EXECUTED 200b4b0: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 <== NOT EXECUTED case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 200b4b4: c2 05 a3 08 ld [ %l6 + 0x308 ], %g1 200b4b8: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 200b4bc: 80 a0 80 03 cmp %g2, %g3 200b4c0: 02 bf ff d3 be 200b40c 200b4c4: 90 04 c0 12 add %l3, %l2, %o0 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 200b4c8: d8 06 a0 0c ld [ %i2 + 0xc ], %o4 200b4cc: c2 03 20 18 ld [ %o4 + 0x18 ], %g1 200b4d0: 80 a0 40 03 cmp %g1, %g3 200b4d4: 22 80 00 5b be,a 200b640 200b4d8: c8 03 20 10 ld [ %o4 + 0x10 ], %g4 *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 200b4dc: e2 00 e0 08 ld [ %g3 + 8 ], %l1 200b4e0: 80 a4 60 00 cmp %l1, 0 200b4e4: 02 80 00 46 be 200b5fc 200b4e8: 01 00 00 00 nop /* * Set the node access to the point we have found. */ pathloc->node_access = node; 200b4ec: 10 bf ff c8 b 200b40c 200b4f0: e2 26 80 00 st %l1, [ %i2 ] case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200b4f4: 40 00 0e f3 call 200f0c0 <__errno> 200b4f8: b0 10 3f ff mov -1, %i0 200b4fc: 82 10 20 5b mov 0x5b, %g1 200b500: c2 22 00 00 st %g1, [ %o0 ] 200b504: 81 c7 e0 08 ret 200b508: 81 e8 00 00 restore case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 200b50c: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 200b510: 80 a0 60 03 cmp %g1, 3 200b514: 02 80 00 31 be 200b5d8 200b518: 80 a0 60 04 cmp %g1, 4 node = pathloc->node_access; if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 200b51c: 02 80 00 54 be 200b66c 200b520: 90 10 00 1a mov %i2, %o0 /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 200b524: 80 a0 60 01 cmp %g1, 1 200b528: 12 80 00 40 bne 200b628 200b52c: 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 ) { 200b530: c6 04 60 58 ld [ %l1 + 0x58 ], %g3 200b534: 80 a0 e0 00 cmp %g3, 0 200b538: 12 80 00 17 bne 200b594 200b53c: 90 10 00 11 mov %l1, %o0 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 200b540: 40 00 01 76 call 200bb18 200b544: 92 10 00 14 mov %l4, %o1 if ( !node ) 200b548: a2 92 20 00 orcc %o0, 0, %l1 200b54c: 32 bf ff af bne,a 200b408 200b550: e2 26 80 00 st %l1, [ %i2 ] rtems_set_errno_and_return_minus_one( ENOENT ); 200b554: 40 00 0e db call 200f0c0 <__errno> 200b558: b0 10 3f ff mov -1, %i0 200b55c: 82 10 20 02 mov 2, %g1 200b560: c2 22 00 00 st %g1, [ %o0 ] 200b564: 81 c7 e0 08 ret 200b568: 81 e8 00 00 restore /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 200b56c: 7f ff ff 67 call 200b308 200b570: 92 10 20 01 mov 1, %o1 200b574: 80 a2 20 00 cmp %o0, 0 200b578: 02 80 00 37 be 200b654 200b57c: 01 00 00 00 nop 200b580: 10 bf ff c1 b 200b484 200b584: c6 06 80 00 ld [ %i2 ], %g3 * * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { 200b588: 80 a0 e0 00 cmp %g3, 0 200b58c: 02 bf ff af be 200b448 200b590: 01 00 00 00 nop newloc = node->info.directory.mt_fs->mt_fs_root; 200b594: c8 00 e0 20 ld [ %g3 + 0x20 ], %g4 *pathloc = newloc; 200b598: c2 00 e0 24 ld [ %g3 + 0x24 ], %g1 * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; 200b59c: c4 00 e0 1c ld [ %g3 + 0x1c ], %g2 *pathloc = newloc; return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200b5a0: da 01 00 00 ld [ %g4 ], %o5 * NOTE: The behavior of stat() on a mount point appears to be questionable. */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; 200b5a4: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3 *pathloc = newloc; return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200b5a8: d0 07 bf f4 ld [ %fp + -12 ], %o0 */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; *pathloc = newloc; 200b5ac: c2 26 a0 0c st %g1, [ %i2 + 0xc ] return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200b5b0: 90 24 80 08 sub %l2, %o0, %o0 */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; *pathloc = newloc; 200b5b4: c4 26 a0 04 st %g2, [ %i2 + 4 ] 200b5b8: c6 26 80 00 st %g3, [ %i2 ] return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200b5bc: 90 02 00 13 add %o0, %l3, %o0 */ if ( node->type == IMFS_DIRECTORY ) { if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; *pathloc = newloc; 200b5c0: c8 26 a0 08 st %g4, [ %i2 + 8 ] return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 200b5c4: 92 10 00 19 mov %i1, %o1 200b5c8: 9f c3 40 00 call %o5 200b5cc: 94 10 00 1a mov %i2, %o2 200b5d0: 81 c7 e0 08 ret 200b5d4: 91 e8 00 08 restore %g0, %o0, %o0 * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { IMFS_evaluate_hard_link( pathloc, 0 ); 200b5d8: 90 10 00 1a mov %i2, %o0 200b5dc: 7f ff ff 69 call 200b380 200b5e0: 92 10 20 00 clr %o1 node = pathloc->node_access; 200b5e4: d0 06 80 00 ld [ %i2 ], %o0 if ( !node ) 200b5e8: 80 a2 20 00 cmp %o0, 0 200b5ec: 02 80 00 0f be 200b628 200b5f0: a2 10 00 08 mov %o0, %l1 } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 200b5f4: 10 bf ff cc b 200b524 200b5f8: c2 02 20 48 ld [ %o0 + 0x48 ], %g1 return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) rtems_set_errno_and_return_minus_one( ENOENT ); 200b5fc: 40 00 0e b1 call 200f0c0 <__errno> 200b600: b0 10 3f ff mov -1, %i0 200b604: e0 22 00 00 st %l0, [ %o0 ] 200b608: 81 c7 e0 08 ret 200b60c: 81 e8 00 00 restore /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 200b610: 40 00 0e ac call 200f0c0 <__errno> 200b614: b0 10 3f ff mov -1, %i0 200b618: 82 10 20 0d mov 0xd, %g1 200b61c: c2 22 00 00 st %g1, [ %o0 ] return result; } 200b620: 81 c7 e0 08 ret 200b624: 81 e8 00 00 restore /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 200b628: 40 00 0e a6 call 200f0c0 <__errno> 200b62c: b0 10 3f ff mov -1, %i0 200b630: 82 10 20 14 mov 0x14, %g1 200b634: c2 22 00 00 st %g1, [ %o0 ] 200b638: 81 c7 e0 08 ret 200b63c: 81 e8 00 00 restore if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; *pathloc = newloc; 200b640: c2 03 20 14 ld [ %o4 + 0x14 ], %g1 return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); 200b644: da 01 00 00 ld [ %g4 ], %o5 */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 200b648: c4 03 20 0c ld [ %o4 + 0xc ], %g2 200b64c: 10 bf ff d7 b 200b5a8 200b650: c6 03 20 08 ld [ %o4 + 8 ], %g3 * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); 200b654: 40 00 0e 9b call 200f0c0 <__errno> 200b658: b0 10 3f ff mov -1, %i0 200b65c: 82 10 20 0d mov 0xd, %g1 200b660: c2 22 00 00 st %g1, [ %o0 ] 200b664: 81 c7 e0 08 ret 200b668: 81 e8 00 00 restore if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); 200b66c: 40 00 00 09 call 200b690 200b670: 92 10 20 00 clr %o1 200b674: b0 10 00 08 mov %o0, %i0 node = pathloc->node_access; if ( result == -1 ) 200b678: 80 a2 3f ff cmp %o0, -1 200b67c: 02 bf ff 7c be 200b46c 200b680: 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; 200b684: c2 02 20 48 ld [ %o0 + 0x48 ], %g1 200b688: 10 bf ff a7 b 200b524 200b68c: a2 10 00 08 mov %o0, %l1 0200b380 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 200b380: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *jnode = node->node_access; 200b384: e0 06 00 00 ld [ %i0 ], %l0 /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 200b388: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200b38c: 80 a0 60 03 cmp %g1, 3 200b390: 22 80 00 05 be,a 200b3a4 200b394: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 rtems_fatal_error_occurred (0xABCD0000); 200b398: 7f ff ed b6 call 2006a70 <== NOT EXECUTED 200b39c: 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; 200b3a0: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 <== NOT EXECUTED IMFS_Set_handlers( node ); 200b3a4: 90 10 00 18 mov %i0, %o0 200b3a8: 7f ff ff ba call 200b290 200b3ac: c2 26 00 00 st %g1, [ %i0 ] /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 200b3b0: 90 10 00 18 mov %i0, %o0 200b3b4: 92 10 00 19 mov %i1, %o1 200b3b8: 7f ff ff d4 call 200b308 200b3bc: b0 10 20 00 clr %i0 200b3c0: 80 a2 20 00 cmp %o0, 0 200b3c4: 02 80 00 04 be 200b3d4 200b3c8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); return result; } 200b3cc: 81 c7 e0 08 ret 200b3d0: 81 e8 00 00 restore /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 200b3d4: 40 00 0f 3b call 200f0c0 <__errno> <== NOT EXECUTED 200b3d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200b3dc: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED 200b3e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return result; } 200b3e4: 81 c7 e0 08 ret <== NOT EXECUTED 200b3e8: 81 e8 00 00 restore <== NOT EXECUTED 0200b77c : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 200b77c: 9d e3 bf 98 save %sp, -104, %sp 200b780: 10 80 00 07 b 200b79c 200b784: 23 00 80 62 sethi %hi(0x2018800), %l1 */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 200b788: 02 80 00 23 be 200b814 200b78c: 82 00 7f fd add %g1, -3, %g1 result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 200b790: 80 a0 60 01 cmp %g1, 1 200b794: 18 80 00 1c bgu 200b804 200b798: 90 10 20 00 clr %o0 /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 200b79c: c4 04 63 08 ld [ %l1 + 0x308 ], %g2 { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 200b7a0: e0 06 00 00 ld [ %i0 ], %l0 /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 200b7a4: c2 10 a0 26 lduh [ %g2 + 0x26 ], %g1 200b7a8: 82 00 60 01 inc %g1 200b7ac: c2 30 a0 26 sth %g1, [ %g2 + 0x26 ] if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 200b7b0: 83 28 60 10 sll %g1, 0x10, %g1 200b7b4: 83 30 60 10 srl %g1, 0x10, %g1 200b7b8: 80 a0 60 05 cmp %g1, 5 200b7bc: 18 80 00 1b bgu 200b828 200b7c0: 01 00 00 00 nop /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 200b7c4: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200b7c8: 80 a0 60 03 cmp %g1, 3 200b7cc: 12 bf ff ef bne 200b788 200b7d0: 80 a0 60 04 cmp %g1, 4 result = IMFS_evaluate_hard_link( node, flags ); 200b7d4: 90 10 00 18 mov %i0, %o0 200b7d8: 7f ff fe ea call 200b380 200b7dc: 92 10 00 19 mov %i1, %o1 else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 200b7e0: 80 a2 20 00 cmp %o0, 0 200b7e4: 12 80 00 09 bne 200b808 200b7e8: c2 04 63 08 ld [ %l1 + 0x308 ], %g1 200b7ec: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200b7f0: 82 00 7f fd add %g1, -3, %g1 200b7f4: 80 a0 60 01 cmp %g1, 1 200b7f8: 08 bf ff ea bleu 200b7a0 200b7fc: c4 04 63 08 ld [ %l1 + 0x308 ], %g2 200b800: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 200b804: c2 04 63 08 ld [ %l1 + 0x308 ], %g1 200b808: c0 30 60 26 clrh [ %g1 + 0x26 ] return result; } 200b80c: 81 c7 e0 08 ret 200b810: 91 e8 00 08 restore %g0, %o0, %o0 if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); 200b814: 90 10 00 18 mov %i0, %o0 200b818: 7f ff ff 9e call 200b690 200b81c: 92 10 00 19 mov %i1, %o1 } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 200b820: 10 bf ff f1 b 200b7e4 200b824: 80 a2 20 00 cmp %o0, 0 */ rtems_filesystem_link_counts ++; if ( rtems_filesystem_link_counts > MAXSYMLINK ) { rtems_filesystem_link_counts = 0; rtems_set_errno_and_return_minus_one( ELOOP ); 200b828: 40 00 0e 26 call 200f0c0 <__errno> 200b82c: c0 30 a0 26 clrh [ %g2 + 0x26 ] 200b830: 82 10 20 5c mov 0x5c, %g1 200b834: c2 22 00 00 st %g1, [ %o0 ] 200b838: 90 10 3f ff mov -1, %o0 */ rtems_filesystem_link_counts = 0; return result; } 200b83c: 81 c7 e0 08 ret 200b840: 91 e8 00 08 restore %g0, %o0, %o0 0200b690 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 200b690: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *jnode = node->node_access; 200b694: e0 06 00 00 ld [ %i0 ], %l0 /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 200b698: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200b69c: 80 a0 60 04 cmp %g1, 4 200b6a0: 22 80 00 05 be,a 200b6b4 200b6a4: c2 04 20 08 ld [ %l0 + 8 ], %g1 rtems_fatal_error_occurred (0xABCD0000); 200b6a8: 7f ff ec f2 call 2006a70 <== NOT EXECUTED 200b6ac: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED if ( !jnode->Parent ) 200b6b0: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200b6b4: 80 a0 60 00 cmp %g1, 0 200b6b8: 02 80 00 28 be 200b758 200b6bc: 01 00 00 00 nop /* * Move the node_access to either the symbolic links parent or * root depending on the symbolic links path. */ node->node_access = jnode->Parent; 200b6c0: c2 26 00 00 st %g1, [ %i0 ] rtems_filesystem_get_sym_start_loc( 200b6c4: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 200b6c8: c2 48 80 00 ldsb [ %g2 ], %g1 200b6cc: 80 a0 60 2f cmp %g1, 0x2f 200b6d0: 02 80 00 15 be 200b724 200b6d4: 80 a0 60 5c cmp %g1, 0x5c 200b6d8: 02 80 00 13 be 200b724 200b6dc: 80 a0 60 00 cmp %g1, 0 200b6e0: 02 80 00 11 be 200b724 200b6e4: 90 10 20 00 clr %o0 /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 200b6e8: 90 02 00 02 add %o0, %g2, %o0 200b6ec: 94 10 00 18 mov %i0, %o2 200b6f0: 7f ff ff 3f call 200b3ec 200b6f4: 92 10 00 19 mov %i1, %o1 200b6f8: a0 10 00 08 mov %o0, %l0 &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 200b6fc: 7f ff fe e5 call 200b290 200b700: 90 10 00 18 mov %i0, %o0 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 200b704: 90 10 00 18 mov %i0, %o0 200b708: 7f ff ff 00 call 200b308 200b70c: 92 10 00 19 mov %i1, %o1 200b710: 80 a2 20 00 cmp %o0, 0 200b714: 02 80 00 15 be 200b768 200b718: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EACCES ); return result; } 200b71c: 81 c7 e0 08 ret 200b720: 91 e8 00 10 restore %g0, %l0, %o0 * root depending on the symbolic links path. */ node->node_access = jnode->Parent; rtems_filesystem_get_sym_start_loc( 200b724: 03 00 80 62 sethi %hi(0x2018800), %g1 200b728: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 200b72c: 90 10 20 01 mov 1, %o0 200b730: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 200b734: c2 26 00 00 st %g1, [ %i0 ] 200b738: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 200b73c: c4 26 20 04 st %g2, [ %i0 + 4 ] 200b740: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 200b744: c2 26 20 08 st %g1, [ %i0 + 8 ] 200b748: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 200b74c: c4 26 20 0c st %g2, [ %i0 + 0xc ] 200b750: 10 bf ff e6 b 200b6e8 200b754: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if ( jnode->type != IMFS_SYM_LINK ) rtems_fatal_error_occurred (0xABCD0000); if ( !jnode->Parent ) rtems_fatal_error_occurred( 0xBAD00000 ); 200b758: 7f ff ec c6 call 2006a70 <== NOT EXECUTED 200b75c: 11 2e b4 00 sethi %hi(0xbad00000), %o0 <== NOT EXECUTED 200b760: 10 bf ff d8 b 200b6c0 <== NOT EXECUTED 200b764: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 200b768: 40 00 0e 56 call 200f0c0 <__errno> <== NOT EXECUTED 200b76c: a0 10 3f ff mov -1, %l0 <== NOT EXECUTED 200b770: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED 200b774: 10 bf ff ea b 200b71c <== NOT EXECUTED 200b778: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 0200e448 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 200e448: 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(); 200e44c: 7f ff f7 ce call 200c384 200e450: f0 06 00 00 ld [ %i0 ], %i0 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 200e454: c2 16 20 38 lduh [ %i0 + 0x38 ], %g1 200e458: 91 2a 20 10 sll %o0, 0x10, %o0 200e45c: 91 32 20 10 srl %o0, 0x10, %o0 200e460: 80 a2 00 01 cmp %o0, %g1 200e464: 02 80 00 04 be 200e474 200e468: 80 a2 20 00 cmp %o0, 0 200e46c: 12 80 00 13 bne 200e4b8 <== NOT EXECUTED 200e470: 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 ) ) ) 200e474: 83 2e 60 10 sll %i1, 0x10, %g1 200e478: 83 30 60 10 srl %g1, 0x10, %g1 200e47c: 82 08 7e 00 and %g1, -512, %g1 200e480: 80 a0 60 00 cmp %g1, 0 200e484: 12 80 00 0d bne 200e4b8 200e488: 90 07 bf f0 add %fp, -16, %o0 rtems_set_errno_and_return_minus_one( EPERM ); jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); 200e48c: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1 jnode->st_mode |= mode; 200e490: 82 08 7e 00 and %g1, -512, %g1 200e494: 82 10 40 19 or %g1, %i1, %g1 IMFS_update_ctime( jnode ); 200e498: 92 10 20 00 clr %o1 200e49c: 7f ff f7 be call 200c394 200e4a0: c2 36 20 2e sth %g1, [ %i0 + 0x2e ] 200e4a4: c2 07 bf f0 ld [ %fp + -16 ], %g1 200e4a8: 84 10 20 00 clr %g2 200e4ac: c2 26 20 44 st %g1, [ %i0 + 0x44 ] return 0; } 200e4b0: 81 c7 e0 08 ret 200e4b4: 91 e8 00 02 restore %g0, %g2, %o0 /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) rtems_set_errno_and_return_minus_one( EPERM ); 200e4b8: 40 00 03 02 call 200f0c0 <__errno> 200e4bc: 01 00 00 00 nop 200e4c0: 82 10 20 01 mov 1, %g1 ! 1 200e4c4: 84 10 3f ff mov -1, %g2 200e4c8: 10 bf ff fa b 200e4b0 200e4cc: c2 22 00 00 st %g1, [ %o0 ] 0200bb18 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 200bb18: 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 ); 200bb1c: 80 a6 20 00 cmp %i0, 0 200bb20: 02 80 00 18 be 200bb80 200bb24: 11 00 80 5e sethi %hi(0x2017800), %o0 if ( !name ) 200bb28: 80 a6 60 00 cmp %i1, 0 200bb2c: 12 80 00 04 bne 200bb3c 200bb30: 80 a6 20 00 cmp %i0, 0 if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 200bb34: 81 c7 e0 08 ret 200bb38: 91 e8 20 00 restore %g0, 0, %o0 assert( directory ); if ( !name ) return 0; assert( name ); if ( !directory ) 200bb3c: 02 80 00 0f be 200bb78 200bb40: 90 10 00 19 mov %i1, %o0 /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 200bb44: 13 00 80 62 sethi %hi(0x2018800), %o1 200bb48: 40 00 11 ec call 20102f8 200bb4c: 92 12 62 88 or %o1, 0x288, %o1 ! 2018a88 200bb50: 80 a2 20 00 cmp %o0, 0 200bb54: 02 80 00 09 be 200bb78 200bb58: 90 10 00 19 mov %i1, %o0 return directory; if ( !strcmp( name, dotdotname ) ) 200bb5c: 13 00 80 62 sethi %hi(0x2018800), %o1 200bb60: 40 00 11 e6 call 20102f8 200bb64: 92 12 62 90 or %o1, 0x290, %o1 ! 2018a90 200bb68: 80 a2 20 00 cmp %o0, 0 200bb6c: 32 80 00 0c bne,a 200bb9c 200bb70: e0 06 20 4c ld [ %i0 + 0x4c ], %l0 return directory->Parent; 200bb74: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 200bb78: 81 c7 e0 08 ret <== NOT EXECUTED 200bb7c: 81 e8 00 00 restore <== NOT EXECUTED /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 200bb80: 15 00 80 5e sethi %hi(0x2017800), %o2 <== NOT EXECUTED 200bb84: 90 12 23 18 or %o0, 0x318, %o0 <== NOT EXECUTED 200bb88: 94 12 a3 68 or %o2, 0x368, %o2 <== NOT EXECUTED 200bb8c: 7f ff d9 08 call 2001fac <__assert> <== NOT EXECUTED 200bb90: 92 10 20 2a mov 0x2a, %o1 <== NOT EXECUTED if ( !name ) 200bb94: 10 bf ff e6 b 200bb2c <== NOT EXECUTED 200bb98: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200bb9c: b0 06 20 50 add %i0, 0x50, %i0 return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !_Chain_Is_tail( the_chain, the_node ); 200bba0: 80 a4 00 18 cmp %l0, %i0 200bba4: 12 80 00 07 bne 200bbc0 200bba8: 92 04 20 0c add %l0, 0xc, %o1 200bbac: 81 c7 e0 08 ret 200bbb0: 91 e8 20 00 restore %g0, 0, %o0 200bbb4: 80 a6 00 10 cmp %i0, %l0 200bbb8: 02 bf ff df be 200bb34 200bbbc: 92 04 20 0c add %l0, 0xc, %o1 the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 200bbc0: 40 00 11 ce call 20102f8 200bbc4: 90 10 00 19 mov %i1, %o0 200bbc8: 80 a2 20 00 cmp %o0, 0 200bbcc: 32 bf ff fa bne,a 200bbb4 200bbd0: e0 04 00 00 ld [ %l0 ], %l0 200bbd4: b0 10 00 10 mov %l0, %i0 200bbd8: 81 c7 e0 08 ret 200bbdc: 81 e8 00 00 restore 02016cd0 : ((IMFS_jnode_t *)( Chain_Head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 2016cd0: 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; 2016cd4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 2016cd8: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2016cdc: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 /* * 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; 2016ce0: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 loc = temp_mt_entry->mt_fs_root; 2016ce4: c2 27 bf ec st %g1, [ %fp + -20 ] 2016ce8: c4 3f bf f0 std %g2, [ %fp + -16 ] /* * Set this to null to indicate that it is being unmounted. */ temp_mt_entry->mt_fs_root.node_access = NULL; 2016cec: c0 26 20 18 clr [ %i0 + 0x18 ] * 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; 2016cf0: e0 27 bf e8 st %l0, [ %fp + -24 ] 2016cf4: a2 07 bf e8 add %fp, -24, %l1 temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; loc.node_access = (void *)jnode; 2016cf8: e0 27 bf e8 st %l0, [ %fp + -24 ] */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 2016cfc: f0 04 20 08 ld [ %l0 + 8 ], %i0 loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 2016d00: 7f ff fd d0 call 2016440 2016d04: 90 10 00 11 mov %l1, %o0 if ( jnode->type != IMFS_DIRECTORY ) { 2016d08: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2016d0c: 80 a0 60 01 cmp %g1, 1 2016d10: 12 80 00 1c bne 2016d80 2016d14: 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 ) ) { 2016d18: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 2016d1c: 80 a0 40 02 cmp %g1, %g2 2016d20: 02 80 00 18 be 2016d80 2016d24: 80 a4 20 00 cmp %l0, 0 result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 2016d28: 02 80 00 1e be 2016da0 2016d2c: 01 00 00 00 nop if ( jnode->type == IMFS_DIRECTORY ) { 2016d30: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2016d34: 80 a0 60 01 cmp %g1, 1 2016d38: 32 bf ff f1 bne,a 2016cfc 2016d3c: e0 27 bf e8 st %l0, [ %fp + -24 ] <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 2016d40: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2016d44: 82 04 20 50 add %l0, 0x50, %g1 2016d48: 80 a0 80 01 cmp %g2, %g1 2016d4c: 22 bf ff ec be,a 2016cfc 2016d50: e0 27 bf e8 st %l0, [ %fp + -24 ] jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); 2016d54: 80 a0 a0 00 cmp %g2, 0 2016d58: 02 80 00 12 be 2016da0 2016d5c: 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; IMFS_Set_handlers( &loc ); 2016d60: 90 10 00 11 mov %l1, %o0 temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; loc.node_access = (void *)jnode; 2016d64: e0 27 bf e8 st %l0, [ %fp + -24 ] IMFS_Set_handlers( &loc ); 2016d68: 7f ff fd b6 call 2016440 2016d6c: f0 04 20 08 ld [ %l0 + 8 ], %i0 if ( jnode->type != IMFS_DIRECTORY ) { 2016d70: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2016d74: 80 a0 60 01 cmp %g1, 1 2016d78: 02 bf ff e8 be 2016d18 2016d7c: 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 ) ) { result = IMFS_unlink( &loc ); 2016d80: 7f ff b3 6f call 2003b3c 2016d84: 90 10 00 11 mov %l1, %o0 if (result != 0) 2016d88: 80 a2 20 00 cmp %o0, 0 2016d8c: 12 80 00 07 bne 2016da8 2016d90: a0 10 00 18 mov %i0, %l0 return -1; jnode = next; } if ( jnode != NULL ) { 2016d94: 80 a4 20 00 cmp %l0, 0 2016d98: 32 bf ff e7 bne,a 2016d34 2016d9c: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 } } } while (jnode != NULL); return 0; } 2016da0: 81 c7 e0 08 ret 2016da4: 91 e8 20 00 restore %g0, 0, %o0 jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); 2016da8: 81 c7 e0 08 ret <== NOT EXECUTED 2016dac: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED 0200bbe0 : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 200bbe0: 9d e3 bf 98 save %sp, -104, %sp register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 200bbe4: c4 0e 00 00 ldub [ %i0 ], %g2 while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 200bbe8: 87 28 a0 18 sll %g2, 0x18, %g3 200bbec: 83 38 e0 18 sra %g3, 0x18, %g1 200bbf0: 80 a0 60 2f cmp %g1, 0x2f 200bbf4: 02 80 00 28 be 200bc94 200bbf8: 80 a0 60 5c cmp %g1, 0x5c 200bbfc: 02 80 00 26 be 200bc94 200bc00: 80 a0 60 00 cmp %g1, 0 200bc04: 02 80 00 41 be 200bd08 200bc08: 86 10 20 00 clr %g3 token[i] = c; 200bc0c: c4 2e 40 00 stb %g2, [ %i1 ] return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 200bc10: 86 00 e0 01 inc %g3 /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 200bc14: c2 48 c0 18 ldsb [ %g3 + %i0 ], %g1 200bc18: 80 a0 60 2f cmp %g1, 0x2f 200bc1c: 02 80 00 07 be 200bc38 200bc20: c4 08 c0 18 ldub [ %g3 + %i0 ], %g2 200bc24: 80 a0 60 5c cmp %g1, 0x5c 200bc28: 02 80 00 04 be 200bc38 200bc2c: 80 a0 60 00 cmp %g1, 0 200bc30: 12 80 00 12 bne 200bc78 200bc34: 80 a0 e0 20 cmp %g3, 0x20 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 200bc38: 82 00 c0 19 add %g3, %i1, %g1 200bc3c: c4 48 7f ff ldsb [ %g1 + -1 ], %g2 200bc40: 80 a0 a0 00 cmp %g2, 0 200bc44: 32 80 00 1c bne,a 200bcb4 200bc48: c0 2e 40 03 clrb [ %i1 + %g3 ] /* * Set token_len to the number of characters copied. */ *token_len = i; 200bc4c: c6 26 80 00 st %g3, [ %i2 ] <== NOT EXECUTED * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) 200bc50: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200bc54: 13 00 80 5e sethi %hi(0x2017800), %o1 <== NOT EXECUTED 200bc58: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED 200bc5c: 40 00 11 a7 call 20102f8 <== NOT EXECUTED 200bc60: 92 12 61 18 or %o1, 0x118, %o1 <== NOT EXECUTED 200bc64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200bc68: 12 80 00 1c bne 200bcd8 <== NOT EXECUTED 200bc6c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 200bc70: 81 c7 e0 08 ret 200bc74: 81 e8 00 00 restore /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 200bc78: 14 bf ff f1 bg 200bc3c 200bc7c: 82 00 c0 19 add %g3, %i1, %g1 token[i] = c; if ( i == IMFS_NAME_MAX ) 200bc80: 80 a0 e0 20 cmp %g3, 0x20 200bc84: 12 bf ff e3 bne 200bc10 200bc88: c4 28 c0 19 stb %g2, [ %g3 + %i1 ] 200bc8c: 81 c7 e0 08 ret 200bc90: 91 e8 20 04 restore %g0, 4, %o0 /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 200bc94: c4 2e 40 00 stb %g2, [ %i1 ] if ( token[i] != '\0' ) { 200bc98: 80 a0 e0 00 cmp %g3, 0 200bc9c: 82 10 20 01 mov 1, %g1 200bca0: 02 80 00 16 be 200bcf8 200bca4: b0 10 20 01 mov 1, %i0 /* * Set token_len to the number of characters copied. */ *token_len = i; 200bca8: c2 26 80 00 st %g1, [ %i2 ] 200bcac: 81 c7 e0 08 ret 200bcb0: 81 e8 00 00 restore 200bcb4: c6 26 80 00 st %g3, [ %i2 ] * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) 200bcb8: 90 10 00 19 mov %i1, %o0 200bcbc: 13 00 80 5e sethi %hi(0x2017800), %o1 200bcc0: b0 10 20 02 mov 2, %i0 200bcc4: 40 00 11 8d call 20102f8 200bcc8: 92 12 61 18 or %o1, 0x118, %o1 200bccc: 80 a2 20 00 cmp %o0, 0 200bcd0: 02 bf ff e8 be 200bc70 200bcd4: 90 10 00 19 mov %i1, %o0 type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 200bcd8: 13 00 80 5e sethi %hi(0x2017800), %o1 200bcdc: 40 00 11 87 call 20102f8 200bce0: 92 12 63 78 or %o1, 0x378, %o1 ! 2017b78 <_CPU_Trap_slot_template+0x70> 200bce4: 80 a0 00 08 cmp %g0, %o0 200bce8: 82 60 20 00 subx %g0, 0, %g1 200bcec: b0 08 60 02 and %g1, 2, %i0 200bcf0: 81 c7 e0 08 ret 200bcf4: 91 ee 20 01 restore %i0, 1, %o0 type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { token[i] = '\0'; 200bcf8: 82 10 20 00 clr %g1 <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 200bcfc: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { token[i] = '\0'; 200bd00: 81 c7 e0 08 ret <== NOT EXECUTED 200bd04: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 200bd08: c4 2e 40 00 stb %g2, [ %i1 ] 200bd0c: 82 10 20 00 clr %g1 200bd10: 10 bf ff e6 b 200bca8 200bd14: b0 10 20 00 clr %i0 0200bd18 : 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 ) { 200bd18: 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, 200bd1c: 03 00 80 61 sethi %hi(0x2018400), %g1 200bd20: 84 10 20 00 clr %g2 200bd24: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 200bd28: 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) { 200bd2c: 80 a0 40 03 cmp %g1, %g3 200bd30: 02 80 00 06 be 200bd48 200bd34: 84 00 a0 01 inc %g2 int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 200bd38: 80 a0 a0 06 cmp %g2, 6 200bd3c: 12 bf ff fc bne 200bd2c 200bd40: 83 28 60 01 sll %g1, 1, %g1 200bd44: 86 10 20 80 mov 0x80, %g3 <== NOT EXECUTED bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { is_valid = TRUE; } } *dest_bytes_per_block = ((is_valid) 200bd48: 03 00 80 65 sethi %hi(0x2019400), %g1 * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_node( 200bd4c: 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) 200bd50: c6 20 60 68 st %g3, [ %g1 + 0x68 ] * 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( 200bd54: 92 10 20 01 mov 1, %o1 200bd58: 90 10 20 00 clr %o0 200bd5c: 15 00 80 5e sethi %hi(0x2017800), %o2 200bd60: 17 00 00 10 sethi %hi(0x4000), %o3 200bd64: 94 12 a0 98 or %o2, 0x98, %o2 200bd68: 40 00 09 56 call 200e2c0 200bd6c: 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; 200bd70: 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( 200bd74: 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; 200bd78: f2 26 20 20 st %i1, [ %i0 + 0x20 ] "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 200bd7c: 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; 200bd80: 13 00 80 63 sethi %hi(0x2018c00), %o1 200bd84: 90 06 20 30 add %i0, 0x30, %o0 200bd88: 40 00 0e a3 call 200f814 200bd8c: 92 12 62 00 or %o1, 0x200, %o1 /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 200bd90: 90 10 20 01 mov 1, %o0 200bd94: 7f ff da 20 call 2002614 200bd98: 92 10 20 0c mov 0xc, %o1 if ( !fs_info ){ 200bd9c: 80 a2 20 00 cmp %o0, 0 200bda0: 02 80 00 0a be 200bdc8 200bda4: 82 10 20 01 mov 1, %g1 fs_info->ino_count = 1; fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers; jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 200bda8: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 200bdac: 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; 200bdb0: 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; 200bdb4: f6 22 20 08 st %i3, [ %o0 + 8 ] jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 200bdb8: 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; 200bdbc: 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; } 200bdc0: 81 c7 e0 08 ret 200bdc4: 91 e8 20 00 restore %g0, 0, %o0 /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); if ( !fs_info ){ free(temp_mt_entry->mt_fs_root.node_access); 200bdc8: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 <== NOT EXECUTED 200bdcc: 7f ff d9 4b call 20022f8 <== NOT EXECUTED 200bdd0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 200bdd4: 40 00 0c bb call 200f0c0 <__errno> <== NOT EXECUTED 200bdd8: 01 00 00 00 nop <== NOT EXECUTED 200bddc: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 200bde0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200bde4: 81 c7 e0 08 ret <== NOT EXECUTED 200bde8: 81 e8 00 00 restore <== NOT EXECUTED 02003884 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 2003884: 9d e3 bf 58 save %sp, -168, %sp /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 2003888: c2 06 00 00 ld [ %i0 ], %g1 200388c: c2 27 bf dc st %g1, [ %fp + -36 ] if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 2003890: c4 10 60 30 lduh [ %g1 + 0x30 ], %g2 2003894: 80 a0 a0 07 cmp %g2, 7 2003898: 18 80 00 1b bgu 2003904 200389c: 90 10 00 1a mov %i2, %o0 /* * Remove any separators at the end of the string. */ IMFS_get_token( token, new_name, &i ); 20038a0: a0 07 bf bb add %fp, -69, %l0 20038a4: 94 07 bf f4 add %fp, -12, %o2 20038a8: 7f ff ff 6a call 2003650 20038ac: 92 10 00 10 mov %l0, %o1 /* * Create a new link node. */ new_node = IMFS_create_node( 20038b0: 90 10 00 19 mov %i1, %o0 20038b4: 94 10 00 10 mov %l0, %o2 20038b8: 92 10 20 03 mov 3, %o1 20038bc: 17 00 00 28 sethi %hi(0xa000), %o3 20038c0: 98 07 bf dc add %fp, -36, %o4 20038c4: 40 00 4a 76 call 201629c 20038c8: 96 12 e1 ff or %o3, 0x1ff, %o3 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 20038cc: 80 a2 20 00 cmp %o0, 0 20038d0: 02 80 00 13 be 200391c 20038d4: c4 07 bf dc ld [ %fp + -36 ], %g2 /* * 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 ); 20038d8: 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++; 20038dc: c2 10 a0 30 lduh [ %g2 + 0x30 ], %g1 IMFS_update_ctime( info.hard_link.link_node ); 20038e0: 92 10 20 00 clr %o1 /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 20038e4: 82 00 60 01 inc %g1 IMFS_update_ctime( info.hard_link.link_node ); 20038e8: 40 00 02 00 call 20040e8 20038ec: c2 30 a0 30 sth %g1, [ %g2 + 0x30 ] 20038f0: c4 07 bf ec ld [ %fp + -20 ], %g2 20038f4: c2 07 bf dc ld [ %fp + -36 ], %g1 20038f8: c4 20 60 44 st %g2, [ %g1 + 0x44 ] return 0; } 20038fc: 81 c7 e0 08 ret 2003900: 91 e8 20 00 restore %g0, 0, %o0 * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) rtems_set_errno_and_return_minus_one( EMLINK ); 2003904: 40 00 87 c5 call 2025818 <__errno> 2003908: b0 10 3f ff mov -1, %i0 200390c: 82 10 20 1f mov 0x1f, %g1 2003910: c2 22 00 00 st %g1, [ %o0 ] 2003914: 81 c7 e0 08 ret 2003918: 81 e8 00 00 restore ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 200391c: 40 00 87 bf call 2025818 <__errno> <== NOT EXECUTED 2003920: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003924: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 2003928: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200392c: 81 c7 e0 08 ret <== NOT EXECUTED 2003930: 81 e8 00 00 restore <== NOT EXECUTED 0201b7b0 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 201b7b0: 9d e3 bf 98 save %sp, -104, %sp block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 201b7b4: 80 a6 20 00 cmp %i0, 0 201b7b8: 02 80 00 26 be 201b850 201b7bc: 92 10 21 69 mov 0x169, %o1 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 201b7c0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201b7c4: 80 a0 60 05 cmp %g1, 5 201b7c8: 02 80 00 0b be 201b7f4 201b7cc: 11 00 80 e0 sethi %hi(0x2038000), %o0 201b7d0: 92 10 21 6d mov 0x16d, %o1 <== NOT EXECUTED 201b7d4: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b7d8: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b7dc: 7f ff a1 79 call 2003dc0 <__assert> <== NOT EXECUTED 201b7e0: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 20380b8 <_POSIX_Threads_Default_attributes+0x98> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 201b7e4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 201b7e8: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 201b7ec: 12 80 00 13 bne 201b838 <== NOT EXECUTED 201b7f0: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 201b7f4: 90 10 00 18 mov %i0, %o0 201b7f8: 92 10 00 19 mov %i1, %o1 201b7fc: 7f ff fe 54 call 201b14c 201b800: 94 10 20 01 mov 1, %o2 if ( *block_entry_ptr ) 201b804: 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 ); 201b808: b2 10 00 08 mov %o0, %i1 if ( *block_entry_ptr ) 201b80c: 80 a0 60 00 cmp %g1, 0 201b810: 12 80 00 0e bne 201b848 201b814: b0 10 20 00 clr %i0 #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 201b818: 7f ff fe 40 call 201b118 201b81c: b0 10 20 01 mov 1, %i0 if ( !memory ) 201b820: 80 a2 20 00 cmp %o0, 0 201b824: 02 80 00 14 be 201b874 201b828: 01 00 00 00 nop return 1; *block_entry_ptr = memory; 201b82c: d0 26 40 00 st %o0, [ %i1 ] return 0; } 201b830: 81 c7 e0 08 ret 201b834: 91 e8 20 00 restore %g0, 0, %o0 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 201b838: 40 00 27 f8 call 2025818 <__errno> <== NOT EXECUTED 201b83c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201b840: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 201b844: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b848: 81 c7 e0 08 ret 201b84c: 81 e8 00 00 restore ) { block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 201b850: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201b854: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b858: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b85c: 7f ff a1 59 call 2003dc0 <__assert> <== NOT EXECUTED 201b860: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); 201b864: 40 00 27 ed call 2025818 <__errno> <== NOT EXECUTED 201b868: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201b86c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 201b870: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b874: 81 c7 e0 08 ret <== NOT EXECUTED 201b878: 81 e8 00 00 restore <== NOT EXECUTED 0201b87c : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 201b87c: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201b880: 80 a6 20 00 cmp %i0, 0 201b884: 02 80 00 56 be 201b9dc 201b888: 92 10 21 31 mov 0x131, %o1 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 201b88c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201b890: 80 a0 60 05 cmp %g1, 5 201b894: 02 80 00 0b be 201b8c0 201b898: 92 10 21 35 mov 0x135, %o1 201b89c: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201b8a0: 90 12 20 58 or %o0, 0x58, %o0 ! 2038058 <_POSIX_Threads_Default_attributes+0x38> <== NOT EXECUTED 201b8a4: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b8a8: 7f ff a1 46 call 2003dc0 <__assert> <== NOT EXECUTED 201b8ac: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 20380b8 <_POSIX_Threads_Default_attributes+0x98> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 201b8b0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 201b8b4: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 201b8b8: 12 80 00 3d bne 201b9ac <== NOT EXECUTED 201b8bc: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 201b8c0: 03 00 80 f1 sethi %hi(0x203c400), %g1 201b8c4: e2 00 63 cc ld [ %g1 + 0x3cc ], %l1 ! 203c7cc 201b8c8: a1 34 60 02 srl %l1, 2, %l0 201b8cc: 92 10 00 10 mov %l0, %o1 201b8d0: 40 00 64 14 call 2034920 <.umul> 201b8d4: 90 04 20 01 add %l0, 1, %o0 201b8d8: 92 10 00 10 mov %l0, %o1 201b8dc: 40 00 64 11 call 2034920 <.umul> 201b8e0: 90 02 20 01 inc %o0 201b8e4: 92 10 00 11 mov %l1, %o1 201b8e8: 40 00 64 0e call 2034920 <.umul> 201b8ec: 90 02 3f ff add %o0, -1, %o0 201b8f0: 80 a6 40 08 cmp %i1, %o0 201b8f4: 1a 80 00 34 bcc 201b9c4 201b8f8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( new_length <= the_jnode->info.file.size ) 201b8fc: e0 06 20 4c ld [ %i0 + 0x4c ], %l0 201b900: 80 a6 40 10 cmp %i1, %l0 201b904: 04 80 00 24 ble 201b994 201b908: 82 10 20 00 clr %g1 /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 201b90c: 92 10 00 11 mov %l1, %o1 201b910: 40 00 64 40 call 2034a10 <.div> 201b914: 90 10 00 19 mov %i1, %o0 old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 201b918: 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; 201b91c: a4 10 00 08 mov %o0, %l2 old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 201b920: 40 00 64 3c call 2034a10 <.div> 201b924: 90 10 00 10 mov %l0, %o0 /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 201b928: 80 a4 80 08 cmp %l2, %o0 201b92c: 0a 80 00 1c bcs 201b99c 201b930: a2 10 00 08 mov %o0, %l1 201b934: 10 80 00 05 b 201b948 201b938: a0 10 00 08 mov %o0, %l0 201b93c: 80 a4 80 10 cmp %l2, %l0 201b940: 2a 80 00 18 bcs,a 201b9a0 201b944: f2 26 20 4c st %i1, [ %i0 + 0x4c ] if ( IMFS_memfile_addblock( the_jnode, block ) ) { 201b948: 92 10 00 10 mov %l0, %o1 201b94c: 7f ff ff 99 call 201b7b0 201b950: 90 10 00 18 mov %i0, %o0 201b954: 80 a2 20 00 cmp %o0, 0 201b958: 22 bf ff f9 be,a 201b93c 201b95c: a0 04 20 01 inc %l0 for ( ; block>=old_blocks ; block-- ) { 201b960: 10 80 00 06 b 201b978 <== NOT EXECUTED 201b964: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); 201b968: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 201b96c: 7f ff fe ac call 201b41c <== NOT EXECUTED 201b970: 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-- ) { 201b974: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED 201b978: 08 bf ff fc bleu 201b968 <== NOT EXECUTED 201b97c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 201b980: 40 00 27 a6 call 2025818 <__errno> <== NOT EXECUTED 201b984: 01 00 00 00 nop <== NOT EXECUTED 201b988: 82 10 20 1c mov 0x1c, %g1 ! 1c <== NOT EXECUTED 201b98c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b990: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 201b994: 81 c7 e0 08 ret 201b998: 91 e8 00 01 restore %g0, %g1, %o0 /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 201b99c: f2 26 20 4c st %i1, [ %i0 + 0x4c ] <== NOT EXECUTED 201b9a0: 82 10 20 00 clr %g1 return 0; } 201b9a4: 81 c7 e0 08 ret 201b9a8: 91 e8 00 01 restore %g0, %g1, %o0 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 201b9ac: 40 00 27 9b call 2025818 <__errno> <== NOT EXECUTED 201b9b0: 01 00 00 00 nop <== NOT EXECUTED 201b9b4: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201b9b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b9bc: 10 bf ff f6 b 201b994 <== NOT EXECUTED 201b9c0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) rtems_set_errno_and_return_minus_one( EINVAL ); 201b9c4: 40 00 27 95 call 2025818 <__errno> <== NOT EXECUTED 201b9c8: 01 00 00 00 nop <== NOT EXECUTED 201b9cc: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 201b9d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b9d4: 10 bf ff f0 b 201b994 <== NOT EXECUTED 201b9d8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 201b9dc: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201b9e0: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b9e4: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b9e8: 7f ff a0 f6 call 2003dc0 <__assert> <== NOT EXECUTED 201b9ec: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); 201b9f0: 40 00 27 8a call 2025818 <__errno> <== NOT EXECUTED 201b9f4: 01 00 00 00 nop <== NOT EXECUTED 201b9f8: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201b9fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201ba00: 10 bf ff e5 b 201b994 <== NOT EXECUTED 201ba04: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 0201b14c : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 201b14c: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201b150: 80 a6 20 00 cmp %i0, 0 201b154: 02 80 00 76 be 201b32c 201b158: 11 00 80 e0 sethi %hi(0x2038000), %o0 if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 201b15c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201b160: 80 a0 60 05 cmp %g1, 5 201b164: 12 80 00 2f bne 201b220 201b168: 92 10 23 8a mov 0x38a, %o1 /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 201b16c: 03 00 80 f1 sethi %hi(0x203c400), %g1 201b170: c4 00 63 cc ld [ %g1 + 0x3cc ], %g2 ! 203c7cc 201b174: a3 30 a0 02 srl %g2, 2, %l1 201b178: 82 04 7f ff add %l1, -1, %g1 201b17c: 80 a6 40 01 cmp %i1, %g1 201b180: 08 80 00 20 bleu 201b200 201b184: 80 a6 a0 00 cmp %i2, 0 /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 201b188: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED 201b18c: 40 00 65 e5 call 2034920 <.umul> <== NOT EXECUTED 201b190: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201b194: 82 02 3f ff add %o0, -1, %g1 <== NOT EXECUTED 201b198: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 201b19c: 18 80 00 31 bgu 201b260 <== NOT EXECUTED 201b1a0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 201b1a4: a0 26 40 11 sub %i1, %l1, %l0 <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 201b1a8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201b1ac: 40 00 66 c3 call 2034cb8 <.urem> <== NOT EXECUTED 201b1b0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 201b1b4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 201b1b8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 201b1bc: 40 00 66 13 call 2034a08 <.udiv> <== NOT EXECUTED 201b1c0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { 201b1c4: 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; 201b1c8: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { 201b1cc: 02 80 00 4e be 201b304 <== NOT EXECUTED 201b1d0: e0 06 20 54 ld [ %i0 + 0x54 ], %l0 <== NOT EXECUTED if ( !p ) { 201b1d4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 201b1d8: 02 80 00 63 be 201b364 <== NOT EXECUTED 201b1dc: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 201b1e0: a3 2c 60 02 sll %l1, 2, %l1 <== NOT EXECUTED 201b1e4: c2 04 40 10 ld [ %l1 + %l0 ], %g1 <== NOT EXECUTED if ( !p1 ) { 201b1e8: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 201b1ec: 02 80 00 65 be 201b380 <== NOT EXECUTED 201b1f0: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) return 0; p[ doubly ] = (block_p) p1; } return (block_p *)&p1[ singly ]; 201b1f4: 83 2c a0 02 sll %l2, 2, %g1 <== NOT EXECUTED 201b1f8: 81 c7 e0 08 ret <== NOT EXECUTED 201b1fc: 91 e8 40 08 restore %g1, %o0, %o0 <== NOT EXECUTED fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; if ( malloc_it ) { 201b200: 02 80 00 12 be 201b248 201b204: d0 06 20 50 ld [ %i0 + 0x50 ], %o0 if ( !p ) { 201b208: 80 a2 20 00 cmp %o0, 0 201b20c: 02 80 00 4f be 201b348 201b210: 01 00 00 00 nop p = memfile_alloc_block(); if ( !p ) return 0; info->indirect = p; } return &info->indirect[ my_block ]; 201b214: 83 2e 60 02 sll %i1, 2, %g1 201b218: 81 c7 e0 08 ret 201b21c: 91 e8 40 08 restore %g1, %o0, %o0 assert( the_jnode ); if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 201b220: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b224: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b228: 7f ff a2 e6 call 2003dc0 <__assert> <== NOT EXECUTED 201b22c: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 20380b8 <_POSIX_Threads_Default_attributes+0x98> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 201b230: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 201b234: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 201b238: 02 bf ff ce be 201b170 <== NOT EXECUTED 201b23c: 03 00 80 f1 sethi %hi(0x203c400), %g1 <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 201b240: 81 c7 e0 08 ret <== NOT EXECUTED 201b244: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED } if ( !p ) return 0; return &info->indirect[ my_block ]; 201b248: 83 2e 60 02 sll %i1, 2, %g1 info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 201b24c: 80 a2 20 00 cmp %o0, 0 201b250: 02 bf ff fc be 201b240 201b254: b0 02 00 01 add %o0, %g1, %i0 /* * This means the requested block number is out of range. */ return 0; } 201b258: 81 c7 e0 08 ret 201b25c: 81 e8 00 00 restore #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 201b260: 90 02 20 01 inc %o0 <== NOT EXECUTED 201b264: 40 00 65 af call 2034920 <.umul> <== NOT EXECUTED 201b268: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201b26c: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED 201b270: 80 a6 40 08 cmp %i1, %o0 <== NOT EXECUTED 201b274: 18 bf ff f3 bgu 201b240 <== NOT EXECUTED 201b278: a0 26 40 10 sub %i1, %l0, %l0 <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 201b27c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201b280: 40 00 66 8e call 2034cb8 <.urem> <== NOT EXECUTED 201b284: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 201b288: 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; 201b28c: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; 201b290: 40 00 65 de call 2034a08 <.udiv> <== NOT EXECUTED 201b294: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 201b298: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 201b29c: 40 00 65 db call 2034a08 <.udiv> <== NOT EXECUTED 201b2a0: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; 201b2a4: 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; 201b2a8: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; 201b2ac: 40 00 66 83 call 2034cb8 <.urem> <== NOT EXECUTED 201b2b0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { 201b2b4: 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; 201b2b8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { 201b2bc: 02 80 00 38 be 201b39c <== NOT EXECUTED 201b2c0: e0 06 20 58 ld [ %i0 + 0x58 ], %l0 <== NOT EXECUTED if ( !p ) { 201b2c4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 201b2c8: 02 80 00 40 be 201b3c8 <== NOT EXECUTED 201b2cc: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 201b2d0: a5 2c a0 02 sll %l2, 2, %l2 <== NOT EXECUTED 201b2d4: c2 04 80 10 ld [ %l2 + %l0 ], %g1 <== NOT EXECUTED if ( !p1 ) { 201b2d8: a2 90 60 00 orcc %g1, 0, %l1 <== NOT EXECUTED 201b2dc: 02 80 00 49 be 201b400 <== NOT EXECUTED 201b2e0: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 201b2e4: a1 2e 60 02 sll %i1, 2, %l0 <== NOT EXECUTED 201b2e8: c2 04 00 11 ld [ %l0 + %l1 ], %g1 <== NOT EXECUTED if ( !p2 ) { 201b2ec: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 201b2f0: 02 80 00 3d be 201b3e4 <== NOT EXECUTED 201b2f4: 01 00 00 00 nop <== NOT EXECUTED p2 = memfile_alloc_block(); if ( !p2 ) return 0; p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; 201b2f8: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED 201b2fc: 81 c7 e0 08 ret <== NOT EXECUTED 201b300: 91 e8 40 08 restore %g1, %o0, %o0 <== NOT EXECUTED } return (block_p *)&p1[ singly ]; } if ( !p ) 201b304: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 201b308: 02 bf ff ce be 201b240 <== NOT EXECUTED 201b30c: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 201b310: c4 04 00 01 ld [ %l0 + %g1 ], %g2 <== 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 ]; 201b314: 87 2c a0 02 sll %l2, 2, %g3 <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 201b318: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201b31c: 02 bf ff c9 be 201b240 <== NOT EXECUTED 201b320: b0 00 c0 02 add %g3, %g2, %i0 <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 201b324: 81 c7 e0 08 ret <== NOT EXECUTED 201b328: 81 e8 00 00 restore <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 201b32c: 92 10 23 86 mov 0x386, %o1 <== NOT EXECUTED 201b330: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b334: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b338: 7f ff a2 a2 call 2003dc0 <__assert> <== NOT EXECUTED 201b33c: 94 12 a0 a8 or %o2, 0xa8, %o2 ! 20380a8 <_POSIX_Threads_Default_attributes+0x88> <== NOT EXECUTED 201b340: 81 c7 e0 08 ret <== NOT EXECUTED 201b344: 81 e8 00 00 restore <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 201b348: 7f ff ff 74 call 201b118 201b34c: 01 00 00 00 nop if ( !p ) 201b350: 80 a2 20 00 cmp %o0, 0 201b354: 02 bf ff bb be 201b240 201b358: 01 00 00 00 nop return 0; info->indirect = p; 201b35c: 10 bf ff ae b 201b214 201b360: d0 26 20 50 st %o0, [ %i0 + 0x50 ] p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 201b364: 7f ff ff 6d call 201b118 <== NOT EXECUTED 201b368: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) 201b36c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201b370: 02 bf ff b4 be 201b240 <== NOT EXECUTED 201b374: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED return 0; info->doubly_indirect = p; 201b378: 10 bf ff 9a b 201b1e0 <== NOT EXECUTED 201b37c: d0 26 20 54 st %o0, [ %i0 + 0x54 ] <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 201b380: 7f ff ff 66 call 201b118 <== NOT EXECUTED 201b384: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) 201b388: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 201b38c: 02 bf ff ad be 201b240 <== NOT EXECUTED 201b390: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 201b394: 10 bf ff 98 b 201b1f4 <== NOT EXECUTED 201b398: c2 24 40 10 st %g1, [ %l1 + %l0 ] <== NOT EXECUTED p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 201b39c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 201b3a0: 02 bf ff a8 be 201b240 <== NOT EXECUTED 201b3a4: 83 2c a0 02 sll %l2, 2, %g1 <== 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 ]; 201b3a8: d0 04 00 01 ld [ %l0 + %g1 ], %o0 <== NOT EXECUTED if ( !p1 ) 201b3ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201b3b0: 02 bf ff a4 be 201b240 <== NOT EXECUTED 201b3b4: 83 2e 60 02 sll %i1, 2, %g1 <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 201b3b8: c6 02 00 01 ld [ %o0 + %g1 ], %g3 <== NOT EXECUTED 201b3bc: 85 2c e0 02 sll %l3, 2, %g2 <== NOT EXECUTED 201b3c0: 81 c7 e0 08 ret <== NOT EXECUTED 201b3c4: 91 e8 80 03 restore %g2, %g3, %o0 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 201b3c8: 7f ff ff 54 call 201b118 <== NOT EXECUTED 201b3cc: 01 00 00 00 nop <== NOT EXECUTED if ( !p ) 201b3d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201b3d4: 02 bf ff 9b be 201b240 <== NOT EXECUTED 201b3d8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED return 0; info->triply_indirect = p; 201b3dc: 10 bf ff bd b 201b2d0 <== NOT EXECUTED 201b3e0: d0 26 20 58 st %o0, [ %i0 + 0x58 ] <== NOT EXECUTED p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 201b3e4: 7f ff ff 4d call 201b118 <== NOT EXECUTED 201b3e8: 01 00 00 00 nop <== NOT EXECUTED if ( !p2 ) 201b3ec: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 201b3f0: 02 bf ff 94 be 201b240 <== NOT EXECUTED 201b3f4: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 201b3f8: 10 bf ff c0 b 201b2f8 <== NOT EXECUTED 201b3fc: c2 24 00 11 st %g1, [ %l0 + %l1 ] <== NOT EXECUTED info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 201b400: 7f ff ff 46 call 201b118 <== NOT EXECUTED 201b404: 01 00 00 00 nop <== NOT EXECUTED if ( !p1 ) 201b408: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED 201b40c: 02 bf ff 8d be 201b240 <== NOT EXECUTED 201b410: a2 10 00 01 mov %g1, %l1 <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 201b414: 10 bf ff b4 b 201b2e4 <== NOT EXECUTED 201b418: c2 24 80 10 st %g1, [ %l2 + %l0 ] <== NOT EXECUTED 0201be70 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 201be70: 9d e3 bf 90 save %sp, -112, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201be74: a4 96 20 00 orcc %i0, 0, %l2 201be78: 02 80 00 ac be 201c128 201be7c: 92 10 22 4a mov 0x24a, %o1 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 201be80: c4 04 a0 48 ld [ %l2 + 0x48 ], %g2 201be84: 82 00 bf fb add %g2, -5, %g1 201be88: 80 a0 60 01 cmp %g1, 1 201be8c: 08 80 00 0c bleu 201bebc 201be90: 11 00 80 e0 sethi %hi(0x2038000), %o0 201be94: 92 10 22 4f mov 0x24f, %o1 <== NOT EXECUTED 201be98: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201be9c: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bea0: 7f ff 9f c8 call 2003dc0 <__assert> <== NOT EXECUTED 201bea4: 94 12 a1 08 or %o2, 0x108, %o2 ! 2038108 <_POSIX_Threads_Default_attributes+0xe8> <== NOT EXECUTED the_jnode->type == IMFS_LINEAR_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE && 201bea8: c4 04 a0 48 ld [ %l2 + 0x48 ], %g2 <== NOT EXECUTED 201beac: 82 00 bf fb add %g2, -5, %g1 <== NOT EXECUTED 201beb0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201beb4: 18 80 00 82 bgu 201c0bc <== NOT EXECUTED 201beb8: 01 00 00 00 nop <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 201bebc: 80 a6 a0 00 cmp %i2, 0 201bec0: 02 80 00 a5 be 201c154 201bec4: 80 a6 e0 00 cmp %i3, 0 /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 201bec8: 02 80 00 92 be 201c110 201becc: 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) { 201bed0: 02 80 00 4e be 201c008 201bed4: 82 06 c0 19 add %i3, %i1, %g1 * 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 ) 201bed8: c4 04 a0 4c ld [ %l2 + 0x4c ], %g2 201bedc: 80 a0 40 02 cmp %g1, %g2 201bee0: 18 80 00 31 bgu 201bfa4 201bee4: a2 10 00 1b mov %i3, %l1 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 201bee8: 27 00 80 f1 sethi %hi(0x203c400), %l3 201beec: f6 04 e3 cc ld [ %l3 + 0x3cc ], %i3 ! 203c7cc 201bef0: 90 10 00 19 mov %i1, %o0 201bef4: 40 00 63 73 call 2034cc0 <.rem> 201bef8: 92 10 00 1b mov %i3, %o1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 201befc: 92 10 00 1b mov %i3, %o1 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 201bf00: a8 10 00 08 mov %o0, %l4 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 201bf04: 40 00 62 c3 call 2034a10 <.div> 201bf08: 90 10 00 19 mov %i1, %o0 if ( start_offset ) { 201bf0c: 80 a5 20 00 cmp %l4, 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; 201bf10: b2 10 00 08 mov %o0, %i1 if ( start_offset ) { 201bf14: a0 10 00 1a mov %i2, %l0 201bf18: 12 80 00 4d bne 201c04c 201bf1c: b0 10 20 00 clr %i0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201bf20: f4 04 e3 cc ld [ %l3 + 0x3cc ], %i2 while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bf24: 80 a4 40 1a cmp %l1, %i2 201bf28: 1a 80 00 0e bcc 201bf60 201bf2c: 92 10 00 19 mov %i1, %o1 * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 201bf30: 10 80 00 20 b 201bfb0 201bf34: 80 a4 60 00 cmp %l1, 0 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 ); 201bf38: d2 02 40 00 ld [ %o1 ], %o1 201bf3c: 40 00 2c eb call 20272e8 201bf40: a2 24 40 1a sub %l1, %i2, %l1 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bf44: c2 04 e3 cc ld [ %l3 + 0x3cc ], %g1 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 ); 201bf48: a0 04 00 1a add %l0, %i2, %l0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bf4c: 80 a0 40 11 cmp %g1, %l1 assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); dest += to_copy; block++; 201bf50: b2 06 60 01 inc %i1 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bf54: 18 80 00 16 bgu 201bfac 201bf58: b0 06 00 1a add %i0, %i2, %i0 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bf5c: 92 10 00 19 mov %i1, %o1 201bf60: 94 10 20 00 clr %o2 201bf64: 7f ff fc 7a call 201b14c 201bf68: 90 10 00 12 mov %l2, %o0 assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 201bf6c: 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 ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bf70: 92 10 00 08 mov %o0, %o1 assert( block_ptr ); 201bf74: 80 a2 60 00 cmp %o1, 0 201bf78: 12 bf ff f0 bne 201bf38 201bf7c: 90 10 00 10 mov %l0, %o0 201bf80: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201bf84: 92 10 22 a5 mov 0x2a5, %o1 <== NOT EXECUTED 201bf88: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bf8c: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bf90: 7f ff 9f 8c call 2003dc0 <__assert> <== NOT EXECUTED 201bf94: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 20380f8 <_POSIX_Threads_Default_attributes+0xd8> <== NOT EXECUTED if ( !block_ptr ) return copied; 201bf98: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 201bf9c: 81 c7 e0 08 ret <== NOT EXECUTED 201bfa0: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) my_length = the_jnode->info.file.size - start; 201bfa4: 10 bf ff d1 b 201bee8 201bfa8: a2 20 80 19 sub %g2, %i1, %l1 * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 201bfac: 80 a4 60 00 cmp %l1, 0 201bfb0: 02 80 00 0f be 201bfec 201bfb4: 90 07 bf f0 add %fp, -16, %o0 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bfb8: 92 10 00 19 mov %i1, %o1 201bfbc: 90 10 00 12 mov %l2, %o0 201bfc0: 7f ff fc 63 call 201b14c 201bfc4: 94 10 20 00 clr %o2 assert( block_ptr ); 201bfc8: 80 a2 20 00 cmp %o0, 0 201bfcc: 22 80 00 4a be,a 201c0f4 201bfd0: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 201bfd4: d2 02 00 00 ld [ %o0 ], %o1 copied += my_length; 201bfd8: b0 06 00 11 add %i0, %l1, %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 ); 201bfdc: 90 10 00 10 mov %l0, %o0 201bfe0: 40 00 2c c2 call 20272e8 201bfe4: 94 10 00 11 mov %l1, %o2 copied += my_length; } IMFS_update_atime( the_jnode ); 201bfe8: 90 07 bf f0 add %fp, -16, %o0 201bfec: 7f ff a0 3f call 20040e8 201bff0: 92 10 20 00 clr %o1 201bff4: c2 07 bf f0 ld [ %fp + -16 ], %g1 return copied; 201bff8: 94 10 00 18 mov %i0, %o2 return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( the_jnode ); 201bffc: c2 24 a0 3c st %g1, [ %l2 + 0x3c ] return copied; } 201c000: 81 c7 e0 08 ret 201c004: 91 e8 00 0a restore %g0, %o2, %o0 if (the_jnode->type == IMFS_LINEAR_FILE) { unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 201c008: c2 04 a0 4c ld [ %l2 + 0x4c ], %g1 <== NOT EXECUTED 201c00c: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED 201c010: 82 20 40 19 sub %g1, %i1, %g1 <== NOT EXECUTED 201c014: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED 201c018: 18 80 00 22 bgu 201c0a0 <== NOT EXECUTED 201c01c: d2 04 a0 50 ld [ %l2 + 0x50 ], %o1 <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 201c020: 92 02 40 19 add %o1, %i1, %o1 <== NOT EXECUTED 201c024: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 201c028: 40 00 2c b0 call 20272e8 <== NOT EXECUTED 201c02c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( the_jnode ); 201c030: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED 201c034: 7f ff a0 2d call 20040e8 <== NOT EXECUTED 201c038: 92 10 20 00 clr %o1 <== NOT EXECUTED 201c03c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED return copied; 201c040: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( the_jnode ); 201c044: 10 bf ff ef b 201c000 <== NOT EXECUTED 201c048: c2 24 a0 3c st %g1, [ %l2 + 0x3c ] <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201c04c: 90 10 00 12 mov %l2, %o0 201c050: 92 10 00 19 mov %i1, %o1 201c054: 7f ff fc 3e call 201b14c 201c058: 94 10 20 00 clr %o2 assert( block_ptr ); 201c05c: 80 a2 20 00 cmp %o0, 0 201c060: 02 80 00 1d be 201c0d4 201c064: 92 26 c0 14 sub %i3, %l4, %o1 */ 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; 201c068: 80 a4 40 09 cmp %l1, %o1 201c06c: 08 80 00 03 bleu 201c078 201c070: 94 10 00 11 mov %l1, %o2 201c074: 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 ); 201c078: d2 02 00 00 ld [ %o0 ], %o1 dest += to_copy; 201c07c: a0 06 80 0a add %i2, %o2, %l0 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 ); 201c080: 92 05 00 09 add %l4, %o1, %o1 dest += to_copy; block++; 201c084: b2 06 60 01 inc %i1 my_length -= to_copy; 201c088: a2 24 40 0a sub %l1, %o2, %l1 201c08c: 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 ); 201c090: 40 00 2c 96 call 20272e8 201c094: 90 10 00 1a mov %i2, %o0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201c098: 10 bf ff a3 b 201bf24 201c09c: f4 04 e3 cc ld [ %l3 + 0x3cc ], %i2 unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) my_length = the_jnode->info.linearfile.size - start; 201c0a0: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED memcpy(dest, &file_ptr[start], my_length); 201c0a4: 92 02 40 19 add %o1, %i1, %o1 <== NOT EXECUTED 201c0a8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 201c0ac: 40 00 2c 8f call 20272e8 <== NOT EXECUTED 201c0b0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); copied += my_length; } IMFS_update_atime( the_jnode ); 201c0b4: 10 bf ff e0 b 201c034 <== NOT EXECUTED 201c0b8: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED assert( the_jnode->type == IMFS_MEMORY_FILE || the_jnode->type == IMFS_LINEAR_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE && the_jnode->type != IMFS_LINEAR_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 201c0bc: 40 00 25 d7 call 2025818 <__errno> <== NOT EXECUTED 201c0c0: 01 00 00 00 nop <== NOT EXECUTED 201c0c4: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201c0c8: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 201c0cc: 10 bf ff b4 b 201bf9c <== NOT EXECUTED 201c0d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); 201c0d4: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201c0d8: 92 10 22 94 mov 0x294, %o1 <== NOT EXECUTED 201c0dc: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201c0e0: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201c0e4: 7f ff 9f 37 call 2003dc0 <__assert> <== NOT EXECUTED 201c0e8: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 20380f8 <_POSIX_Threads_Default_attributes+0xd8> <== NOT EXECUTED 201c0ec: 10 bf ff ac b 201bf9c <== NOT EXECUTED 201c0f0: 94 10 20 00 clr %o2 <== NOT EXECUTED assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); 201c0f4: 92 10 22 b7 mov 0x2b7, %o1 <== NOT EXECUTED 201c0f8: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201c0fc: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201c100: 7f ff 9f 30 call 2003dc0 <__assert> <== NOT EXECUTED 201c104: 94 12 a0 f8 or %o2, 0xf8, %o2 ! 20380f8 <_POSIX_Threads_Default_attributes+0xd8> <== NOT EXECUTED if ( !block_ptr ) return copied; 201c108: 10 bf ff a5 b 201bf9c <== NOT EXECUTED 201c10c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) rtems_set_errno_and_return_minus_one( EINVAL ); 201c110: 40 00 25 c2 call 2025818 <__errno> <== NOT EXECUTED 201c114: 01 00 00 00 nop <== NOT EXECUTED 201c118: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 201c11c: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 201c120: 10 bf ff 9f b 201bf9c <== NOT EXECUTED 201c124: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 201c128: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201c12c: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201c130: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201c134: 7f ff 9f 23 call 2003dc0 <__assert> <== NOT EXECUTED 201c138: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); 201c13c: 40 00 25 b7 call 2025818 <__errno> <== NOT EXECUTED 201c140: 01 00 00 00 nop <== NOT EXECUTED 201c144: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201c148: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 201c14c: 10 bf ff 94 b 201bf9c <== NOT EXECUTED 201c150: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 201c154: 92 10 22 58 mov 0x258, %o1 <== NOT EXECUTED 201c158: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201c15c: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201c160: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201c164: 7f ff 9f 17 call 2003dc0 <__assert> <== NOT EXECUTED 201c168: 94 12 a1 58 or %o2, 0x158, %o2 <== NOT EXECUTED if ( !dest ) rtems_set_errno_and_return_minus_one( EINVAL ); 201c16c: 40 00 25 ab call 2025818 <__errno> <== NOT EXECUTED 201c170: 01 00 00 00 nop <== NOT EXECUTED 201c174: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 201c178: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 201c17c: 10 bf ff 88 b 201bf9c <== NOT EXECUTED 201c180: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 0201b4c8 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 201b4c8: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201b4cc: 80 a6 20 00 cmp %i0, 0 201b4d0: 02 80 00 74 be 201b6a0 201b4d4: 92 10 21 ec mov 0x1ec, %o1 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 201b4d8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201b4dc: 80 a0 60 05 cmp %g1, 5 201b4e0: 02 80 00 0b be 201b50c 201b4e4: 11 00 80 e0 sethi %hi(0x2038000), %o0 201b4e8: 92 10 21 f0 mov 0x1f0, %o1 <== NOT EXECUTED 201b4ec: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b4f0: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b4f4: 7f ff a2 33 call 2003dc0 <__assert> <== NOT EXECUTED 201b4f8: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 20380b8 <_POSIX_Threads_Default_attributes+0x98> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 201b4fc: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 201b500: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 201b504: 12 80 00 5a bne 201b66c <== NOT EXECUTED 201b508: 01 00 00 00 nop <== NOT EXECUTED /* * 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; 201b50c: 25 00 80 f1 sethi %hi(0x203c400), %l2 * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 201b510: 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; 201b514: c4 04 a3 cc ld [ %l2 + 0x3cc ], %g2 * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 201b518: 80 a0 60 00 cmp %g1, 0 201b51c: 02 80 00 05 be 201b530 201b520: a7 30 a0 02 srl %g2, 2, %l3 memfile_free_blocks_in_table( &info->indirect, to_free ); 201b524: 90 06 20 50 add %i0, 0x50, %o0 201b528: 7f ff ff c9 call 201b44c 201b52c: 92 10 00 13 mov %l3, %o1 } if ( info->doubly_indirect ) { 201b530: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 201b534: 80 a2 20 00 cmp %o0, 0 201b538: 02 80 00 19 be 201b59c 201b53c: c2 04 a3 cc ld [ %l2 + 0x3cc ], %g1 for ( i=0 ; i <== NOT EXECUTED 201b54c: 84 10 20 00 clr %g2 <== NOT EXECUTED 201b550: 10 80 00 03 b 201b55c <== NOT EXECUTED 201b554: a0 10 20 00 clr %l0 <== NOT EXECUTED 201b558: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 <== NOT EXECUTED if ( info->doubly_indirect[i] ) { 201b55c: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 201b560: c4 00 40 08 ld [ %g1 + %o0 ], %g2 <== NOT EXECUTED 201b564: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201b568: 02 80 00 04 be 201b578 <== NOT EXECUTED 201b56c: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED memfile_free_blocks_in_table( 201b570: 7f ff ff b7 call 201b44c <== NOT EXECUTED 201b574: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i <== NOT EXECUTED 201b58c: a0 10 00 02 mov %g2, %l0 <== 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 ); 201b590: 90 06 20 54 add %i0, 0x54, %o0 <== NOT EXECUTED 201b594: 7f ff ff ae call 201b44c <== NOT EXECUTED 201b598: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED } if ( info->triply_indirect ) { 201b59c: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 201b5a0: 80 a0 a0 00 cmp %g2, 0 201b5a4: 02 80 00 37 be 201b680 201b5a8: 82 10 20 00 clr %g1 for ( i=0 ; i <== NOT EXECUTED 201b5bc: 90 06 20 58 add %i0, 0x58, %o0 <== NOT EXECUTED p = (block_p *) info->triply_indirect[i]; 201b5c0: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 201b5c4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201b5c8: 02 80 00 31 be 201b68c <== NOT EXECUTED 201b5cc: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 201b5d0: a8 10 20 00 clr %l4 <== NOT EXECUTED 201b5d4: aa 10 20 00 clr %l5 <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j <== NOT EXECUTED 201b5e8: 90 05 40 02 add %l5, %g2, %o0 <== NOT EXECUTED 201b5ec: a2 10 20 00 clr %l1 <== NOT EXECUTED 201b5f0: 84 10 20 00 clr %g2 <== NOT EXECUTED if ( p[j] ) { 201b5f4: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 201b5f8: c4 00 40 10 ld [ %g1 + %l0 ], %g2 <== NOT EXECUTED 201b5fc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201b600: 02 80 00 04 be 201b610 <== NOT EXECUTED 201b604: 90 00 40 10 add %g1, %l0, %o0 <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 201b608: 7f ff ff 91 call 201b44c <== NOT EXECUTED 201b60c: 92 10 00 13 mov %l3, %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 201b624: a2 10 00 02 mov %g2, %l1 <== NOT EXECUTED 201b628: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 <== NOT EXECUTED if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 201b62c: 90 05 40 02 add %l5, %g2, %o0 <== NOT EXECUTED 201b630: 7f ff ff 87 call 201b44c <== NOT EXECUTED 201b634: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i <== NOT EXECUTED 201b64c: ab 2d 20 02 sll %l4, 2, %l5 <== NOT EXECUTED p = (block_p *) info->triply_indirect[i]; 201b650: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 <== NOT EXECUTED 201b654: c2 00 80 15 ld [ %g2 + %l5 ], %g1 <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 201b658: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201b65c: 02 80 00 0b be 201b688 <== NOT EXECUTED 201b660: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED break; for ( j=0 ; j <== NOT EXECUTED 201b668: c2 04 a3 cc ld [ %l2 + 0x3cc ], %g1 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 201b66c: 40 00 28 6b call 2025818 <__errno> <== NOT EXECUTED 201b670: 01 00 00 00 nop <== NOT EXECUTED 201b674: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201b678: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b67c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&info->triply_indirect, to_free ); } return 0; } 201b680: 81 c7 e0 08 ret 201b684: 91 e8 00 01 restore %g0, %g1, %o0 } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 201b688: 90 06 20 58 add %i0, 0x58, %o0 <== NOT EXECUTED 201b68c: 7f ff ff 70 call 201b44c <== NOT EXECUTED 201b690: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 201b694: 82 10 20 00 clr %g1 <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 201b698: 81 c7 e0 08 ret <== NOT EXECUTED 201b69c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 201b6a0: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201b6a4: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201b6a8: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201b6ac: 7f ff a1 c5 call 2003dc0 <__assert> <== NOT EXECUTED 201b6b0: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); 201b6b4: 40 00 28 59 call 2025818 <__errno> <== NOT EXECUTED 201b6b8: 01 00 00 00 nop <== NOT EXECUTED 201b6bc: 82 10 20 05 mov 5, %g1 ! 5 <== NOT EXECUTED 201b6c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201b6c4: 10 bf ff ef b 201b680 <== NOT EXECUTED 201b6c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED 0201b41c : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 201b41c: 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 ); 201b420: 94 10 20 00 clr %o2 <== NOT EXECUTED 201b424: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201b428: 7f ff ff 49 call 201b14c <== NOT EXECUTED 201b42c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ptr = *block_entry_ptr; 201b430: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED *block_entry_ptr = 0; memfile_free_block( ptr ); return 1; } 201b434: 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; 201b438: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED memfile_free_block( ptr ); 201b43c: 7f ff ff 2e call 201b0f4 <== NOT EXECUTED 201b440: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED return 1; } 201b444: 81 c7 e0 08 ret <== NOT EXECUTED 201b448: 81 e8 00 00 restore <== NOT EXECUTED 0201bad4 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 201bad4: 9d e3 bf 90 save %sp, -112, %sp /* * Perform internal consistency checks */ assert( the_jnode ); 201bad8: 80 a6 20 00 cmp %i0, 0 201badc: 02 80 00 99 be 201bd40 201bae0: 92 10 22 e1 mov 0x2e1, %o1 if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 201bae4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201bae8: 80 a0 60 05 cmp %g1, 5 201baec: 02 80 00 0b be 201bb18 201baf0: 11 00 80 e0 sethi %hi(0x2038000), %o0 201baf4: 92 10 22 e5 mov 0x2e5, %o1 <== NOT EXECUTED 201baf8: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bafc: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bb00: 7f ff a0 b0 call 2003dc0 <__assert> <== NOT EXECUTED 201bb04: 94 12 a0 b8 or %o2, 0xb8, %o2 ! 20380b8 <_POSIX_Threads_Default_attributes+0x98> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) 201bb08: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 <== NOT EXECUTED 201bb0c: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 201bb10: 12 80 00 82 bne 201bd18 <== NOT EXECUTED 201bb14: 01 00 00 00 nop <== NOT EXECUTED /* * Error check arguments */ assert( source ); 201bb18: 80 a6 a0 00 cmp %i2, 0 201bb1c: 02 80 00 93 be 201bd68 201bb20: 80 a6 e0 00 cmp %i3, 0 /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 201bb24: 02 80 00 82 be 201bd2c 201bb28: 92 06 c0 19 add %i3, %i1, %o1 * 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 ) { 201bb2c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 201bb30: 80 a2 40 01 cmp %o1, %g1 201bb34: 18 80 00 43 bgu 201bc40 201bb38: 25 00 80 f1 sethi %hi(0x203c400), %l2 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 201bb3c: e0 04 a3 cc ld [ %l2 + 0x3cc ], %l0 ! 203c7cc 201bb40: 90 10 00 19 mov %i1, %o0 201bb44: 40 00 64 5f call 2034cc0 <.rem> 201bb48: 92 10 00 10 mov %l0, %o1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 201bb4c: 92 10 00 10 mov %l0, %o1 /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 201bb50: a2 10 00 08 mov %o0, %l1 block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 201bb54: 40 00 63 af call 2034a10 <.div> 201bb58: 90 10 00 19 mov %i1, %o0 if ( start_offset ) { 201bb5c: 80 a4 60 00 cmp %l1, 0 201bb60: 12 80 00 42 bne 201bc68 201bb64: b2 10 00 08 mov %o0, %i1 201bb68: a0 10 00 1a mov %i2, %l0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201bb6c: f4 04 a3 cc ld [ %l2 + 0x3cc ], %i2 while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bb70: 80 a6 c0 1a cmp %i3, %i2 201bb74: 1a 80 00 0e bcc 201bbac 201bb78: 92 10 00 19 mov %i1, %o1 */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 201bb7c: 10 80 00 1c b 201bbec 201bb80: 80 a6 e0 00 cmp %i3, 0 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 ); 201bb84: d0 02 00 00 ld [ %o0 ], %o0 201bb88: 40 00 2d d8 call 20272e8 201bb8c: b6 26 c0 1a sub %i3, %i2, %i3 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bb90: c2 04 a3 cc ld [ %l2 + 0x3cc ], %g1 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 ); 201bb94: a0 04 00 1a add %l0, %i2, %l0 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bb98: 80 a0 40 1b cmp %g1, %i3 #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); src += to_copy; block++; 201bb9c: b2 06 60 01 inc %i1 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 201bba0: 18 80 00 12 bgu 201bbe8 201bba4: a2 04 40 1a add %l1, %i2, %l1 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bba8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201bbac: 94 10 20 00 clr %o2 201bbb0: 7f ff fd 67 call 201b14c 201bbb4: 90 10 00 18 mov %i0, %o0 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 ); 201bbb8: 92 10 00 10 mov %l0, %o1 */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); 201bbbc: 80 a2 20 00 cmp %o0, 0 201bbc0: 12 bf ff f1 bne 201bb84 201bbc4: 94 10 00 1a mov %i2, %o2 201bbc8: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201bbcc: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bbd0: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bbd4: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED 201bbd8: 7f ff a0 7a call 2003dc0 <__assert> <== NOT EXECUTED 201bbdc: 92 10 23 2e mov 0x32e, %o1 <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); return copied; } 201bbe0: 81 c7 e0 08 ret <== NOT EXECUTED 201bbe4: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 201bbe8: 80 a6 e0 00 cmp %i3, 0 201bbec: 02 80 00 0e be 201bc24 201bbf0: 90 07 bf f0 add %fp, -16, %o0 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bbf4: 92 10 00 19 mov %i1, %o1 201bbf8: 90 10 00 18 mov %i0, %o0 201bbfc: 7f ff fd 54 call 201b14c 201bc00: 94 10 20 00 clr %o2 assert( block_ptr ); 201bc04: 80 a2 20 00 cmp %o0, 0 201bc08: 02 80 00 3d be 201bcfc 201bc0c: 92 10 00 10 mov %l0, %o1 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 ); 201bc10: d0 02 00 00 ld [ %o0 ], %o0 my_length = 0; copied += to_copy; 201bc14: a2 04 40 1b add %l1, %i3, %l1 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 ); 201bc18: 40 00 2d b4 call 20272e8 201bc1c: 94 10 00 1b mov %i3, %o2 my_length = 0; copied += to_copy; } IMFS_atime_mtime_update( the_jnode ); 201bc20: 90 07 bf f0 add %fp, -16, %o0 201bc24: 7f ff a1 31 call 20040e8 201bc28: 92 10 20 00 clr %o1 201bc2c: c2 07 bf f0 ld [ %fp + -16 ], %g1 201bc30: c2 26 20 3c st %g1, [ %i0 + 0x3c ] 201bc34: c2 26 20 40 st %g1, [ %i0 + 0x40 ] return copied; } 201bc38: 81 c7 e0 08 ret 201bc3c: 91 e8 00 11 restore %g0, %l1, %o0 * in memory file, then extend the length. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) { status = IMFS_memfile_extend( the_jnode, last_byte ); 201bc40: 7f ff ff 0f call 201b87c 201bc44: 90 10 00 18 mov %i0, %o0 if ( status ) 201bc48: 80 a2 20 00 cmp %o0, 0 201bc4c: 02 bf ff bc be 201bb3c 201bc50: 25 00 80 f1 sethi %hi(0x203c400), %l2 rtems_set_errno_and_return_minus_one( ENOSPC ); 201bc54: 40 00 26 f1 call 2025818 <__errno> <== NOT EXECUTED 201bc58: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED 201bc5c: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED 201bc60: 10 bf ff e0 b 201bbe0 <== NOT EXECUTED 201bc64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 201bc68: 90 10 00 18 mov %i0, %o0 201bc6c: 92 10 00 19 mov %i1, %o1 201bc70: 7f ff fd 37 call 201b14c 201bc74: 94 10 20 00 clr %o2 assert( block_ptr ); 201bc78: 80 a2 20 00 cmp %o0, 0 201bc7c: 22 80 00 19 be,a 201bce0 201bc80: 11 00 80 e0 sethi %hi(0x2038000), %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; 201bc84: 94 24 00 11 sub %l0, %l1, %o2 201bc88: 80 a2 80 1b cmp %o2, %i3 201bc8c: 18 80 00 0b bgu 201bcb8 201bc90: d0 02 00 00 ld [ %o0 ], %o0 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 ); src += to_copy; 201bc94: a0 06 80 0a add %i2, %o2, %l0 <== NOT EXECUTED 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 ); 201bc98: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED src += to_copy; block++; 201bc9c: b2 06 60 01 inc %i1 <== NOT EXECUTED my_length -= to_copy; 201bca0: b6 26 c0 0a sub %i3, %o2, %i3 <== NOT EXECUTED copied += to_copy; 201bca4: a2 10 00 0a mov %o2, %l1 <== NOT EXECUTED 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 ); 201bca8: 40 00 2d 90 call 20272e8 <== NOT EXECUTED 201bcac: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201bcb0: 10 bf ff b0 b 201bb70 <== NOT EXECUTED 201bcb4: f4 04 a3 cc ld [ %l2 + 0x3cc ], %i2 <== 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; 201bcb8: 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 ); 201bcbc: 90 04 40 08 add %l1, %o0, %o0 src += to_copy; 201bcc0: a0 06 80 0a add %i2, %o2, %l0 block++; 201bcc4: b2 06 60 01 inc %i1 my_length -= to_copy; 201bcc8: b6 26 c0 0a sub %i3, %o2, %i3 copied += to_copy; 201bccc: a2 10 00 0a mov %o2, %l1 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 ); 201bcd0: 40 00 2d 86 call 20272e8 201bcd4: 92 10 00 1a mov %i2, %o1 /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 201bcd8: 10 bf ff a6 b 201bb70 201bcdc: f4 04 a3 cc ld [ %l2 + 0x3cc ], %i2 if ( start_offset ) { to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset; if ( to_copy > my_length ) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); 201bce0: 92 10 23 1a mov 0x31a, %o1 <== NOT EXECUTED 201bce4: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bce8: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bcec: a2 10 20 00 clr %l1 <== NOT EXECUTED 201bcf0: 7f ff a0 34 call 2003dc0 <__assert> <== NOT EXECUTED 201bcf4: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED 201bcf8: 30 bf ff ba b,a 201bbe0 <== NOT EXECUTED assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); 201bcfc: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201bd00: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bd04: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bd08: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED 201bd0c: 7f ff a0 2d call 2003dc0 <__assert> <== NOT EXECUTED 201bd10: 92 10 23 44 mov 0x344, %o1 <== NOT EXECUTED 201bd14: 30 bf ff b3 b,a 201bbe0 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); 201bd18: 40 00 26 c0 call 2025818 <__errno> <== NOT EXECUTED 201bd1c: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED 201bd20: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 201bd24: 10 bf ff af b 201bbe0 <== NOT EXECUTED 201bd28: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) rtems_set_errno_and_return_minus_one( EINVAL ); 201bd2c: 40 00 26 bb call 2025818 <__errno> <== NOT EXECUTED 201bd30: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED 201bd34: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 201bd38: 10 bf ff aa b 201bbe0 <== NOT EXECUTED 201bd3c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 201bd40: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201bd44: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bd48: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bd4c: 7f ff a0 1d call 2003dc0 <__assert> <== NOT EXECUTED 201bd50: 94 12 a0 a8 or %o2, 0xa8, %o2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); 201bd54: 40 00 26 b1 call 2025818 <__errno> <== NOT EXECUTED 201bd58: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED 201bd5c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 201bd60: 10 bf ff a0 b 201bbe0 <== NOT EXECUTED 201bd64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * Error check arguments */ assert( source ); 201bd68: 92 10 22 ed mov 0x2ed, %o1 <== NOT EXECUTED 201bd6c: 11 00 80 e0 sethi %hi(0x2038000), %o0 <== NOT EXECUTED 201bd70: 15 00 80 e0 sethi %hi(0x2038000), %o2 <== NOT EXECUTED 201bd74: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED 201bd78: 7f ff a0 12 call 2003dc0 <__assert> <== NOT EXECUTED 201bd7c: 94 12 a0 f0 or %o2, 0xf0, %o2 <== NOT EXECUTED if ( !source ) rtems_set_errno_and_return_minus_one( EINVAL ); 201bd80: 40 00 26 a6 call 2025818 <__errno> <== NOT EXECUTED 201bd84: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED 201bd88: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 201bd8c: 10 bf ff 95 b 201bbe0 <== NOT EXECUTED 201bd90: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 0200bdec : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 200bdec: 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 ); 200bdf0: 90 10 00 18 mov %i0, %o0 200bdf4: 94 07 bf f4 add %fp, -12, %o2 200bdf8: b0 07 bf c3 add %fp, -61, %i0 200bdfc: 7f ff ff 79 call 200bbe0 200be00: 92 10 00 18 mov %i0, %o1 /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 200be04: b3 2e 60 10 sll %i1, 0x10, %i1 200be08: 03 00 00 3c sethi %hi(0xf000), %g1 200be0c: 97 36 60 10 srl %i1, 0x10, %o3 200be10: 05 00 00 10 sethi %hi(0x4000), %g2 200be14: 86 0a c0 01 and %o3, %g1, %g3 200be18: 80 a0 c0 02 cmp %g3, %g2 200be1c: 02 80 00 1f be 200be98 200be20: 90 10 00 1c mov %i4, %o0 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 200be24: 03 00 00 20 sethi %hi(0x8000), %g1 200be28: 80 a0 c0 01 cmp %g3, %g1 200be2c: 02 80 00 12 be 200be74 200be30: 92 10 20 05 mov 5, %o1 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 200be34: 03 00 00 18 sethi %hi(0x6000), %g1 200be38: 80 a0 c0 01 cmp %g3, %g1 200be3c: 02 80 00 0b be 200be68 200be40: 03 00 00 08 sethi %hi(0x2000), %g1 200be44: 80 a0 c0 01 cmp %g3, %g1 200be48: 22 80 00 09 be,a 200be6c 200be4c: f6 27 bf e8 st %i3, [ %fp + -24 ] type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else { rtems_set_errno_and_return_minus_one( EINVAL ); 200be50: 40 00 0c 9c call 200f0c0 <__errno> <== NOT EXECUTED 200be54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200be58: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200be5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200be60: 81 c7 e0 08 ret <== NOT EXECUTED 200be64: 81 e8 00 00 restore <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 200be68: f6 27 bf e8 st %i3, [ %fp + -24 ] <== NOT EXECUTED 200be6c: f4 27 bf e4 st %i2, [ %fp + -28 ] 200be70: 92 10 20 02 mov 2, %o1 /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 200be74: 94 10 00 18 mov %i0, %o2 200be78: 98 07 bf e4 add %fp, -28, %o4 200be7c: 40 00 09 11 call 200e2c0 200be80: b0 10 20 00 clr %i0 new_name, mode, &info ); if ( !new_node ) 200be84: 80 a2 20 00 cmp %o0, 0 200be88: 02 80 00 06 be 200bea0 200be8c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; } 200be90: 81 c7 e0 08 ret 200be94: 81 e8 00 00 restore type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else { rtems_set_errno_and_return_minus_one( EINVAL ); 200be98: 10 bf ff f7 b 200be74 200be9c: 92 10 20 01 mov 1, %o1 mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 200bea0: 40 00 0c 88 call 200f0c0 <__errno> <== NOT EXECUTED 200bea4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200bea8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 200beac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return 0; } 200beb0: 81 c7 e0 08 ret <== NOT EXECUTED 200beb4: 81 e8 00 00 restore <== NOT EXECUTED 02003a00 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 2003a00: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 2003a04: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 2003a08: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 2003a0c: 80 a0 60 01 cmp %g1, 1 2003a10: 12 80 00 05 bne 2003a24 2003a14: 01 00 00 00 nop /* * Set mt_fs pointer to point to the mount table entry for * the mounted file system. */ node->info.directory.mt_fs = mt_entry; 2003a18: f0 20 a0 58 st %i0, [ %g2 + 0x58 ] return 0; } 2003a1c: 81 c7 e0 08 ret 2003a20: 91 e8 20 00 restore %g0, 0, %o0 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 2003a24: 40 00 87 7d call 2025818 <__errno> <== NOT EXECUTED 2003a28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003a2c: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED 2003a30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003a34: 81 c7 e0 08 ret <== NOT EXECUTED 2003a38: 81 e8 00 00 restore <== NOT EXECUTED 02003980 : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 2003980: 9d e3 bf 98 save %sp, -104, %sp assert( the_jnode ); 2003984: 80 a6 20 00 cmp %i0, 0 2003988: 02 80 00 54 be 2003ad8 200398c: 11 00 80 7a sethi %hi(0x201e800), %o0 fprintf(stdout, "%s", the_jnode->name ); 2003990: 21 00 80 83 sethi %hi(0x2020c00), %l0 2003994: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 ! 2020ce0 <_impure_ptr> 2003998: 90 06 20 0c add %i0, 0xc, %o0 200399c: 40 00 40 d7 call 2013cf8 20039a0: d2 00 60 08 ld [ %g1 + 8 ], %o1 switch( the_jnode->type ) { 20039a4: d4 06 20 48 ld [ %i0 + 0x48 ], %o2 20039a8: 80 a2 a0 06 cmp %o2, 6 20039ac: 08 80 00 10 bleu 20039ec 20039b0: 83 2a a0 02 sll %o2, 2, %g1 fprintf(stdout, " links not printed\n" ); assert(0); break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 20039b4: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 20039b8: 13 00 80 7a sethi %hi(0x201e800), %o1 <== NOT EXECUTED 20039bc: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED 20039c0: 40 00 40 81 call 2013bc4 <== NOT EXECUTED 20039c4: 92 12 63 c0 or %o1, 0x3c0, %o1 <== NOT EXECUTED assert(0); 20039c8: 92 10 20 67 mov 0x67, %o1 <== NOT EXECUTED 20039cc: 11 00 80 7a sethi %hi(0x201e800), %o0 <== NOT EXECUTED 20039d0: 15 00 80 7a sethi %hi(0x201e800), %o2 <== NOT EXECUTED 20039d4: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED 20039d8: 94 12 a3 b8 or %o2, 0x3b8, %o2 <== NOT EXECUTED 20039dc: 40 00 02 34 call 20042ac <__assert> <== NOT EXECUTED 20039e0: 31 00 80 7a sethi %hi(0x201e800), %i0 <== NOT EXECUTED break; } puts(""); 20039e4: 40 00 47 45 call 20156f8 <== NOT EXECUTED 20039e8: 91 ee 22 b8 restore %i0, 0x2b8, %o0 <== NOT EXECUTED ) { assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { 20039ec: 05 00 80 0e sethi %hi(0x2003800), %g2 20039f0: 84 10 a1 28 or %g2, 0x128, %g2 ! 2003928 20039f4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20039f8: 81 c0 c0 00 jmp %g3 20039fc: 01 00 00 00 nop fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 2003a00: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 2003a04: d6 06 20 50 ld [ %i0 + 0x50 ], %o3 <== NOT EXECUTED 2003a08: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 <== NOT EXECUTED 2003a0c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED 2003a10: 13 00 80 7a sethi %hi(0x201e800), %o1 <== NOT EXECUTED 2003a14: 40 00 40 6c call 2013bc4 <== NOT EXECUTED 2003a18: 92 12 63 80 or %o1, 0x380, %o1 ! 201eb80 <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 2003a1c: 31 00 80 7a sethi %hi(0x201e800), %i0 <== NOT EXECUTED 2003a20: 40 00 47 36 call 20156f8 <== NOT EXECUTED 2003a24: 91 ee 22 b8 restore %i0, 0x2b8, %o0 <== NOT EXECUTED assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { case IMFS_DIRECTORY: fprintf(stdout, "/" ); 2003a28: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 2003a2c: 90 10 20 2f mov 0x2f, %o0 2003a30: d2 00 60 08 ld [ %g1 + 8 ], %o1 2003a34: 40 00 40 70 call 2013bf4 2003a38: 31 00 80 7a sethi %hi(0x201e800), %i0 default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 2003a3c: 40 00 47 2f call 20156f8 2003a40: 91 ee 22 b8 restore %i0, 0x2b8, %o0 case IMFS_DIRECTORY: fprintf(stdout, "/" ); break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 2003a44: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 2003a48: d6 06 20 50 ld [ %i0 + 0x50 ], %o3 2003a4c: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 2003a50: d0 00 60 08 ld [ %g1 + 8 ], %o0 2003a54: 13 00 80 7a sethi %hi(0x201e800), %o1 2003a58: 40 00 40 5b call 2013bc4 2003a5c: 92 12 63 68 or %o1, 0x368, %o1 ! 201eb68 default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 2003a60: 31 00 80 7a sethi %hi(0x201e800), %i0 2003a64: 40 00 47 25 call 20156f8 2003a68: 91 ee 22 b8 restore %i0, 0x2b8, %o0 (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 2003a6c: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 2003a70: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2003a74: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED 2003a78: 11 00 80 7a sethi %hi(0x201e800), %o0 <== NOT EXECUTED 2003a7c: 94 10 20 13 mov 0x13, %o2 <== NOT EXECUTED 2003a80: 40 00 43 4d call 20147b4 <== NOT EXECUTED 2003a84: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED assert(0); 2003a88: 10 bf ff d1 b 20039cc <== NOT EXECUTED 2003a8c: 92 10 20 5d mov 0x5d, %o1 <== NOT EXECUTED break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 2003a90: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 <== NOT EXECUTED 2003a94: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2003a98: d6 00 60 08 ld [ %g1 + 8 ], %o3 <== NOT EXECUTED 2003a9c: 11 00 80 7a sethi %hi(0x201e800), %o0 <== NOT EXECUTED 2003aa0: 94 10 20 13 mov 0x13, %o2 <== NOT EXECUTED 2003aa4: 40 00 43 44 call 20147b4 <== NOT EXECUTED 2003aa8: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED assert(0); 2003aac: 10 bf ff c8 b 20039cc <== NOT EXECUTED 2003ab0: 92 10 20 62 mov 0x62, %o1 <== NOT EXECUTED the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 2003ab4: c2 04 20 e0 ld [ %l0 + 0xe0 ], %g1 2003ab8: d4 06 20 4c ld [ %i0 + 0x4c ], %o2 2003abc: d0 00 60 08 ld [ %g1 + 8 ], %o0 2003ac0: 13 00 80 7a sethi %hi(0x201e800), %o1 2003ac4: 40 00 40 40 call 2013bc4 2003ac8: 92 12 63 90 or %o1, 0x390, %o1 ! 201eb90 default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 2003acc: 31 00 80 7a sethi %hi(0x201e800), %i0 2003ad0: 40 00 47 0a call 20156f8 2003ad4: 91 ee 22 b8 restore %i0, 0x2b8, %o0 void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { assert( the_jnode ); 2003ad8: 15 00 80 7a sethi %hi(0x201e800), %o2 <== NOT EXECUTED 2003adc: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED 2003ae0: 94 12 a3 58 or %o2, 0x358, %o2 <== NOT EXECUTED 2003ae4: 40 00 01 f2 call 20042ac <__assert> <== NOT EXECUTED 2003ae8: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 2003aec: 10 bf ff aa b 2003994 <== NOT EXECUTED 2003af0: 21 00 80 83 sethi %hi(0x2020c00), %l0 <== NOT EXECUTED 02003a48 : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 2003a48: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; int i; node = loc->node_access; 2003a4c: c6 06 00 00 ld [ %i0 ], %g3 if ( node->type != IMFS_SYM_LINK ) 2003a50: c2 00 e0 48 ld [ %g3 + 0x48 ], %g1 2003a54: 80 a0 60 04 cmp %g1, 4 2003a58: 12 80 00 19 bne 2003abc 2003a5c: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EINVAL ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 2003a60: 02 80 00 15 be 2003ab4 2003a64: 88 10 20 00 clr %g4 2003a68: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1 int i; node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); 2003a6c: b0 10 20 00 clr %i0 for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 2003a70: c4 48 40 00 ldsb [ %g1 ], %g2 2003a74: 80 a0 a0 00 cmp %g2, 0 2003a78: 12 80 00 08 bne 2003a98 2003a7c: c2 08 40 00 ldub [ %g1 ], %g1 2003a80: 30 80 00 13 b,a 2003acc <== NOT EXECUTED 2003a84: c2 00 e0 4c ld [ %g3 + 0x4c ], %g1 2003a88: c4 48 40 18 ldsb [ %g1 + %i0 ], %g2 2003a8c: 80 a0 a0 00 cmp %g2, 0 2003a90: 02 80 00 07 be 2003aac 2003a94: c2 08 40 18 ldub [ %g1 + %i0 ], %g1 buf[i] = node->info.sym_link.name[i]; 2003a98: c2 2e 40 04 stb %g1, [ %i1 + %g4 ] 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++ ) 2003a9c: b0 06 20 01 inc %i0 2003aa0: 80 a6 00 1a cmp %i0, %i2 2003aa4: 12 bf ff f8 bne 2003a84 2003aa8: 88 10 00 18 mov %i0, %g4 buf[i] = node->info.sym_link.name[i]; return i; } 2003aac: 81 c7 e0 08 ret 2003ab0: 81 e8 00 00 restore 2003ab4: 81 c7 e0 08 ret <== NOT EXECUTED 2003ab8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED int i; node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); 2003abc: 40 00 87 57 call 2025818 <__errno> <== NOT EXECUTED 2003ac0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003ac4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2003ac8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003acc: 81 c7 e0 08 ret <== NOT EXECUTED 2003ad0: 81 e8 00 00 restore <== NOT EXECUTED 0200bec4 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 200bec4: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 200bec8: 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 ) { 200becc: c2 04 20 08 ld [ %l0 + 8 ], %g1 200bed0: 80 a0 60 00 cmp %g1, 0 200bed4: 22 80 00 06 be,a 200beec 200bed8: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 <== NOT EXECUTED Chain_Extract( (Chain_Node *) the_jnode ); 200bedc: 40 00 05 c2 call 200d5e4 <_Chain_Extract> 200bee0: 90 10 00 10 mov %l0, %o0 the_jnode->Parent = NULL; 200bee4: c0 24 20 08 clr [ %l0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 200bee8: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 200beec: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 200bef0: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 200bef4: 90 07 bf f0 add %fp, -16, %o0 200bef8: 40 00 01 27 call 200c394 200befc: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] 200bf00: 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) ) { 200bf04: 90 10 00 10 mov %l0, %o0 200bf08: 40 00 01 5d call 200c47c 200bf0c: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 200bf10: 80 a2 20 00 cmp %o0, 0 200bf14: 12 80 00 12 bne 200bf5c 200bf18: 01 00 00 00 nop 200bf1c: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 200bf20: 80 a0 60 00 cmp %g1, 0 200bf24: 12 80 00 0e bne 200bf5c 200bf28: 03 00 80 62 sethi %hi(0x2018800), %g1 /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 200bf2c: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 200bf30: c4 06 00 00 ld [ %i0 ], %g2 200bf34: c2 00 e0 04 ld [ %g3 + 4 ], %g1 200bf38: 80 a0 40 02 cmp %g1, %g2 200bf3c: 22 80 00 02 be,a 200bf44 200bf40: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 200bf44: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 200bf48: 80 a0 60 04 cmp %g1, 4 200bf4c: 22 80 00 06 be,a 200bf64 200bf50: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 if ( the_jnode->info.sym_link.name ) free( the_jnode->info.sym_link.name ); } free( the_jnode ); 200bf54: 7f ff d8 e9 call 20022f8 200bf58: 90 10 00 10 mov %l0, %o0 } return 0; } 200bf5c: 81 c7 e0 08 ret 200bf60: 91 e8 20 00 restore %g0, 0, %o0 /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { if ( the_jnode->info.sym_link.name ) 200bf64: 80 a2 20 00 cmp %o0, 0 200bf68: 02 bf ff fb be 200bf54 200bf6c: 01 00 00 00 nop free( the_jnode->info.sym_link.name ); 200bf70: 7f ff d8 e2 call 20022f8 200bf74: 01 00 00 00 nop 200bf78: 30 bf ff f7 b,a 200bf54 0200bf7c : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 200bf7c: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 200bf80: f0 06 00 00 ld [ %i0 ], %i0 switch ( the_jnode->type ) { 200bf84: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 200bf88: 80 a0 60 04 cmp %g1, 4 200bf8c: 22 80 00 11 be,a 200bfd0 200bf90: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED 200bf94: 14 80 00 0b bg 200bfc0 200bf98: 80 a0 60 06 cmp %g1, 6 200bf9c: 80 a0 60 02 cmp %g1, 2 200bfa0: 22 80 00 1e be,a 200c018 200bfa4: c4 06 20 4c ld [ %i0 + 0x4c ], %g2 case IMFS_SYM_LINK: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 200bfa8: 40 00 0c 46 call 200f0c0 <__errno> <== NOT EXECUTED 200bfac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200bfb0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 200bfb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200bfb8: 81 c7 e0 08 ret <== NOT EXECUTED 200bfbc: 81 e8 00 00 restore <== NOT EXECUTED IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 200bfc0: 14 bf ff fa bg 200bfa8 200bfc4: 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; 200bfc8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 200bfcc: c2 26 60 20 st %g1, [ %i1 + 0x20 ] default: rtems_set_errno_and_return_minus_one( ENOTSUP ); break; } buf->st_mode = the_jnode->st_mode; 200bfd0: c2 16 20 2e lduh [ %i0 + 0x2e ], %g1 buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; 200bfd4: 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; 200bfd8: c2 36 60 0c sth %g1, [ %i1 + 0xc ] buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino; 200bfdc: 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; 200bfe0: 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; 200bfe4: 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; 200bfe8: 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; 200bfec: 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; 200bff0: 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; 200bff4: 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; 200bff8: 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; 200bffc: 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; 200c000: 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; 200c004: 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; 200c008: 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; 200c00c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] return 0; } 200c010: 81 c7 e0 08 ret 200c014: 91 e8 20 00 restore %g0, 0, %o0 200c018: 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 ); 200c01c: 10 bf ff ed b 200bfd0 200c020: c4 3e 40 00 std %g2, [ %i1 ] 02003ad4 : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 2003ad4: 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 ); 2003ad8: a0 07 bf c3 add %fp, -61, %l0 2003adc: 94 07 bf f4 add %fp, -12, %o2 2003ae0: 92 10 00 10 mov %l0, %o1 2003ae4: 7f ff fe db call 2003650 2003ae8: 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 ) { 2003aec: 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; 2003af0: f2 27 bf e4 st %i1, [ %fp + -28 ] /* * Create a new link node. */ new_node = IMFS_create_node( 2003af4: 94 10 00 10 mov %l0, %o2 2003af8: 92 10 20 04 mov 4, %o1 2003afc: 17 00 00 28 sethi %hi(0xa000), %o3 2003b00: 98 07 bf e4 add %fp, -28, %o4 2003b04: 96 12 e1 ff or %o3, 0x1ff, %o3 2003b08: 40 00 49 e5 call 201629c 2003b0c: b0 10 20 00 clr %i0 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 2003b10: 80 a2 20 00 cmp %o0, 0 2003b14: 02 80 00 04 be 2003b24 2003b18: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; } 2003b1c: 81 c7 e0 08 ret 2003b20: 81 e8 00 00 restore ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 2003b24: 40 00 87 3d call 2025818 <__errno> <== NOT EXECUTED 2003b28: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003b2c: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 2003b30: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return 0; } 2003b34: 81 c7 e0 08 ret <== NOT EXECUTED 2003b38: 81 e8 00 00 restore <== NOT EXECUTED 02003b3c : #include int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) { 2003b3c: 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; 2003b40: 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 ) { 2003b44: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 2003b48: 80 a0 60 03 cmp %g1, 3 2003b4c: 22 80 00 08 be,a 2003b6c 2003b50: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 2003b54: c4 06 20 04 ld [ %i0 + 4 ], %g2 2003b58: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 2003b5c: 9f c0 40 00 call %g1 2003b60: 90 10 00 18 mov %i0, %o0 return result; } 2003b64: 81 c7 e0 08 ret 2003b68: 91 e8 00 08 restore %g0, %o0, %o0 * free the node. */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) 2003b6c: 80 a0 60 00 cmp %g1, 0 2003b70: 02 80 00 21 be 2003bf4 2003b74: a2 07 bf e0 add %fp, -32, %l1 rtems_set_errno_and_return_minus_one( EINVAL ); the_link = *loc; 2003b78: c2 06 20 04 ld [ %i0 + 4 ], %g1 2003b7c: c4 06 20 08 ld [ %i0 + 8 ], %g2 2003b80: c6 06 20 0c ld [ %i0 + 0xc ], %g3 2003b84: e0 27 bf e0 st %l0, [ %fp + -32 ] 2003b88: c4 3f bf e8 std %g2, [ %fp + -24 ] 2003b8c: c2 27 bf e4 st %g1, [ %fp + -28 ] the_link.node_access = node->info.hard_link.link_node; 2003b90: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 2003b94: c2 27 bf e0 st %g1, [ %fp + -32 ] IMFS_Set_handlers( &the_link ); 2003b98: 40 00 4a 2a call 2016440 2003b9c: 90 10 00 11 mov %l1, %o0 /* * 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) 2003ba0: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2003ba4: c2 10 a0 30 lduh [ %g2 + 0x30 ], %g1 2003ba8: 80 a0 60 01 cmp %g1, 1 2003bac: 02 80 00 0a be 2003bd4 2003bb0: 82 00 7f ff add %g1, -1, %g1 return -1; } else { node->info.hard_link.link_node->st_nlink --; IMFS_update_ctime( node->info.hard_link.link_node ); 2003bb4: 90 07 bf f0 add %fp, -16, %o0 if ( result != 0 ) return -1; } else { node->info.hard_link.link_node->st_nlink --; 2003bb8: c2 30 a0 30 sth %g1, [ %g2 + 0x30 ] IMFS_update_ctime( node->info.hard_link.link_node ); 2003bbc: 40 00 01 4b call 20040e8 2003bc0: 92 10 20 00 clr %o1 2003bc4: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2003bc8: c2 07 bf f0 ld [ %fp + -16 ], %g1 2003bcc: 10 bf ff e2 b 2003b54 2003bd0: c2 20 a0 44 st %g1, [ %g2 + 0x44 ] * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) { result = (*the_link.handlers->rmnod_h)( &the_link ); 2003bd4: c2 07 bf e4 ld [ %fp + -28 ], %g1 2003bd8: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 2003bdc: 9f c0 80 00 call %g2 2003be0: 90 10 00 11 mov %l1, %o0 if ( result != 0 ) 2003be4: 80 a2 20 00 cmp %o0, 0 2003be8: 02 bf ff db be 2003b54 2003bec: 90 10 3f ff mov -1, %o0 2003bf0: 30 bf ff dd b,a 2003b64 */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) rtems_set_errno_and_return_minus_one( EINVAL ); 2003bf4: 40 00 87 09 call 2025818 <__errno> <== NOT EXECUTED 2003bf8: 01 00 00 00 nop <== NOT EXECUTED 2003bfc: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2003c00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003c04: 10 bf ff d8 b 2003b64 <== NOT EXECUTED 2003c08: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 02003c0c : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 2003c0c: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 2003c10: c4 06 20 08 ld [ %i0 + 8 ], %g2 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 2003c14: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 2003c18: 80 a0 60 01 cmp %g1, 1 2003c1c: 12 80 00 09 bne 2003c40 2003c20: 01 00 00 00 nop /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 2003c24: c2 00 a0 58 ld [ %g2 + 0x58 ], %g1 2003c28: 80 a0 60 00 cmp %g1, 0 2003c2c: 02 80 00 0b be 2003c58 2003c30: 01 00 00 00 nop /* * Set the mt_fs pointer to indicate that there is no longer * a file system mounted to this point. */ node->info.directory.mt_fs = NULL; 2003c34: c0 20 a0 58 clr [ %g2 + 0x58 ] return 0; } 2003c38: 81 c7 e0 08 ret 2003c3c: 91 e8 20 00 restore %g0, 0, %o0 /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 2003c40: 40 00 86 f6 call 2025818 <__errno> <== NOT EXECUTED 2003c44: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003c48: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED 2003c4c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003c50: 81 c7 e0 08 ret <== NOT EXECUTED 2003c54: 81 e8 00 00 restore <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 2003c58: 40 00 86 f0 call 2025818 <__errno> <== NOT EXECUTED 2003c5c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003c60: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2003c64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003c68: 81 c7 e0 08 ret <== NOT EXECUTED 2003c6c: 81 e8 00 00 restore <== NOT EXECUTED 02025180 : assert( 0 ); return 0; } int POSIX_BOTTOM_REACHED() { 2025180: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 2025184: 92 10 20 22 mov 0x22, %o1 <== NOT EXECUTED 2025188: 11 00 80 a4 sethi %hi(0x2029000), %o0 <== NOT EXECUTED 202518c: 15 00 80 9d sethi %hi(0x2027400), %o2 <== NOT EXECUTED 2025190: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED 2025194: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 2025198: 7f ff 8e 1d call 2008a0c <__assert> <== NOT EXECUTED 202519c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 20251a0: 81 c7 e0 08 ret <== NOT EXECUTED 20251a4: 81 e8 00 00 restore <== NOT EXECUTED 020251a8 : */ #include int POSIX_MP_NOT_IMPLEMENTED() { 20251a8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 20251ac: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED 20251b0: 11 00 80 a4 sethi %hi(0x2029000), %o0 <== NOT EXECUTED 20251b4: 15 00 80 9d sethi %hi(0x2027400), %o2 <== NOT EXECUTED 20251b8: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED 20251bc: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 20251c0: 7f ff 8e 13 call 2008a0c <__assert> <== NOT EXECUTED 20251c4: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 20251c8: 81 c7 e0 08 ret <== NOT EXECUTED 20251cc: 81 e8 00 00 restore <== NOT EXECUTED 02025158 : assert( 0 ); return 0; } int POSIX_NOT_IMPLEMENTED() { 2025158: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED assert( 0 ); 202515c: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED 2025160: 11 00 80 a4 sethi %hi(0x2029000), %o0 <== NOT EXECUTED 2025164: 15 00 80 9d sethi %hi(0x2027400), %o2 <== NOT EXECUTED 2025168: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED 202516c: 94 12 a3 c0 or %o2, 0x3c0, %o2 <== NOT EXECUTED 2025170: 7f ff 8e 27 call 2008a0c <__assert> <== NOT EXECUTED 2025174: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 2025178: 81 c7 e0 08 ret <== NOT EXECUTED 202517c: 81 e8 00 00 restore <== NOT EXECUTED 02002660 : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 2002660: 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; 2002664: 03 00 80 65 sethi %hi(0x2019400), %g1 * 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; 2002668: 05 00 80 65 sethi %hi(0x2019400), %g2 200266c: 82 10 62 dc or %g1, 0x2dc, %g1 2002670: f4 20 a2 d4 st %i2, [ %g2 + 0x2d4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2002674: c2 20 7f fc st %g1, [ %g1 + -4 ] 2002678: 82 00 7f fc add %g1, -4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 200267c: c2 20 60 08 st %g1, [ %g1 + 8 ] if (!starting_address) { 2002680: 80 a6 20 00 cmp %i0, 0 2002684: 02 80 00 19 be 20026e8 2002688: c0 20 60 04 clr [ %g1 + 4 ] * 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() ) 200268c: 03 00 80 66 sethi %hi(0x2019800), %g1 2002690: c4 00 60 64 ld [ %g1 + 0x64 ], %g2 ! 2019864 <_CPU_Table+0x10> 2002694: 80 a0 a0 00 cmp %g2, 0 2002698: 32 80 00 0f bne,a 20026d4 200269c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 20026a0: 92 10 00 18 mov %i0, %o1 20026a4: 94 10 00 19 mov %i1, %o2 20026a8: 11 00 80 65 sethi %hi(0x2019400), %o0 20026ac: 96 10 20 08 mov 8, %o3 20026b0: 40 00 13 fc call 20076a0 <_Heap_Initialize> 20026b4: 90 12 22 7c or %o0, 0x27c, %o0 &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 20026b8: 80 a2 20 00 cmp %o0, 0 20026bc: 02 80 00 04 be 20026cc 20026c0: 01 00 00 00 nop 20026c4: 81 c7 e0 08 ret 20026c8: 81 e8 00 00 restore rtems_fatal_error_occurred( status ); 20026cc: 40 00 10 e9 call 2006a70 <== NOT EXECUTED 20026d0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED * 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() ) memset( starting_address, 0, length ); 20026d4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20026d8: 40 00 34 7c call 200f8c8 <== NOT EXECUTED 20026dc: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 20026e0: 10 bf ff f1 b 20026a4 <== NOT EXECUTED 20026e4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED starting_address = start; RTEMS_Malloc_Sbrk_amount = sbrk_amount; if (!starting_address) { uaddress = (uintptr_t)sbrk(length); 20026e8: 40 00 51 50 call 2016c28 <== NOT EXECUTED 20026ec: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED if (uaddress == (uintptr_t) -1) { 20026f0: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 20026f4: 02 80 00 0b be 2002720 <== NOT EXECUTED 20026f8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); /* DOES NOT RETURN!!! */ } if (uaddress & (CPU_HEAP_ALIGNMENT-1)) { 20026fc: 80 8a 20 07 btst 7, %o0 <== NOT EXECUTED 2002700: 02 bf ff e4 be 2002690 <== NOT EXECUTED 2002704: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED old_address = uaddress; uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1); 2002708: 82 06 20 08 add %i0, 8, %g1 <== NOT EXECUTED 200270c: 82 08 7f f8 and %g1, -8, %g1 <== NOT EXECUTED /* * adjust the length by whatever we aligned by */ length -= uaddress - old_address; 2002710: 84 20 40 18 sub %g1, %i0, %g2 <== NOT EXECUTED 2002714: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED 2002718: 10 bf ff dd b 200268c <== NOT EXECUTED 200271c: b2 26 40 02 sub %i1, %g2, %i1 <== NOT EXECUTED if (!starting_address) { uaddress = (uintptr_t)sbrk(length); if (uaddress == (uintptr_t) -1) { rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 2002720: 40 00 10 d4 call 2006a70 <== NOT EXECUTED 2002724: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED /* DOES NOT RETURN!!! */ } if (uaddress & (CPU_HEAP_ALIGNMENT-1)) { old_address = uaddress; uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1); 2002728: 10 bf ff f9 b 200270c <== NOT EXECUTED 200272c: 82 06 20 08 add %i0, 8, %g1 <== NOT EXECUTED 020027c8 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 20027c8: 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 ) 20027cc: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 20027d0: 02 80 00 2a be 2002878 <== NOT EXECUTED 20027d4: 2b 00 80 76 sethi %hi(0x201d800), %l5 <== NOT EXECUTED return; if ( !print_handler ) 20027d8: e6 05 62 04 ld [ %l5 + 0x204 ], %l3 ! 201da04 <== NOT EXECUTED 20027dc: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED 20027e0: 02 80 00 26 be 2002878 <== NOT EXECUTED 20027e4: 80 a6 3f ff cmp %i0, -1 <== NOT EXECUTED /* * XXX HACK to get to interrupt stack */ if (the_thread == (Thread_Control *) -1) { 20027e8: 02 80 00 33 be 20028b4 <== NOT EXECUTED 20027ec: a2 06 20 d0 add %i0, 0xd0, %l1 <== NOT EXECUTED else return; } else stack = &the_thread->Start.Initial_stack; low = Stack_check_usable_stack_start(stack); 20027f0: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 20027f4: 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); 20027f8: a0 00 60 10 add %g1, 0x10, %l0 <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 20027fc: a4 00 bf f0 add %g2, -16, %l2 <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 2002800: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2002804: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 2002808: 7f ff ff d7 call 2002764 <== NOT EXECUTED 200280c: a8 10 20 00 clr %l4 <== NOT EXECUTED if ( high_water_mark ) 2002810: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002814: 02 80 00 03 be 2002820 <== NOT EXECUTED 2002818: 82 04 00 12 add %l0, %l2, %g1 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 200281c: a8 20 40 08 sub %g1, %o0, %l4 <== NOT EXECUTED else used = 0; if ( the_thread ) { 2002820: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 2002824: 02 80 00 17 be 2002880 <== NOT EXECUTED 2002828: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 200282c: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED 2002830: a0 07 bf f3 add %fp, -13, %l0 <== NOT EXECUTED 2002834: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED 2002838: 40 00 11 3d call 2006d2c <== NOT EXECUTED 200283c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED name[ 2 ] = 'T'; name[ 3 ] = 'R'; name[ 4 ] = '\0'; } (*print_handler)( 2002840: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED 2002844: e6 05 62 04 ld [ %l5 + 0x204 ], %l3 <== NOT EXECUTED 2002848: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED 200284c: d0 00 62 00 ld [ %g1 + 0x200 ], %o0 <== NOT EXECUTED 2002850: da 04 40 00 ld [ %l1 ], %o5 <== NOT EXECUTED 2002854: d8 04 60 04 ld [ %l1 + 4 ], %o4 <== NOT EXECUTED 2002858: 13 00 80 6b sethi %hi(0x201ac00), %o1 <== NOT EXECUTED 200285c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED 2002860: e4 23 a0 5c st %l2, [ %sp + 0x5c ] <== NOT EXECUTED 2002864: e8 23 a0 60 st %l4, [ %sp + 0x60 ] <== NOT EXECUTED 2002868: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 200286c: 9a 03 7f ff add %o5, -1, %o5 <== NOT EXECUTED 2002870: 9f c4 c0 00 call %l3 <== NOT EXECUTED 2002874: 92 12 63 d8 or %o1, 0x3d8, %o1 <== NOT EXECUTED 2002878: 81 c7 e0 08 ret <== NOT EXECUTED 200287c: 81 e8 00 00 restore <== NOT EXECUTED 2002880: d0 00 62 00 ld [ %g1 + 0x200 ], %o0 <== NOT EXECUTED if ( the_thread ) { rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); } else { name[ 0 ] = 'I'; name[ 1 ] = 'N'; 2002884: 84 10 20 4e mov 0x4e, %g2 <== NOT EXECUTED used = 0; if ( the_thread ) { rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); } else { name[ 0 ] = 'I'; 2002888: 82 10 20 49 mov 0x49, %g1 <== NOT EXECUTED name[ 1 ] = 'N'; 200288c: c4 2f bf f4 stb %g2, [ %fp + -12 ] <== NOT EXECUTED used = 0; if ( the_thread ) { rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); } else { name[ 0 ] = 'I'; 2002890: c2 2f bf f3 stb %g1, [ %fp + -13 ] <== NOT EXECUTED name[ 1 ] = 'N'; name[ 2 ] = 'T'; name[ 3 ] = 'R'; 2002894: 84 10 20 52 mov 0x52, %g2 <== 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'; 2002898: 82 10 20 54 mov 0x54, %g1 <== NOT EXECUTED name[ 3 ] = 'R'; name[ 4 ] = '\0'; 200289c: 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'; 20028a0: c2 2f bf f5 stb %g1, [ %fp + -11 ] <== NOT EXECUTED name[ 3 ] = 'R'; 20028a4: c4 2f bf f6 stb %g2, [ %fp + -10 ] <== NOT EXECUTED name[ 4 ] = '\0'; } (*print_handler)( 20028a8: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED 20028ac: 10 bf ff e9 b 2002850 <== NOT EXECUTED 20028b0: a0 07 bf f3 add %fp, -13, %l0 <== NOT EXECUTED /* * XXX HACK to get to interrupt stack */ if (the_thread == (Thread_Control *) -1) { if (Stack_check_Interrupt_stack.area) { 20028b4: 03 00 80 77 sethi %hi(0x201dc00), %g1 <== NOT EXECUTED 20028b8: 82 10 61 7c or %g1, 0x17c, %g1 ! 201dd7c <== NOT EXECUTED 20028bc: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; } else return; 20028c0: 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) { 20028c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20028c8: 12 bf ff ca bne 20027f0 <== NOT EXECUTED 20028cc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20028d0: 81 c7 e0 08 ret <== NOT EXECUTED 20028d4: 81 e8 00 00 restore <== NOT EXECUTED 02002764 : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 2002764: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) 2002768: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 200276c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 2002770: 92 02 40 08 add %o1, %o0, %o1 <== NOT EXECUTED 2002774: 80 a2 00 09 cmp %o0, %o1 <== NOT EXECUTED 2002778: 3a 80 00 12 bcc,a 20027c0 <== NOT EXECUTED 200277c: 90 10 20 00 clr %o0 <== NOT EXECUTED if (*base != U32_PATTERN) 2002780: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED 2002784: 03 29 69 69 sethi %hi(0xa5a5a400), %g1 <== NOT EXECUTED 2002788: 82 10 61 a5 or %g1, 0x1a5, %g1 ! a5a5a5a5 <== NOT EXECUTED 200278c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2002790: 22 80 00 07 be,a 20027ac <== NOT EXECUTED 2002794: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 2002798: 30 80 00 0a b,a 20027c0 <== NOT EXECUTED 200279c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20027a0: 12 80 00 08 bne 20027c0 <== NOT EXECUTED 20027a4: 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++) 20027a8: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED 20027ac: 80 a2 40 08 cmp %o1, %o0 <== NOT EXECUTED 20027b0: 38 bf ff fb bgu,a 200279c <== NOT EXECUTED 20027b4: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 20027b8: 81 c3 e0 08 retl <== NOT EXECUTED 20027bc: 90 10 20 00 clr %o0 <== NOT EXECUTED 20027c0: 81 c3 e0 08 retl <== NOT EXECUTED 20027c4: 01 00 00 00 nop 0200295c : */ void Stack_check_report_blown_task( Thread_Control *running, boolean pattern_ok ) { 200295c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; printk( 2002960: d4 1e 20 08 ldd [ %i0 + 8 ], %o2 <== NOT EXECUTED 2002964: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002968: 11 00 80 6c sethi %hi(0x201b000), %o0 <== NOT EXECUTED 200296c: 40 00 06 47 call 2004288 <== NOT EXECUTED 2002970: 90 12 20 60 or %o0, 0x60, %o0 ! 201b060 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 2002974: d4 06 20 d4 ld [ %i0 + 0xd4 ], %o2 <== NOT EXECUTED 2002978: c2 06 20 d0 ld [ %i0 + 0xd0 ], %g1 <== NOT EXECUTED 200297c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2002980: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 2002984: 94 02 80 01 add %o2, %g1, %o2 <== NOT EXECUTED 2002988: 11 00 80 6c sethi %hi(0x201b000), %o0 <== NOT EXECUTED 200298c: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED 2002990: 40 00 06 3e call 2004288 <== NOT EXECUTED 2002994: 90 12 20 a0 or %o0, 0xa0, %o0 <== NOT EXECUTED stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 2002998: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 200299c: 12 80 00 07 bne 20029b8 <== NOT EXECUTED 20029a0: 11 00 80 6c sethi %hi(0x201b000), %o0 <== NOT EXECUTED printk( 20029a4: d2 06 20 d4 ld [ %i0 + 0xd4 ], %o1 <== NOT EXECUTED 20029a8: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 20029ac: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED 20029b0: 40 00 06 36 call 2004288 <== NOT EXECUTED 20029b4: 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 ); 20029b8: 40 00 14 e6 call 2007d50 <== NOT EXECUTED 20029bc: 91 e8 20 81 restore %g0, 0x81, %o0 <== NOT EXECUTED 20029c0: 01 00 00 00 nop 02006cbc <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 2006cbc: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006cc0: 03 00 80 66 sethi %hi(0x2019800), %g1 2006cc4: e0 00 62 d0 ld [ %g1 + 0x2d0 ], %l0 ! 2019ad0 <_API_extensions_List> 2006cc8: 82 10 62 d0 or %g1, 0x2d0, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2006ccc: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006cd0: 80 a4 00 11 cmp %l0, %l1 2006cd4: 02 80 00 0c be 2006d04 <_API_extensions_Run_postdriver+0x48> 2006cd8: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 2006cdc: c2 04 20 0c ld [ %l0 + 0xc ], %g1 2006ce0: 80 a0 60 00 cmp %g1, 0 2006ce4: 22 80 00 05 be,a 2006cf8 <_API_extensions_Run_postdriver+0x3c> 2006ce8: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postdriver_hook)(); 2006cec: 9f c0 40 00 call %g1 2006cf0: 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 ) { 2006cf4: 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 ) ; 2006cf8: 80 a4 00 11 cmp %l0, %l1 2006cfc: 32 bf ff f9 bne,a 2006ce0 <_API_extensions_Run_postdriver+0x24> 2006d00: c2 04 20 0c ld [ %l0 + 0xc ], %g1 2006d04: 81 c7 e0 08 ret 2006d08: 81 e8 00 00 restore 02006d78 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 2006d78: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006d7c: 03 00 80 66 sethi %hi(0x2019800), %g1 2006d80: e0 00 62 d0 ld [ %g1 + 0x2d0 ], %l0 ! 2019ad0 <_API_extensions_List> 2006d84: 82 10 62 d0 or %g1, 0x2d0, %g1 2006d88: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006d8c: 80 a4 00 11 cmp %l0, %l1 2006d90: 02 80 00 0c be 2006dc0 <_API_extensions_Run_postswitch+0x48> 2006d94: 25 00 80 66 sethi %hi(0x2019800), %l2 the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 2006d98: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006d9c: 80 a0 60 00 cmp %g1, 0 2006da0: 22 80 00 05 be,a 2006db4 <_API_extensions_Run_postswitch+0x3c> 2006da4: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 2006da8: 9f c0 40 00 call %g1 2006dac: d0 04 a1 20 ld [ %l2 + 0x120 ], %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 ) { 2006db0: 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 ) ; 2006db4: 80 a4 00 11 cmp %l0, %l1 2006db8: 32 bf ff f9 bne,a 2006d9c <_API_extensions_Run_postswitch+0x24> 2006dbc: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2006dc0: 81 c7 e0 08 ret 2006dc4: 81 e8 00 00 restore 02006d28 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 2006d28: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 2006d2c: 03 00 80 66 sethi %hi(0x2019800), %g1 2006d30: e0 00 62 d0 ld [ %g1 + 0x2d0 ], %l0 ! 2019ad0 <_API_extensions_List> 2006d34: 82 10 62 d0 or %g1, 0x2d0, %g1 2006d38: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 2006d3c: 80 a4 00 11 cmp %l0, %l1 2006d40: 02 80 00 0c be 2006d70 <_API_extensions_Run_predriver+0x48> 2006d44: 01 00 00 00 nop the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 2006d48: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006d4c: 80 a0 60 00 cmp %g1, 0 2006d50: 22 80 00 05 be,a 2006d64 <_API_extensions_Run_predriver+0x3c> 2006d54: e0 04 00 00 ld [ %l0 ], %l0 (*the_extension->predriver_hook)(); 2006d58: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006d5c: 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 ) { 2006d60: 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 ) ; 2006d64: 80 a4 00 11 cmp %l0, %l1 2006d68: 32 bf ff f9 bne,a 2006d4c <_API_extensions_Run_predriver+0x24> 2006d6c: c2 04 20 08 ld [ %l0 + 8 ], %g1 2006d70: 81 c7 e0 08 ret 2006d74: 81 e8 00 00 restore 0200924c <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 200924c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing = _Thread_Executing; 2009250: 03 00 80 71 sethi %hi(0x201c400), %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 ); 2009254: 7f ff e6 c9 call 2002d78 2009258: e0 00 61 70 ld [ %g1 + 0x170 ], %l0 ! 201c570 <_Thread_Executing> 200925c: 84 10 00 08 mov %o0, %g2 switch ( the_rwlock->current_state ) { 2009260: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 2009264: 80 a0 60 01 cmp %g1, 1 2009268: 22 80 00 2d be,a 200931c <_CORE_RWLock_Release+0xd0> 200926c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 2009270: 0a 80 00 24 bcs 2009300 <_CORE_RWLock_Release+0xb4> 2009274: 80 a0 60 02 cmp %g1, 2 2009278: 22 80 00 02 be,a 2009280 <_CORE_RWLock_Release+0x34> 200927c: 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; 2009280: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 2009284: 7f ff e6 c1 call 2002d88 2009288: 90 10 00 02 mov %g2, %o0 next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 200928c: 40 00 09 c8 call 200b9ac <_Thread_queue_Dequeue> 2009290: 90 10 00 18 mov %i0, %o0 if ( next ) { 2009294: 80 a2 20 00 cmp %o0, 0 2009298: 22 80 00 1f be,a 2009314 <_CORE_RWLock_Release+0xc8> 200929c: b0 10 20 00 clr %i0 if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 20092a0: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 20092a4: 80 a0 60 01 cmp %g1, 1 20092a8: 02 80 00 26 be 2009340 <_CORE_RWLock_Release+0xf4> 20092ac: 84 10 20 01 mov 1, %g2 } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 20092b0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 20092b4: 82 00 60 01 inc %g1 the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 20092b8: c4 26 20 44 st %g2, [ %i0 + 0x44 ] } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 20092bc: 10 80 00 0a b 20092e4 <_CORE_RWLock_Release+0x98> 20092c0: 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 ); if ( !next || 20092c4: 80 a0 60 01 cmp %g1, 1 20092c8: 02 80 00 12 be 2009310 <_CORE_RWLock_Release+0xc4> 20092cc: 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; 20092d0: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 20092d4: 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; 20092d8: 82 00 60 01 inc %g1 _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 20092dc: 40 00 0b 02 call 200bee4 <_Thread_queue_Extract> 20092e0: 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 ); 20092e4: 40 00 0b 70 call 200c0a4 <_Thread_queue_First> 20092e8: 90 10 00 18 mov %i0, %o0 if ( !next || 20092ec: 80 a2 20 00 cmp %o0, 0 20092f0: 32 bf ff f5 bne,a 20092c4 <_CORE_RWLock_Release+0x78> 20092f4: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 20092f8: 81 c7 e0 08 ret 20092fc: 91 e8 20 00 restore %g0, 0, %o0 */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { case CORE_RWLOCK_UNLOCKED: _ISR_Enable( level ); 2009300: 7f ff e6 a2 call 2002d88 <== NOT EXECUTED 2009304: 01 00 00 00 nop <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 2009308: 82 10 20 02 mov 2, %g1 ! 2 <== NOT EXECUTED 200930c: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2009310: b0 10 20 00 clr %i0 <== NOT EXECUTED 2009314: 81 c7 e0 08 ret 2009318: 81 e8 00 00 restore _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; 200931c: 82 00 7f ff add %g1, -1, %g1 if ( the_rwlock->number_of_readers != 0 ) { 2009320: 80 a0 60 00 cmp %g1, 0 2009324: 12 80 00 04 bne 2009334 <_CORE_RWLock_Release+0xe8> 2009328: c2 26 20 48 st %g1, [ %i0 + 0x48 ] 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; 200932c: 10 bf ff d5 b 2009280 <_CORE_RWLock_Release+0x34> 2009330: c0 24 20 34 clr [ %l0 + 0x34 ] case CORE_RWLOCK_LOCKED_FOR_READING: the_rwlock->number_of_readers -= 1; if ( the_rwlock->number_of_readers != 0 ) { /* must be unlocked again */ _ISR_Enable( level ); 2009334: 7f ff e6 95 call 2002d88 2009338: b0 10 20 00 clr %i0 200933c: 30 bf ff f6 b,a 2009314 <_CORE_RWLock_Release+0xc8> next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); if ( next ) { if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 2009340: 82 10 20 02 mov 2, %g1 2009344: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 2009348: 81 c7 e0 08 ret 200934c: 91 e8 20 00 restore %g0, 0, %o0 02009350 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 2009350: 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 ) ) { 2009354: 92 96 20 00 orcc %i0, 0, %o1 2009358: 12 80 00 1a bne 20093c0 <_CORE_RWLock_Timeout+0x70> 200935c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009360: 31 00 80 71 sethi %hi(0x201c400), %i0 <== NOT EXECUTED 2009364: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 ! 201c490 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2009368: 82 00 60 01 inc %g1 <== NOT EXECUTED 200936c: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== 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; 2009370: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED 2009374: d2 00 61 70 ld [ %g1 + 0x170 ], %o1 ! 201c570 <_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; 2009378: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 200937c: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 2009380: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 2009384: 80 a0 e0 00 cmp %g3, 0 2009388: 02 80 00 06 be 20093a0 <_CORE_RWLock_Timeout+0x50> 200938c: 03 00 80 71 sethi %hi(0x201c400), %g1 2009390: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201c570 <_Thread_Executing> <== NOT EXECUTED 2009394: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 2009398: 02 80 00 20 be 2009418 <_CORE_RWLock_Timeout+0xc8> <== NOT EXECUTED 200939c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 20093a0: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 20093a4: 40 00 0a d0 call 200bee4 <_Thread_queue_Extract> 20093a8: 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; 20093ac: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 20093b0: 82 00 7f ff add %g1, -1, %g1 20093b4: c2 26 20 90 st %g1, [ %i0 + 0x90 ] 20093b8: 81 c7 e0 08 ret 20093bc: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20093c0: 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 ) { 20093c4: 80 a0 a0 04 cmp %g2, 4 20093c8: 18 bf ff fc bgu 20093b8 <_CORE_RWLock_Timeout+0x68> 20093cc: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20093d0: 80 a0 60 01 cmp %g1, 1 20093d4: 12 bf ff f9 bne 20093b8 <_CORE_RWLock_Timeout+0x68> 20093d8: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20093dc: 05 00 80 70 sethi %hi(0x201c000), %g2 20093e0: 84 10 a3 f0 or %g2, 0x3f0, %g2 ! 201c3f0 <_Objects_Information_table> 20093e4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20093e8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20093ec: 80 a2 20 00 cmp %o0, 0 20093f0: 02 bf ff f2 be 20093b8 <_CORE_RWLock_Timeout+0x68> 20093f4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20093f8: 40 00 03 4a call 200a120 <_Objects_Get> 20093fc: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009400: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009404: 80 a0 60 00 cmp %g1, 0 2009408: 12 bf ff ec bne 20093b8 <_CORE_RWLock_Timeout+0x68> 200940c: 92 10 00 08 mov %o0, %o1 2009410: 10 bf ff db b 200937c <_CORE_RWLock_Timeout+0x2c> 2009414: 31 00 80 71 sethi %hi(0x201c400), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 2009418: 02 bf ff e5 be 20093ac <_CORE_RWLock_Timeout+0x5c> <== NOT EXECUTED 200941c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2009420: 10 bf ff e3 b 20093ac <_CORE_RWLock_Timeout+0x5c> <== NOT EXECUTED 2009424: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 02014024 <_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 ) { 2014024: 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 ) { 2014028: 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 ) { 201402c: 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 ) { 2014030: 80 a0 40 1a cmp %g1, %i2 2014034: 0a 80 00 17 bcs 2014090 <_CORE_message_queue_Broadcast+0x6c> 2014038: 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 ) { 201403c: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1 2014040: 80 a0 60 00 cmp %g1, 0 2014044: 02 80 00 0a be 201406c <_CORE_message_queue_Broadcast+0x48> 2014048: a2 10 20 00 clr %l1 *count = 0; 201404c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED 2014050: 81 c7 e0 08 ret <== NOT EXECUTED 2014054: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2014058: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 201405c: 40 00 25 52 call 201d5a4 2014060: a2 04 60 01 inc %l1 buffer, waitp->return_argument, size ); *(uint32_t *)the_thread->Wait.return_argument_1 = size; 2014064: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 2014068: 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))) { 201406c: 40 00 0b c9 call 2016f90 <_Thread_queue_Dequeue> 2014070: 90 10 00 12 mov %l2, %o0 2014074: 92 10 00 19 mov %i1, %o1 2014078: a0 10 00 08 mov %o0, %l0 201407c: 80 a2 20 00 cmp %o0, 0 2014080: 12 bf ff f6 bne 2014058 <_CORE_message_queue_Broadcast+0x34> 2014084: 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; 2014088: e2 27 40 00 st %l1, [ %i5 ] 201408c: b0 10 20 00 clr %i0 return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 2014090: 81 c7 e0 08 ret 2014094: 81 e8 00 00 restore 02014b84 <_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 ) { 2014b84: 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; 2014b88: 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; 2014b8c: 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; 2014b90: 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; 2014b94: c0 26 20 60 clr [ %i0 + 0x60 ] the_message_queue->notify_argument = the_argument; 2014b98: 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)) { 2014b9c: 80 8e e0 03 btst 3, %i3 2014ba0: 02 80 00 07 be 2014bbc <_CORE_message_queue_Initialize+0x38> 2014ba4: a0 10 00 1b mov %i3, %l0 allocated_message_size += sizeof(uint32_t); 2014ba8: 82 06 e0 04 add %i3, 4, %g1 allocated_message_size &= ~(sizeof(uint32_t) - 1); 2014bac: a0 08 7f fc and %g1, -4, %l0 } if (allocated_message_size < maximum_message_size) 2014bb0: 80 a6 c0 10 cmp %i3, %l0 2014bb4: 18 80 00 09 bgu 2014bd8 <_CORE_message_queue_Initialize+0x54> 2014bb8: 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 * 2014bbc: b6 04 20 14 add %l0, 0x14, %i3 2014bc0: 92 10 00 1a mov %i2, %o1 2014bc4: 40 00 2a 66 call 201f55c <.umul> 2014bc8: 90 10 00 1b mov %i3, %o0 (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 2014bcc: 80 a2 00 10 cmp %o0, %l0 2014bd0: 1a 80 00 04 bcc 2014be0 <_CORE_message_queue_Initialize+0x5c> 2014bd4: 92 10 00 08 mov %o0, %o1 STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return TRUE; } 2014bd8: 81 c7 e0 08 ret <== NOT EXECUTED 2014bdc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 2014be0: 11 00 80 93 sethi %hi(0x2024c00), %o0 2014be4: 7f ff e5 dd call 200e358 <_Heap_Allocate> 2014be8: 90 12 21 1c or %o0, 0x11c, %o0 ! 2024d1c <_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) 2014bec: 80 a2 20 00 cmp %o0, 0 2014bf0: 02 bf ff fa be 2014bd8 <_CORE_message_queue_Initialize+0x54> 2014bf4: d0 26 20 5c st %o0, [ %i0 + 0x5c ] /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 2014bf8: 92 10 00 08 mov %o0, %o1 2014bfc: 94 10 00 1a mov %i2, %o2 2014c00: 90 06 20 68 add %i0, 0x68, %o0 2014c04: 7f ff ff 73 call 20149d0 <_Chain_Initialize> 2014c08: 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( 2014c0c: c2 06 40 00 ld [ %i1 ], %g1 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2014c10: 84 06 20 50 add %i0, 0x50, %g2 2014c14: 82 18 60 01 xor %g1, 1, %g1 2014c18: 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); 2014c1c: 82 06 20 54 add %i0, 0x54, %g1 the_chain->permanent_null = NULL; 2014c20: c0 26 20 54 clr [ %i0 + 0x54 ] 2014c24: 90 10 00 18 mov %i0, %o0 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2014c28: c2 26 20 50 st %g1, [ %i0 + 0x50 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2014c2c: c4 26 20 58 st %g2, [ %i0 + 0x58 ] 2014c30: 92 60 3f ff subx %g0, -1, %o1 2014c34: 94 10 20 80 mov 0x80, %o2 2014c38: 96 10 20 06 mov 6, %o3 2014c3c: 7f ff f0 16 call 2010c94 <_Thread_queue_Initialize> 2014c40: b0 10 20 01 mov 1, %i0 2014c44: 81 c7 e0 08 ret 2014c48: 81 e8 00 00 restore 02016e1c <_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 ) { 2016e1c: 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 ) { 2016e20: 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 ) { 2016e24: 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 ) { 2016e28: 80 a0 40 1a cmp %g1, %i2 2016e2c: 0a 80 00 22 bcs 2016eb4 <_CORE_message_queue_Submit+0x98> 2016e30: 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 ) { 2016e34: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 2016e38: 80 a0 a0 00 cmp %g2, 0 2016e3c: 02 80 00 22 be 2016ec4 <_CORE_message_queue_Submit+0xa8> 2016e40: 01 00 00 00 nop /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 2016e44: c2 04 60 44 ld [ %l1 + 0x44 ], %g1 2016e48: 80 a0 40 02 cmp %g1, %g2 2016e4c: 18 80 00 2b bgu 2016ef8 <_CORE_message_queue_Submit+0xdc> 2016e50: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * 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 ) { 2016e54: 80 a0 60 00 cmp %g1, 0 2016e58: 02 80 00 17 be 2016eb4 <_CORE_message_queue_Submit+0x98> 2016e5c: 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() ) { 2016e60: 03 00 80 ad sethi %hi(0x202b400), %g1 2016e64: c4 00 63 28 ld [ %g1 + 0x328 ], %g2 ! 202b728 <_ISR_Nest_level> 2016e68: 80 a0 a0 00 cmp %g2, 0 2016e6c: 12 80 00 14 bne 2016ebc <_CORE_message_queue_Submit+0xa0> 2016e70: 03 00 80 ad sethi %hi(0x202b400), %g1 */ { Thread_Control *executing = _Thread_Executing; _ISR_Disable( level ); 2016e74: 7f ff ad eb call 2002620 2016e78: e0 00 63 40 ld [ %g1 + 0x340 ], %l0 ! 202b740 <_Thread_Executing> 2016e7c: 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; 2016e80: 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; 2016e84: f6 24 20 20 st %i3, [ %l0 + 0x20 ] executing->Wait.return_argument = buffer; 2016e88: f2 24 20 28 st %i1, [ %l0 + 0x28 ] executing->Wait.option = size; 2016e8c: 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; 2016e90: e2 24 20 44 st %l1, [ %l0 + 0x44 ] 2016e94: 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 ); 2016e98: 7f ff ad e6 call 2002630 2016e9c: b0 10 20 07 mov 7, %i0 _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 2016ea0: d2 07 a0 60 ld [ %fp + 0x60 ], %o1 2016ea4: 90 10 00 11 mov %l1, %o0 2016ea8: 15 00 80 44 sethi %hi(0x2011000), %o2 2016eac: 7f ff e7 40 call 2010bac <_Thread_queue_Enqueue_with_handler> 2016eb0: 94 12 a0 ec or %o2, 0xec, %o2 ! 20110ec <_Thread_queue_Timeout> 2016eb4: 81 c7 e0 08 ret 2016eb8: 81 e8 00 00 restore } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 2016ebc: 81 c7 e0 08 ret <== NOT EXECUTED 2016ec0: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 2016ec4: 7f ff e6 cc call 20109f4 <_Thread_queue_Dequeue> 2016ec8: 90 10 00 11 mov %l1, %o0 if ( the_thread ) { 2016ecc: a0 92 20 00 orcc %o0, 0, %l0 2016ed0: 02 80 00 1b be 2016f3c <_CORE_message_queue_Submit+0x120> 2016ed4: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2016ed8: d0 04 20 28 ld [ %l0 + 0x28 ], %o0 2016edc: 40 00 13 d2 call 201be24 2016ee0: 94 10 00 1a mov %i2, %o2 _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument, size ); *(size_t *)the_thread->Wait.return_argument_1 = size; 2016ee4: c2 04 20 2c ld [ %l0 + 0x2c ], %g1 the_thread->Wait.count = submit_type; 2016ee8: 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; 2016eec: f4 20 40 00 st %i2, [ %g1 ] the_thread->Wait.count = submit_type; 2016ef0: 81 c7 e0 08 ret 2016ef4: 91 e8 20 00 restore %g0, 0, %o0 RTEMS_INLINE_ROUTINE CORE_message_queue_Buffer_control * _CORE_message_queue_Allocate_message_buffer ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) 2016ef8: 7f ff dc 55 call 200e04c <_Chain_Get> 2016efc: 90 04 60 68 add %l1, 0x68, %o0 /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 2016f00: a0 92 20 00 orcc %o0, 0, %l0 2016f04: 02 bf ff ee be 2016ebc <_CORE_message_queue_Submit+0xa0> 2016f08: 92 10 00 19 mov %i1, %o1 const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 2016f0c: 94 10 00 1a mov %i2, %o2 2016f10: 40 00 13 c5 call 201be24 2016f14: 90 04 20 10 add %l0, 0x10, %o0 size ); the_message->Contents.size = size; the_message->priority = submit_type; _CORE_message_queue_Insert_message( 2016f18: 90 10 00 11 mov %l1, %o0 _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 2016f1c: f4 24 20 0c st %i2, [ %l0 + 0xc ] the_message->priority = submit_type; 2016f20: fa 24 20 08 st %i5, [ %l0 + 8 ] _CORE_message_queue_Insert_message( 2016f24: 92 10 00 10 mov %l0, %o1 2016f28: 94 10 00 1d mov %i5, %o2 2016f2c: 40 00 0c 69 call 201a0d0 <_CORE_message_queue_Insert_message> 2016f30: b0 10 20 00 clr %i0 2016f34: 81 c7 e0 08 ret 2016f38: 81 e8 00 00 restore * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); if ( the_thread ) { 2016f3c: 10 bf ff c2 b 2016e44 <_CORE_message_queue_Submit+0x28> 2016f40: c4 04 60 48 ld [ %l1 + 0x48 ], %g2 02006e54 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 2006e54: 9d e3 bf 98 save %sp, -104, %sp /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006e58: c2 06 40 00 ld [ %i1 ], %g1 CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 2006e5c: 90 10 00 18 mov %i0, %o0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006e60: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 2006e64: c4 06 60 04 ld [ %i1 + 4 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 2006e68: 80 a6 a0 00 cmp %i2, 0 /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006e6c: c4 26 20 44 st %g2, [ %i0 + 0x44 ] 2006e70: c8 06 60 08 ld [ %i1 + 8 ], %g4 2006e74: c8 26 20 48 st %g4, [ %i0 + 0x48 ] 2006e78: da 06 60 0c ld [ %i1 + 0xc ], %o5 the_mutex->lock = initial_lock; 2006e7c: f4 26 20 50 st %i2, [ %i0 + 0x50 ] /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 2006e80: da 26 20 4c st %o5, [ %i0 + 0x4c ] the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { 2006e84: 12 80 00 1c bne 2006ef4 <_CORE_mutex_Initialize+0xa0> 2006e88: c0 26 20 58 clr [ %i0 + 0x58 ] the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006e8c: 19 00 80 66 sethi %hi(0x2019800), %o4 2006e90: c6 03 21 20 ld [ %o4 + 0x120 ], %g3 ! 2019920 <_Thread_Executing> the_mutex->Attributes = *the_mutex_attributes; the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; 2006e94: 82 10 20 01 mov 1, %g1 2006e98: c2 26 20 54 st %g1, [ %i0 + 0x54 ] the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; 2006e9c: c4 00 e0 08 ld [ %g3 + 8 ], %g2 the_mutex->lock = initial_lock; the_mutex->blocked_count = 0; if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; 2006ea0: c6 26 20 5c st %g3, [ %i0 + 0x5c ] the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006ea4: 80 a1 20 02 cmp %g4, 2 2006ea8: 12 80 00 1f bne 2006f24 <_CORE_mutex_Initialize+0xd0> 2006eac: c4 26 20 60 st %g2, [ %i0 + 0x60 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 2006eb0: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 2006eb4: 80 a0 40 0d cmp %g1, %o5 2006eb8: 0a 80 00 0d bcs 2006eec <_CORE_mutex_Initialize+0x98> 2006ebc: b0 10 20 06 mov 6, %i0 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006ec0: c4 03 21 20 ld [ %o4 + 0x120 ], %g2 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006ec4: 94 10 24 00 mov 0x400, %o2 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006ec8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006ecc: 96 10 20 05 mov 5, %o3 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; 2006ed0: 82 00 60 01 inc %g1 2006ed4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006ed8: c2 06 60 08 ld [ %i1 + 8 ], %g1 2006edc: b0 10 20 00 clr %i0 2006ee0: 80 a0 00 01 cmp %g0, %g1 2006ee4: 40 00 0b 95 call 2009d38 <_Thread_queue_Initialize> 2006ee8: 92 40 20 00 addx %g0, 0, %o1 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006eec: 81 c7 e0 08 ret 2006ef0: 81 e8 00 00 restore the_mutex->nest_count = 0; the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006ef4: c2 06 60 08 ld [ %i1 + 8 ], %g1 if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; 2006ef8: c0 26 20 54 clr [ %i0 + 0x54 ] the_mutex->holder = NULL; the_mutex->holder_id = 0; } _Thread_queue_Initialize( 2006efc: 80 a0 00 01 cmp %g0, %g1 the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; _Thread_Executing->resource_count++; } else { the_mutex->nest_count = 0; the_mutex->holder = NULL; 2006f00: c0 26 20 5c clr [ %i0 + 0x5c ] the_mutex->holder_id = 0; 2006f04: c0 26 20 60 clr [ %i0 + 0x60 ] } _Thread_queue_Initialize( 2006f08: 92 40 20 00 addx %g0, 0, %o1 2006f0c: 94 10 24 00 mov 0x400, %o2 2006f10: 96 10 20 05 mov 5, %o3 2006f14: 40 00 0b 89 call 2009d38 <_Thread_queue_Initialize> 2006f18: b0 10 20 00 clr %i0 STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 2006f1c: 81 c7 e0 08 ret 2006f20: 81 e8 00 00 restore if ( initial_lock == CORE_MUTEX_LOCKED ) { the_mutex->nest_count = 1; the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2006f24: 80 a1 20 03 cmp %g4, 3 2006f28: 32 bf ff e7 bne,a 2006ec4 <_CORE_mutex_Initialize+0x70> 2006f2c: c4 03 21 20 ld [ %o4 + 0x120 ], %g2 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) if ( _Thread_Executing->current_priority < 2006f30: 10 bf ff e1 b 2006eb4 <_CORE_mutex_Initialize+0x60> <== NOT EXECUTED 2006f34: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED 02006f38 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 2006f38: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 2006f3c: c4 06 20 48 ld [ %i0 + 0x48 ], %g2 Watchdog_Interval timeout ) { Thread_Control *executing; executing = _Thread_Executing; 2006f40: 03 00 80 66 sethi %hi(0x2019800), %g1 if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 2006f44: 80 a0 a0 02 cmp %g2, 2 2006f48: 12 80 00 08 bne 2006f68 <_CORE_mutex_Seize_interrupt_blocking+0x30> 2006f4c: d2 00 61 20 ld [ %g1 + 0x120 ], %o1 if ( the_mutex->holder->current_priority > executing->current_priority ) { 2006f50: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 2006f54: d2 02 60 14 ld [ %o1 + 0x14 ], %o1 2006f58: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006f5c: 80 a0 40 09 cmp %g1, %o1 2006f60: 18 80 00 16 bgu 2006fb8 <_CORE_mutex_Seize_interrupt_blocking+0x80> 2006f64: 01 00 00 00 nop FALSE ); } } the_mutex->blocked_count++; 2006f68: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006f6c: 90 10 00 18 mov %i0, %o0 FALSE ); } } the_mutex->blocked_count++; 2006f70: 82 00 60 01 inc %g1 _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006f74: 92 10 00 19 mov %i1, %o1 FALSE ); } } the_mutex->blocked_count++; 2006f78: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 2006f7c: 15 00 80 27 sethi %hi(0x2009c00), %o2 2006f80: 40 00 0a 60 call 2009900 <_Thread_queue_Enqueue_with_handler> 2006f84: 94 12 a2 40 or %o2, 0x240, %o2 ! 2009e40 <_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 ) 2006f88: 05 00 80 66 sethi %hi(0x2019800), %g2 2006f8c: c2 00 a0 40 ld [ %g2 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 2006f90: 82 00 7f ff add %g1, -1, %g1 2006f94: c2 20 a0 40 st %g1, [ %g2 + 0x40 ] 2006f98: c6 00 a0 40 ld [ %g2 + 0x40 ], %g3 2006f9c: 80 a0 e0 00 cmp %g3, 0 2006fa0: 02 80 00 04 be 2006fb0 <_CORE_mutex_Seize_interrupt_blocking+0x78> 2006fa4: 01 00 00 00 nop 2006fa8: 81 c7 e0 08 ret <== NOT EXECUTED 2006fac: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2006fb0: 40 00 08 bb call 200929c <_Thread_Dispatch> 2006fb4: 81 e8 00 00 restore Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { _Thread_Change_priority( 2006fb8: 40 00 07 89 call 2008ddc <_Thread_Change_priority> 2006fbc: 94 10 20 00 clr %o2 FALSE ); } } the_mutex->blocked_count++; 2006fc0: 10 bf ff eb b 2006f6c <_CORE_mutex_Seize_interrupt_blocking+0x34> 2006fc4: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 02006fc8 <_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 ) { 2006fc8: 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 ) { 2006fcc: c2 06 20 44 ld [ %i0 + 0x44 ], %g1 CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 2006fd0: a0 10 00 18 mov %i0, %l0 * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 2006fd4: 80 a0 60 00 cmp %g1, 0 2006fd8: 02 80 00 07 be 2006ff4 <_CORE_mutex_Surrender+0x2c> 2006fdc: d0 06 20 5c ld [ %i0 + 0x5c ], %o0 if ( !_Thread_Is_executing( holder ) ) 2006fe0: 03 00 80 66 sethi %hi(0x2019800), %g1 2006fe4: c4 00 61 20 ld [ %g1 + 0x120 ], %g2 ! 2019920 <_Thread_Executing> 2006fe8: 80 a2 00 02 cmp %o0, %g2 2006fec: 12 80 00 49 bne 2007110 <_CORE_mutex_Surrender+0x148> 2006ff0: b0 10 20 03 mov 3, %i0 return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 2006ff4: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2006ff8: 80 a0 60 00 cmp %g1, 0 2006ffc: 22 80 00 45 be,a 2007110 <_CORE_mutex_Surrender+0x148> 2007000: b0 10 20 00 clr %i0 return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 2007004: 82 00 7f ff add %g1, -1, %g1 if ( the_mutex->nest_count != 0 ) { 2007008: 80 a0 60 00 cmp %g1, 0 200700c: 02 80 00 09 be 2007030 <_CORE_mutex_Surrender+0x68> 2007010: c2 24 20 54 st %g1, [ %l0 + 0x54 ] switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007014: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2007018: 80 a0 60 00 cmp %g1, 0 200701c: 02 80 00 3d be 2007110 <_CORE_mutex_Surrender+0x148> 2007020: b0 10 20 00 clr %i0 2007024: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2007028: 02 80 00 3a be 2007110 <_CORE_mutex_Surrender+0x148> <== NOT EXECUTED 200702c: b0 10 20 02 mov 2, %i0 <== 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; 2007030: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007034: 80 a0 a0 02 cmp %g2, 2 2007038: 22 80 00 2a be,a 20070e0 <_CORE_mutex_Surrender+0x118> 200703c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2007040: 80 a0 a0 03 cmp %g2, 3 2007044: 22 80 00 27 be,a 20070e0 <_CORE_mutex_Surrender+0x118> 2007048: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; the_mutex->holder = NULL; 200704c: c0 24 20 5c clr [ %l0 + 0x5c ] /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007050: 80 a0 a0 02 cmp %g2, 2 2007054: 02 80 00 17 be 20070b0 <_CORE_mutex_Surrender+0xe8> 2007058: c0 24 20 60 clr [ %l0 + 0x60 ] 200705c: 80 a0 a0 03 cmp %g2, 3 2007060: 22 80 00 15 be,a 20070b4 <_CORE_mutex_Surrender+0xec> 2007064: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 /* * 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 ) ) ) { 2007068: 40 00 09 b8 call 2009748 <_Thread_queue_Dequeue> 200706c: 90 10 00 10 mov %l0, %o0 2007070: 86 92 20 00 orcc %o0, 0, %g3 2007074: 02 80 00 2e be 200712c <_CORE_mutex_Surrender+0x164> 2007078: 82 10 20 01 mov 1, %g1 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 200707c: c2 00 e0 08 ld [ %g3 + 8 ], %g1 the_mutex->nest_count = 1; switch ( the_mutex->Attributes.discipline ) { 2007080: c4 04 20 48 ld [ %l0 + 0x48 ], %g2 } else #endif { the_mutex->holder = the_thread; the_mutex->holder_id = the_thread->Object.id; 2007084: c2 24 20 60 st %g1, [ %l0 + 0x60 ] } else #endif { the_mutex->holder = the_thread; 2007088: c6 24 20 5c st %g3, [ %l0 + 0x5c ] the_mutex->holder_id = the_thread->Object.id; the_mutex->nest_count = 1; 200708c: 82 10 20 01 mov 1, %g1 switch ( the_mutex->Attributes.discipline ) { 2007090: 80 a0 a0 02 cmp %g2, 2 2007094: 02 80 00 21 be 2007118 <_CORE_mutex_Surrender+0x150> 2007098: c2 24 20 54 st %g1, [ %l0 + 0x54 ] 200709c: 80 a0 a0 03 cmp %g2, 3 20070a0: 22 80 00 13 be,a 20070ec <_CORE_mutex_Surrender+0x124> 20070a4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 20070a8: 81 c7 e0 08 ret 20070ac: 91 e8 20 00 restore %g0, 0, %o0 * 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 ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( holder->resource_count == 0 && 20070b0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 20070b4: 80 a0 60 00 cmp %g1, 0 20070b8: 12 bf ff ec bne 2007068 <_CORE_mutex_Surrender+0xa0> 20070bc: 01 00 00 00 nop 20070c0: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 20070c4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 20070c8: 80 a2 40 01 cmp %o1, %g1 20070cc: 02 bf ff e7 be 2007068 <_CORE_mutex_Surrender+0xa0> 20070d0: 01 00 00 00 nop holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 20070d4: 40 00 07 42 call 2008ddc <_Thread_Change_priority> 20070d8: 94 10 20 01 mov 1, %o2 ! 1 20070dc: 30 bf ff e3 b,a 2007068 <_CORE_mutex_Surrender+0xa0> * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) holder->resource_count--; 20070e0: 82 00 7f ff add %g1, -1, %g1 20070e4: 10 bf ff da b 200704c <_CORE_mutex_Surrender+0x84> 20070e8: c2 22 20 1c st %g1, [ %o0 + 0x1c ] case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_thread->resource_count++; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: the_thread->resource_count++; if (the_mutex->Attributes.priority_ceiling < 20070ec: 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++; 20070f0: 82 00 60 01 inc %g1 20070f4: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if (the_mutex->Attributes.priority_ceiling < 20070f8: d2 04 20 4c ld [ %l0 + 0x4c ], %o1 20070fc: 80 a2 40 02 cmp %o1, %g2 2007100: 1a 80 00 04 bcc 2007110 <_CORE_mutex_Surrender+0x148> 2007104: b0 10 20 00 clr %i0 the_thread->current_priority){ _Thread_Change_priority( 2007108: 40 00 07 35 call 2008ddc <_Thread_Change_priority> 200710c: 94 10 20 00 clr %o2 2007110: 81 c7 e0 08 ret 2007114: 81 e8 00 00 restore 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++; 2007118: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 200711c: 82 00 60 01 inc %g1 2007120: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 2007124: 81 c7 e0 08 ret 2007128: 91 e8 20 00 restore %g0, 0, %o0 } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 200712c: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2007130: 81 c7 e0 08 ret 2007134: 91 e8 20 00 restore %g0, 0, %o0 02007cd4 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 2007cd4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 2007cd8: 7f ff e9 f8 call 20024b8 2007cdc: 01 00 00 00 nop /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007ce0: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007ce4: 80 a0 60 00 cmp %g1, 0 2007ce8: 12 80 00 06 bne 2007d00 <_CORE_spinlock_Release+0x2c> 2007cec: 03 00 80 55 sethi %hi(0x2015400), %g1 _ISR_Enable( level ); 2007cf0: 7f ff e9 f6 call 20024c8 2007cf4: b0 10 20 06 mov 6, %i0 2007cf8: 81 c7 e0 08 ret 2007cfc: 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 ) { 2007d00: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 2007d04: c6 06 20 0c ld [ %i0 + 0xc ], %g3 2007d08: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007d0c: 80 a0 c0 01 cmp %g3, %g1 2007d10: 02 80 00 06 be 2007d28 <_CORE_spinlock_Release+0x54> 2007d14: 01 00 00 00 nop _ISR_Enable( level ); 2007d18: 7f ff e9 ec call 20024c8 <== NOT EXECUTED 2007d1c: b0 10 20 02 mov 2, %i0 ! 2 <== NOT EXECUTED 2007d20: 81 c7 e0 08 ret <== NOT EXECUTED 2007d24: 81 e8 00 00 restore <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 2007d28: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007d2c: 82 00 7f ff add %g1, -1, %g1 2007d30: c2 26 20 08 st %g1, [ %i0 + 8 ] the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 2007d34: c0 26 20 04 clr [ %i0 + 4 ] the_spinlock->holder = 0; 2007d38: c0 26 20 0c clr [ %i0 + 0xc ] _ISR_Enable( level ); 2007d3c: 7f ff e9 e3 call 20024c8 2007d40: b0 10 20 00 clr %i0 return CORE_SPINLOCK_SUCCESSFUL; } 2007d44: 81 c7 e0 08 ret 2007d48: 81 e8 00 00 restore 02007d4c <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, boolean wait, Watchdog_Interval timeout ) { 2007d4c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 2007d50: 23 00 80 55 sethi %hi(0x2015400), %l1 2007d54: c2 04 61 34 ld [ %l1 + 0x134 ], %g1 ! 2015534 <_Watchdog_Ticks_since_boot> _ISR_Disable( level ); 2007d58: 7f ff e9 d8 call 20024b8 2007d5c: a0 06 80 01 add %i2, %g1, %l0 2007d60: 88 10 00 08 mov %o0, %g4 if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 2007d64: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007d68: 80 a0 60 01 cmp %g1, 1 2007d6c: 02 80 00 45 be 2007e80 <_CORE_spinlock_Wait+0x134> 2007d70: 03 00 80 55 sethi %hi(0x2015400), %g1 (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 2007d74: c2 06 20 08 ld [ %i0 + 8 ], %g1 2007d78: 82 00 60 01 inc %g1 2007d7c: c2 26 20 08 st %g1, [ %i0 + 8 ] for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007d80: c4 06 20 04 ld [ %i0 + 4 ], %g2 2007d84: 80 a0 a0 00 cmp %g2, 0 2007d88: 02 80 00 2b be 2007e34 <_CORE_spinlock_Wait+0xe8> 2007d8c: 80 a6 60 00 cmp %i1, 0 } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 2007d90: 12 80 00 0d bne 2007dc4 <_CORE_spinlock_Wait+0x78> 2007d94: 33 00 80 54 sethi %hi(0x2015000), %i1 2007d98: 30 80 00 32 b,a 2007e60 <_CORE_spinlock_Wait+0x114> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007d9c: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 ! 20153b0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007da0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007da4: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] <== NOT EXECUTED /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 2007da8: 7f ff e9 c4 call 20024b8 <== NOT EXECUTED 2007dac: 01 00 00 00 nop <== NOT EXECUTED 2007db0: 88 10 00 08 mov %o0, %g4 <== NOT EXECUTED _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007db4: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2007db8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2007dbc: 02 80 00 1f be 2007e38 <_CORE_spinlock_Wait+0xec> <== NOT EXECUTED 2007dc0: 03 00 80 55 sethi %hi(0x2015400), %g1 <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 2007dc4: 80 a6 a0 00 cmp %i2, 0 2007dc8: 02 80 00 06 be 2007de0 <_CORE_spinlock_Wait+0x94> 2007dcc: 01 00 00 00 nop 2007dd0: c2 04 61 34 ld [ %l1 + 0x134 ], %g1 <== NOT EXECUTED 2007dd4: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 2007dd8: 08 80 00 34 bleu 2007ea8 <_CORE_spinlock_Wait+0x15c> <== NOT EXECUTED 2007ddc: 01 00 00 00 nop <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 2007de0: 7f ff e9 ba call 20024c8 2007de4: 90 10 00 04 mov %g4, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007de8: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 2007dec: 82 00 7f ff add %g1, -1, %g1 2007df0: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] 2007df4: c4 06 63 b0 ld [ %i1 + 0x3b0 ], %g2 2007df8: 80 a0 a0 00 cmp %g2, 0 2007dfc: 12 bf ff e8 bne 2007d9c <_CORE_spinlock_Wait+0x50> 2007e00: 01 00 00 00 nop _Thread_Dispatch(); 2007e04: 40 00 08 23 call 2009e90 <_Thread_Dispatch> 2007e08: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007e0c: c2 06 63 b0 ld [ %i1 + 0x3b0 ], %g1 2007e10: 82 00 60 01 inc %g1 2007e14: c2 26 63 b0 st %g1, [ %i1 + 0x3b0 ] /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 2007e18: 7f ff e9 a8 call 20024b8 2007e1c: 01 00 00 00 nop 2007e20: 88 10 00 08 mov %o0, %g4 _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 2007e24: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007e28: 80 a0 60 00 cmp %g1, 0 2007e2c: 12 bf ff e7 bne 2007dc8 <_CORE_spinlock_Wait+0x7c> 2007e30: 80 a6 a0 00 cmp %i2, 0 the_spinlock->lock = CORE_SPINLOCK_LOCKED; the_spinlock->holder = _Thread_Executing->Object.id; 2007e34: 03 00 80 55 sethi %hi(0x2015400), %g1 2007e38: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 ! 2015490 <_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; 2007e3c: 84 10 20 01 mov 1, %g2 2007e40: c4 26 20 04 st %g2, [ %i0 + 4 ] the_spinlock->holder = _Thread_Executing->Object.id; 2007e44: c2 00 e0 08 ld [ %g3 + 8 ], %g1 2007e48: c2 26 20 0c st %g1, [ %i0 + 0xc ] _ISR_Enable( level ); 2007e4c: b0 10 20 00 clr %i0 2007e50: 7f ff e9 9e call 20024c8 2007e54: 90 10 00 04 mov %g4, %o0 2007e58: 81 c7 e0 08 ret 2007e5c: 81 e8 00 00 restore /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { the_spinlock->users -= 1; 2007e60: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007e64: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007e68: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007e6c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 2007e70: 7f ff e9 96 call 20024c8 <== NOT EXECUTED 2007e74: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 2007e78: 81 c7 e0 08 ret <== NOT EXECUTED 2007e7c: 81 e8 00 00 restore <== NOT EXECUTED { ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; _ISR_Disable( level ); if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 2007e80: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 2007e84: c6 06 20 0c ld [ %i0 + 0xc ], %g3 2007e88: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2007e8c: 80 a0 c0 01 cmp %g3, %g1 2007e90: 12 bf ff b9 bne 2007d74 <_CORE_spinlock_Wait+0x28> 2007e94: 01 00 00 00 nop (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 2007e98: 7f ff e9 8c call 20024c8 2007e9c: b0 10 20 01 mov 1, %i0 ! 1 2007ea0: 81 c7 e0 08 ret 2007ea4: 81 e8 00 00 restore /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { the_spinlock->users -= 1; 2007ea8: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED 2007eac: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2007eb0: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED _ISR_Enable( level ); 2007eb4: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED 2007eb8: 7f ff e9 84 call 20024c8 <== NOT EXECUTED 2007ebc: 90 10 00 04 mov %g4, %o0 <== NOT EXECUTED 2007ec0: 81 c7 e0 08 ret <== NOT EXECUTED 2007ec4: 81 e8 00 00 restore <== NOT EXECUTED 0200d578 <_Debug_Is_enabled>: */ boolean _Debug_Is_enabled( rtems_debug_control level ) { 200d578: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200d57c: c4 00 61 24 ld [ %g1 + 0x124 ], %g2 ! 2019924 <_Debug_Level> <== NOT EXECUTED 200d580: 90 0a 00 02 and %o0, %g2, %o0 <== NOT EXECUTED return (_Debug_Level & level) ? TRUE : FALSE; } 200d584: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200d588: 81 c3 e0 08 retl <== NOT EXECUTED 200d58c: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED 02005564 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 2005564: 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; 2005568: 03 00 80 66 sethi %hi(0x2019800), %g1 200556c: e0 00 61 20 ld [ %g1 + 0x120 ], %l0 ! 2019920 <_Thread_Executing> executing->Wait.return_code = RTEMS_SUCCESSFUL; 2005570: c0 24 20 34 clr [ %l0 + 0x34 ] api = executing->API_Extensions[ THREAD_API_RTEMS ]; _ISR_Disable( level ); 2005574: 7f ff f2 22 call 2001dfc 2005578: e4 04 21 70 ld [ %l0 + 0x170 ], %l2 200557c: 84 10 00 08 mov %o0, %g2 pending_events = api->pending_events; 2005580: c2 04 a0 40 ld [ %l2 + 0x40 ], %g1 seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 2005584: a2 8e 00 01 andcc %i0, %g1, %l1 2005588: 02 80 00 0e be 20055c0 <_Event_Seize+0x5c> 200558c: 80 8e 60 01 btst 1, %i1 2005590: 80 a6 00 11 cmp %i0, %l1 2005594: 02 80 00 04 be 20055a4 <_Event_Seize+0x40> 2005598: 80 8e 60 02 btst 2, %i1 200559c: 02 80 00 09 be 20055c0 <_Event_Seize+0x5c> 20055a0: 80 8e 60 01 btst 1, %i1 (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 20055a4: 82 28 40 11 andn %g1, %l1, %g1 20055a8: c2 24 a0 40 st %g1, [ %l2 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 20055ac: 7f ff f2 18 call 2001e0c 20055b0: 01 00 00 00 nop *event_out = seized_events; 20055b4: e2 26 c0 00 st %l1, [ %i3 ] 20055b8: 81 c7 e0 08 ret 20055bc: 81 e8 00 00 restore return; } if ( _Options_Is_no_wait( option_set ) ) { 20055c0: 12 80 00 1e bne 2005638 <_Event_Seize+0xd4> 20055c4: 82 10 20 01 mov 1, %g1 executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = EVENT_SYNC_NOTHING_HAPPENED; 20055c8: 23 00 80 68 sethi %hi(0x201a000), %l1 executing->Wait.option = (uint32_t ) option_set; 20055cc: f2 24 20 30 st %i1, [ %l0 + 0x30 ] executing->Wait.count = (uint32_t ) event_in; 20055d0: f0 24 20 24 st %i0, [ %l0 + 0x24 ] executing->Wait.return_argument = event_out; 20055d4: 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; 20055d8: c2 24 62 24 st %g1, [ %l1 + 0x224 ] executing->Wait.option = (uint32_t ) option_set; executing->Wait.count = (uint32_t ) event_in; executing->Wait.return_argument = event_out; _ISR_Enable( level ); 20055dc: 7f ff f2 0c call 2001e0c 20055e0: 90 10 00 02 mov %g2, %o0 if ( ticks ) { 20055e4: 80 a6 a0 00 cmp %i2, 0 20055e8: 32 80 00 24 bne,a 2005678 <_Event_Seize+0x114> 20055ec: c2 04 20 08 ld [ %l0 + 8 ], %g1 NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20055f0: 90 10 00 10 mov %l0, %o0 20055f4: 40 00 12 63 call 2009f80 <_Thread_Set_state> 20055f8: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20055fc: 7f ff f2 00 call 2001dfc 2005600: 01 00 00 00 nop 2005604: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 2005608: c4 04 62 24 ld [ %l1 + 0x224 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 200560c: c0 24 62 24 clr [ %l1 + 0x224 ] switch ( sync_state ) { 2005610: 80 a0 a0 02 cmp %g2, 2 2005614: 02 80 00 30 be 20056d4 <_Event_Seize+0x170> 2005618: 82 10 20 06 mov 6, %g1 200561c: 80 a0 a0 03 cmp %g2, 3 2005620: 02 80 00 0d be 2005654 <_Event_Seize+0xf0> 2005624: 80 a0 a0 01 cmp %g2, 1 2005628: 02 80 00 31 be 20056ec <_Event_Seize+0x188> 200562c: 01 00 00 00 nop 2005630: 81 c7 e0 08 ret <== NOT EXECUTED 2005634: 81 e8 00 00 restore <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 2005638: 7f ff f1 f5 call 2001e0c 200563c: 90 10 00 02 mov %g2, %o0 executing->Wait.return_code = RTEMS_UNSATISFIED; 2005640: 82 10 20 0d mov 0xd, %g1 2005644: c2 24 20 34 st %g1, [ %l0 + 0x34 ] *event_out = seized_events; 2005648: e2 26 c0 00 st %l1, [ %i3 ] 200564c: 81 c7 e0 08 ret 2005650: 81 e8 00 00 restore _ISR_Enable( level ); _Thread_Unblock( executing ); return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { 2005654: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2005658: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200565c: 22 80 00 26 be,a 20056f4 <_Event_Seize+0x190> <== NOT EXECUTED 2005660: c4 24 20 50 st %g2, [ %l0 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &executing->Timer ); } else _ISR_Enable( level ); 2005664: 7f ff f1 ea call 2001e0c <== NOT EXECUTED 2005668: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200566c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2005670: 40 00 0e 4a call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 2005674: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005678: 92 04 20 48 add %l0, 0x48, %o1 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200567c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2005680: 03 00 80 16 sethi %hi(0x2005800), %g1 2005684: 82 10 61 28 or %g1, 0x128, %g1 ! 2005928 <_Event_Timeout> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2005688: f4 24 20 54 st %i2, [ %l0 + 0x54 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200568c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2005690: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2005694: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2005698: 11 00 80 66 sethi %hi(0x2019800), %o0 200569c: 40 00 14 55 call 200a7f0 <_Watchdog_Insert> 20056a0: 90 12 21 40 or %o0, 0x140, %o0 ! 2019940 <_Watchdog_Ticks_chain> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 20056a4: 90 10 00 10 mov %l0, %o0 20056a8: 40 00 12 36 call 2009f80 <_Thread_Set_state> 20056ac: 92 10 21 00 mov 0x100, %o1 _ISR_Disable( level ); 20056b0: 7f ff f1 d3 call 2001dfc 20056b4: 01 00 00 00 nop 20056b8: b0 10 00 08 mov %o0, %i0 sync_state = _Event_Sync_state; 20056bc: c4 04 62 24 ld [ %l1 + 0x224 ], %g2 _Event_Sync_state = EVENT_SYNC_SYNCHRONIZED; 20056c0: c0 24 62 24 clr [ %l1 + 0x224 ] switch ( sync_state ) { 20056c4: 80 a0 a0 02 cmp %g2, 2 20056c8: 12 bf ff d6 bne 2005620 <_Event_Seize+0xbc> 20056cc: 80 a0 a0 03 cmp %g2, 3 case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); return; case EVENT_SYNC_TIMEOUT: executing->Wait.return_code = RTEMS_TIMEOUT; 20056d0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20056d4: c2 24 20 34 st %g1, [ %l0 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20056d8: 7f ff f1 cd call 2001e0c <== NOT EXECUTED 20056dc: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 20056e0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 20056e4: 40 00 0e 2d call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 20056e8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED * enter the synchronization states above. */ return; case EVENT_SYNC_NOTHING_HAPPENED: _ISR_Enable( level ); 20056ec: 7f ff f1 c8 call 2001e0c 20056f0: 81 e8 00 00 restore return; case EVENT_SYNC_SATISFIED: if ( _Watchdog_Is_active( &executing->Timer ) ) { _Watchdog_Deactivate( &executing->Timer ); _ISR_Enable( level ); 20056f4: 7f ff f1 c6 call 2001e0c <== NOT EXECUTED 20056f8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED (void) _Watchdog_Remove( &executing->Timer ); 20056fc: 40 00 14 a7 call 200a998 <_Watchdog_Remove> <== NOT EXECUTED 2005700: 90 04 20 48 add %l0, 0x48, %o0 <== NOT EXECUTED 2005704: 10 bf ff db b 2005670 <_Event_Seize+0x10c> <== NOT EXECUTED 2005708: b2 16 63 f8 or %i1, 0x3f8, %i1 <== NOT EXECUTED 02005808 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 2005808: 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 ]; 200580c: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 option_set = (rtems_option) the_thread->Wait.option; 2005810: e4 06 20 30 ld [ %i0 + 0x30 ], %l2 _ISR_Disable( level ); 2005814: 7f ff f1 7a call 2001dfc 2005818: b2 10 00 18 mov %i0, %i1 200581c: a2 10 00 08 mov %o0, %l1 pending_events = api->pending_events; 2005820: c8 04 20 40 ld [ %l0 + 0x40 ], %g4 event_condition = (rtems_event_set) the_thread->Wait.count; 2005824: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 seized_events = _Event_sets_Get( pending_events, event_condition ); if ( !_Event_sets_Is_empty( seized_events ) ) { 2005828: 9a 88 c0 04 andcc %g3, %g4, %o5 200582c: 02 80 00 20 be 20058ac <_Event_Surrender+0xa4> 2005830: 01 00 00 00 nop if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 2005834: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 2005838: 80 88 61 00 btst 0x100, %g1 200583c: 02 80 00 08 be 200585c <_Event_Surrender+0x54> 2005840: 19 00 80 68 sethi %hi(0x201a000), %o4 if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 2005844: 80 a0 c0 0d cmp %g3, %o5 2005848: 02 80 00 1b be 20058b4 <_Event_Surrender+0xac> 200584c: 80 8c a0 02 btst 2, %l2 2005850: 12 80 00 1a bne 20058b8 <_Event_Surrender+0xb0> 2005854: 82 29 00 0d andn %g4, %o5, %g1 } return; } } switch ( _Event_Sync_state ) { 2005858: 19 00 80 68 sethi %hi(0x201a000), %o4 <== NOT EXECUTED 200585c: c2 03 22 24 ld [ %o4 + 0x224 ], %g1 ! 201a224 <_Event_Sync_state> <== NOT EXECUTED 2005860: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005864: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2005868: 18 80 00 11 bgu 20058ac <_Event_Surrender+0xa4> <== NOT EXECUTED 200586c: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED case EVENT_SYNC_SATISFIED: break; case EVENT_SYNC_NOTHING_HAPPENED: case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) 2005870: c4 00 61 20 ld [ %g1 + 0x120 ], %g2 ! 2019920 <_Thread_Executing> <== NOT EXECUTED 2005874: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 2005878: 12 80 00 0d bne 20058ac <_Event_Surrender+0xa4> <== NOT EXECUTED 200587c: 80 a0 c0 0d cmp %g3, %o5 <== NOT EXECUTED break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 2005880: 02 80 00 04 be 2005890 <_Event_Surrender+0x88> <== NOT EXECUTED 2005884: 80 8c a0 02 btst 2, %l2 <== NOT EXECUTED 2005888: 02 80 00 09 be 20058ac <_Event_Surrender+0xa4> <== NOT EXECUTED 200588c: 01 00 00 00 nop <== NOT EXECUTED api->pending_events = 2005890: 82 29 00 0d andn %g4, %o5, %g1 <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 2005894: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED case EVENT_SYNC_TIMEOUT: if ( !_Thread_Is_executing( the_thread ) ) break; if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = 2005898: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 200589c: c0 26 60 24 clr [ %i1 + 0x24 ] <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; _Event_Sync_state = EVENT_SYNC_SATISFIED; 20058a0: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED if ( seized_events == event_condition || _Options_Is_any(option_set) ) { api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20058a4: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_SATISFIED; 20058a8: c2 23 22 24 st %g1, [ %o4 + 0x224 ] <== NOT EXECUTED } break; } } _ISR_Enable( level ); 20058ac: 7f ff f1 58 call 2001e0c 20058b0: 91 e8 00 11 restore %g0, %l1, %o0 seized_events = _Event_sets_Get( pending_events, event_condition ); 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 = 20058b4: 82 29 00 0d andn %g4, %o5, %g1 _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20058b8: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 seized_events = _Event_sets_Get( pending_events, event_condition ); 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 = 20058bc: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 20058c0: c0 26 60 24 clr [ %i1 + 0x24 ] *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 20058c4: da 20 80 00 st %o5, [ %g2 ] _ISR_Flash( level ); 20058c8: 7f ff f1 51 call 2001e0c 20058cc: 01 00 00 00 nop 20058d0: 7f ff f1 4b call 2001dfc 20058d4: 01 00 00 00 nop if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20058d8: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 20058dc: 80 a0 60 02 cmp %g1, 2 20058e0: 02 80 00 08 be 2005900 <_Event_Surrender+0xf8> 20058e4: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 20058e8: 90 10 00 11 mov %l1, %o0 20058ec: 7f ff f1 48 call 2001e0c 20058f0: 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 ); 20058f4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 20058f8: 40 00 0d a8 call 2008f98 <_Thread_Clear_state> 20058fc: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2005900: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 2005904: 7f ff f1 42 call 2001e0c 2005908: 90 10 00 11 mov %l1, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 200590c: 40 00 14 23 call 200a998 <_Watchdog_Remove> 2005910: 90 06 60 48 add %i1, 0x48, %o0 2005914: 33 04 00 ff sethi %hi(0x1003fc00), %i1 2005918: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200591c: 40 00 0d 9f call 2008f98 <_Thread_Clear_state> 2005920: 81 e8 00 00 restore 2005924: 01 00 00 00 nop 02005928 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 2005928: 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 ) ) { 200592c: 92 96 20 00 orcc %i0, 0, %o1 2005930: 12 80 00 25 bne 20059c4 <_Event_Timeout+0x9c> 2005934: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005938: 21 00 80 66 sethi %hi(0x2019800), %l0 <== NOT EXECUTED 200593c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2005940: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005944: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== 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; 2005948: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200594c: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_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; 2005950: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 2005954: 7f ff f1 2a call 2001dfc 2005958: 01 00 00 00 nop 200595c: 88 10 00 08 mov %o0, %g4 if ( the_thread->Wait.count ) { /* verify thread is waiting */ 2005960: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 2005964: 80 a0 60 00 cmp %g1, 0 2005968: 02 80 00 3a be 2005a50 <_Event_Timeout+0x128> 200596c: 07 00 80 68 sethi %hi(0x201a000), %g3 the_thread->Wait.count = 0; if ( _Event_Sync_state != EVENT_SYNC_SYNCHRONIZED && 2005970: c2 00 e2 24 ld [ %g3 + 0x224 ], %g1 ! 201a224 <_Event_Sync_state> 2005974: 80 a0 60 00 cmp %g1, 0 2005978: 02 80 00 29 be 2005a1c <_Event_Timeout+0xf4> 200597c: c0 26 20 24 clr [ %i0 + 0x24 ] 2005980: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 2005984: c4 00 61 20 ld [ %g1 + 0x120 ], %g2 ! 2019920 <_Thread_Executing> <== NOT EXECUTED 2005988: 80 a6 00 02 cmp %i0, %g2 <== NOT EXECUTED 200598c: 12 80 00 25 bne 2005a20 <_Event_Timeout+0xf8> <== NOT EXECUTED 2005990: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { 2005994: c2 00 e2 24 ld [ %g3 + 0x224 ], %g1 <== NOT EXECUTED 2005998: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200599c: 02 80 00 03 be 20059a8 <_Event_Timeout+0x80> <== NOT EXECUTED 20059a0: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED _Event_Sync_state = EVENT_SYNC_TIMEOUT; 20059a4: c2 20 e2 24 st %g1, [ %g3 + 0x224 ] <== NOT EXECUTED } _ISR_Enable( level ); 20059a8: 7f ff f1 19 call 2001e0c <== NOT EXECUTED 20059ac: 01 00 00 00 nop <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 20059b0: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 <== NOT EXECUTED 20059b4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20059b8: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 20059bc: 81 c7 e0 08 ret <== NOT EXECUTED 20059c0: 81 e8 00 00 restore <== NOT EXECUTED 20059c4: 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 ) { 20059c8: 80 a0 a0 04 cmp %g2, 4 20059cc: 18 bf ff fc bgu 20059bc <_Event_Timeout+0x94> 20059d0: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20059d4: 80 a0 60 01 cmp %g1, 1 20059d8: 12 bf ff f9 bne 20059bc <_Event_Timeout+0x94> 20059dc: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20059e0: 05 00 80 65 sethi %hi(0x2019400), %g2 20059e4: 84 10 a3 a0 or %g2, 0x3a0, %g2 ! 20197a0 <_Objects_Information_table> 20059e8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20059ec: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20059f0: 80 a2 20 00 cmp %o0, 0 20059f4: 02 80 00 15 be 2005a48 <_Event_Timeout+0x120> 20059f8: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20059fc: 40 00 08 f4 call 2007dcc <_Objects_Get> 2005a00: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2005a04: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005a08: 80 a0 60 00 cmp %g1, 0 2005a0c: 12 bf ff ec bne 20059bc <_Event_Timeout+0x94> 2005a10: b0 10 00 08 mov %o0, %i0 2005a14: 10 bf ff d0 b 2005954 <_Event_Timeout+0x2c> 2005a18: 21 00 80 66 sethi %hi(0x2019800), %l0 if ( _Event_Sync_state != EVENT_SYNC_SATISFIED ) { _Event_Sync_state = EVENT_SYNC_TIMEOUT; } _ISR_Enable( level ); } else { the_thread->Wait.return_code = RTEMS_TIMEOUT; 2005a1c: 82 10 20 06 mov 6, %g1 2005a20: c2 26 20 34 st %g1, [ %i0 + 0x34 ] _ISR_Enable( level ); 2005a24: 7f ff f0 fa call 2001e0c 2005a28: 90 10 00 04 mov %g4, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2005a2c: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2005a30: 90 10 00 18 mov %i0, %o0 2005a34: 40 00 0d 59 call 2008f98 <_Thread_Clear_state> 2005a38: 92 12 63 f8 or %o1, 0x3f8, %o1 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2005a3c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2005a40: 82 00 7f ff add %g1, -1, %g1 2005a44: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 2005a48: 81 c7 e0 08 ret 2005a4c: 81 e8 00 00 restore _Thread_Unblock( the_thread ); } } else { _ISR_Enable( level ); 2005a50: 7f ff f0 ef call 2001e0c <== NOT EXECUTED 2005a54: 01 00 00 00 nop <== NOT EXECUTED 2005a58: 30 bf ff f9 b,a 2005a3c <_Event_Timeout+0x114> <== NOT EXECUTED 0200730c <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 200730c: 9d e3 bf 98 save %sp, -104, %sp Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 2007310: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 2007314: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 2007318: 90 10 00 19 mov %i1, %o0 200731c: 40 00 00 cd call 2007650 <_Heap_Calc_block_size> 2007320: a0 10 00 18 mov %i0, %l0 _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 2007324: 80 a2 20 00 cmp %o0, 0 2007328: 22 80 00 1a be,a 2007390 <_Heap_Allocate+0x84> 200732c: b0 10 20 00 clr %i0 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 2007330: f0 06 20 08 ld [ %i0 + 8 ], %i0 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 2007334: 80 a4 00 18 cmp %l0, %i0 2007338: 22 80 00 16 be,a 2007390 <_Heap_Allocate+0x84> 200733c: b0 10 20 00 clr %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 2007340: c2 06 20 04 ld [ %i0 + 4 ], %g1 2007344: 80 a2 00 01 cmp %o0, %g1 2007348: 08 80 00 16 bleu 20073a0 <_Heap_Allocate+0x94> 200734c: b2 10 20 00 clr %i1 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 2007350: 10 80 00 07 b 200736c <_Heap_Allocate+0x60> 2007354: f0 06 20 08 ld [ %i0 + 8 ], %i0 /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 2007358: c2 06 20 04 ld [ %i0 + 4 ], %g1 200735c: 80 a2 00 01 cmp %o0, %g1 2007360: 08 80 00 11 bleu 20073a4 <_Heap_Allocate+0x98> 2007364: 94 10 00 08 mov %o0, %o2 return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 2007368: f0 06 20 08 ld [ %i0 + 8 ], %i0 if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 200736c: 80 a4 00 18 cmp %l0, %i0 2007370: 12 bf ff fa bne 2007358 <_Heap_Allocate+0x4c> 2007374: b2 06 60 01 inc %i1 2007378: b0 10 20 00 clr %i0 _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 200737c: c2 04 20 44 ld [ %l0 + 0x44 ], %g1 2007380: 80 a6 40 01 cmp %i1, %g1 2007384: 08 80 00 05 bleu 2007398 <_Heap_Allocate+0x8c> 2007388: 01 00 00 00 nop stats->max_search = search_count; 200738c: f2 24 20 44 st %i1, [ %l0 + 0x44 ] 2007390: 81 c7 e0 08 ret 2007394: 81 e8 00 00 restore return ptr; } 2007398: 81 c7 e0 08 ret 200739c: 81 e8 00 00 restore _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 20073a0: 94 10 00 08 mov %o0, %o2 20073a4: 92 10 00 18 mov %i0, %o1 20073a8: 40 00 00 7e call 20075a0 <_Heap_Block_allocate> 20073ac: 90 10 00 10 mov %l0, %o0 ptr = _Heap_User_area(the_block); stats->allocs += 1; 20073b0: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 stats->searches += search_count + 1; 20073b4: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 20073b8: 82 00 60 01 inc %g1 stats->searches += search_count + 1; 20073bc: 84 00 a0 01 inc %g2 if(the_block->size >= the_size) { (void)_Heap_Block_allocate(the_heap, the_block, the_size ); ptr = _Heap_User_area(the_block); stats->allocs += 1; 20073c0: c2 24 20 48 st %g1, [ %l0 + 0x48 ] stats->searches += search_count + 1; 20073c4: 84 00 80 19 add %g2, %i1, %g2 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( void *base, uint32_t offset ) { return (void *)((char *)base + offset); 20073c8: b0 06 20 08 add %i0, 8, %i0 20073cc: 10 bf ff ec b 200737c <_Heap_Allocate+0x70> 20073d0: c4 24 20 4c st %g2, [ %l0 + 0x4c ] 0201a65c <_Heap_Get_free_information>: */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First ( Heap_Control *the_heap ) { return _Heap_Head(the_heap)->next; 201a65c: 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; 201a660: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED info->largest = 0; 201a664: c0 22 60 04 clr [ %o1 + 4 ] <== NOT EXECUTED info->total = 0; 201a668: c0 22 60 08 clr [ %o1 + 8 ] <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 201a66c: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 201a670: 02 80 00 12 be 201a6b8 <_Heap_Get_free_information+0x5c> <== NOT EXECUTED 201a674: 98 10 20 00 clr %o4 <== NOT EXECUTED 201a678: 84 10 00 0c mov %o4, %g2 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size ( Heap_Block *the_block ) { return (the_block->size & ~HEAP_PREV_USED); 201a67c: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; info->total += the_size; if ( info->largest < the_size ) 201a680: c6 02 60 04 ld [ %o1 + 4 ], %g3 <== NOT EXECUTED 201a684: 88 08 7f fe and %g1, -2, %g4 <== 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++; 201a688: 84 00 a0 01 inc %g2 <== NOT EXECUTED info->total += the_size; 201a68c: 82 03 00 04 add %o4, %g4, %g1 <== 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++; 201a690: c4 22 40 00 st %g2, [ %o1 ] <== NOT EXECUTED info->total += the_size; 201a694: c2 22 60 08 st %g1, [ %o1 + 8 ] <== NOT EXECUTED if ( info->largest < the_size ) 201a698: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED 201a69c: 08 80 00 03 bleu 201a6a8 <_Heap_Get_free_information+0x4c> <== NOT EXECUTED 201a6a0: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED info->largest = the_size; 201a6a4: c8 22 60 04 st %g4, [ %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) 201a6a8: 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; 201a6ac: 80 a2 00 0d cmp %o0, %o5 <== NOT EXECUTED 201a6b0: 32 bf ff f4 bne,a 201a680 <_Heap_Get_free_information+0x24> <== NOT EXECUTED 201a6b4: c2 03 60 04 ld [ %o5 + 4 ], %g1 <== NOT EXECUTED 201a6b8: 81 c3 e0 08 retl <== NOT EXECUTED 201a6bc: 01 00 00 00 nop 020076a0 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 20076a0: 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) 20076a4: 80 a6 e0 00 cmp %i3, 0 20076a8: 12 80 00 43 bne 20077b4 <_Heap_Initialize+0x114> 20076ac: 84 8e e0 07 andcc %i3, 7, %g2 20076b0: b6 10 20 08 mov 8, %i3 <== NOT EXECUTED 20076b4: a4 10 20 00 clr %l2 <== NOT EXECUTED /* 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; 20076b8: a0 06 60 08 add %i1, 8, %l0 uint32_t alignment ) { _H_uptr_t v = *value; uint32_t a = alignment; _H_uptr_t r = v % a; 20076bc: 92 10 00 1b mov %i3, %o1 20076c0: 40 00 3a c9 call 20161e4 <.urem> 20076c4: 90 10 00 10 mov %l0, %o0 *value = r ? v - r + a : v; 20076c8: 80 a2 20 00 cmp %o0, 0 20076cc: 02 80 00 05 be 20076e0 <_Heap_Initialize+0x40> 20076d0: a2 04 3f f8 add %l0, -8, %l1 20076d4: 82 06 c0 10 add %i3, %l0, %g1 20076d8: a0 20 40 08 sub %g1, %o0, %l0 _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 20076dc: a2 04 3f f8 add %l0, -8, %l1 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 20076e0: 80 a4 a0 00 cmp %l2, 0 20076e4: 02 80 00 04 be 20076f4 <_Heap_Initialize+0x54> 20076e8: 82 10 20 10 mov 0x10, %g1 20076ec: 82 06 e0 10 add %i3, 0x10, %g1 20076f0: 82 20 40 12 sub %g1, %l2, %g1 20076f4: c2 26 20 14 st %g1, [ %i0 + 0x14 ] /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 20076f8: 82 24 40 19 sub %l1, %i1, %g1 20076fc: 82 00 60 08 add %g1, 8, %g1 if ( size < overhead ) 2007700: 80 a0 40 1a cmp %g1, %i2 2007704: 18 80 00 2a bgu 20077ac <_Heap_Initialize+0x10c> 2007708: a0 26 80 01 sub %i2, %g1, %l0 uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200770c: 92 10 00 1b mov %i3, %o1 2007710: 40 00 3a b5 call 20161e4 <.urem> 2007714: 90 10 00 10 mov %l0, %o0 return 0; /* Too small area for the heap */ the_size = size - overhead; _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 2007718: a0 a4 00 08 subcc %l0, %o0, %l0 200771c: 02 80 00 24 be 20077ac <_Heap_Initialize+0x10c> 2007720: 09 00 80 65 sethi %hi(0x2019400), %g4 return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 2007724: f6 26 20 10 st %i3, [ %i0 + 0x10 ] the_heap->begin = starting_address; the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 2007728: f6 24 40 00 st %i3, [ %l1 ] the_block->size = the_size | HEAP_PREV_USED; 200772c: 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++; 2007730: c6 01 20 60 ld [ %g4 + 0x60 ], %g3 the_heap->end = starting_address + size; the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; 2007734: c2 24 60 04 st %g1, [ %l1 + 4 ] _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ 2007738: e0 24 40 10 st %l0, [ %l1 + %l0 ] RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200773c: 9a 04 40 10 add %l1, %l0, %o5 the_block->size = page_size; 2007740: f6 23 60 04 st %i3, [ %o5 + 4 ] the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; the_block->size = the_size | HEAP_PREV_USED; the_block->next = _Heap_Tail( the_heap ); 2007744: f0 24 60 08 st %i0, [ %l1 + 8 ] the_block->prev = _Heap_Head( the_heap ); 2007748: f0 24 60 0c st %i0, [ %l1 + 0xc ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 200774c: c6 26 20 28 st %g3, [ %i0 + 0x28 ] the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ the_block->prev_size = the_size; /* Previous block is free */ the_block->size = page_size; stats->size = size; 2007750: f4 26 20 2c st %i2, [ %i0 + 0x2c ] stats->free_size = the_size; 2007754: e0 26 20 30 st %l0, [ %i0 + 0x30 ] stats->min_free_size = the_size; 2007758: e0 26 20 34 st %l0, [ %i0 + 0x34 ] stats->free_blocks = 1; stats->max_free_blocks = 1; stats->used_blocks = 0; 200775c: c0 26 20 40 clr [ %i0 + 0x40 ] stats->max_search = 0; 2007760: c0 26 20 44 clr [ %i0 + 0x44 ] stats->allocs = 0; 2007764: c0 26 20 48 clr [ %i0 + 0x48 ] stats->searches = 0; 2007768: c0 26 20 4c clr [ %i0 + 0x4c ] stats->frees = 0; 200776c: c0 26 20 50 clr [ %i0 + 0x50 ] stats->resizes = 0; 2007770: c0 26 20 54 clr [ %i0 + 0x54 ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 2007774: 84 10 20 01 mov 1, %g2 stats->max_free_blocks = 1; 2007778: c4 26 20 3c st %g2, [ %i0 + 0x3c ] the_block->size = page_size; stats->size = size; stats->free_size = the_size; stats->min_free_size = the_size; stats->free_blocks = 1; 200777c: c4 26 20 38 st %g2, [ %i0 + 0x38 ] if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2007780: 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++; 2007784: 86 00 e0 01 inc %g3 if ( the_size == 0 ) return 0; /* Too small area for the heap */ the_heap->page_size = page_size; the_heap->begin = starting_address; the_heap->end = starting_address + size; 2007788: 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; 200778c: 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; 2007790: e2 26 20 08 st %l1, [ %i0 + 8 ] _Heap_Tail(the_heap)->prev = the_block; 2007794: e2 26 20 0c st %l1, [ %i0 + 0xc ] the_heap->start = the_block; 2007798: e2 26 20 20 st %l1, [ %i0 + 0x20 ] _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 200779c: da 26 20 24 st %o5, [ %i0 + 0x24 ] stats->max_search = 0; stats->allocs = 0; stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; 20077a0: c6 21 20 60 st %g3, [ %g4 + 0x60 ] return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 20077a4: 81 c7 e0 08 ret 20077a8: 91 ec 3f fc restore %l0, -4, %o0 } 20077ac: 81 c7 e0 08 ret 20077b0: 91 e8 20 00 restore %g0, 0, %o0 ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 20077b4: 02 80 00 04 be 20077c4 <_Heap_Initialize+0x124> 20077b8: 90 10 20 10 mov 0x10, %o0 20077bc: 82 06 e0 08 add %i3, 8, %g1 20077c0: b6 20 40 02 sub %g1, %g2, %i3 20077c4: 40 00 3a 88 call 20161e4 <.urem> 20077c8: 92 10 00 1b mov %i3, %o1 20077cc: 10 bf ff bb b 20076b8 <_Heap_Initialize+0x18> 20077d0: a4 10 00 08 mov %o0, %l2 0200d79c <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 200d79c: 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; 200d7a0: 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; 200d7a4: ee 06 20 14 ld [ %i0 + 0x14 ], %l7 <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; *old_mem_size = 0; 200d7a8: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED *avail_mem_size = 0; 200d7ac: 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); 200d7b0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200d7b4: 40 00 22 8c call 20161e4 <.urem> <== NOT EXECUTED 200d7b8: 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 ); 200d7bc: 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); 200d7c0: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200d7c4: 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)) 200d7c8: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 200d7cc: 1a 80 00 05 bcc 200d7e0 <_Heap_Resize_block+0x44> <== NOT EXECUTED 200d7d0: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 200d7d4: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED } 200d7d8: 81 c7 e0 08 ret <== NOT EXECUTED 200d7dc: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED *old_mem_size = 0; *avail_mem_size = 0; _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)) 200d7e0: 80 a4 80 02 cmp %l2, %g2 <== NOT EXECUTED 200d7e4: 38 bf ff fd bgu,a 200d7d8 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200d7e8: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 200d7ec: 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); 200d7f0: a8 08 ff fe and %g3, -2, %l4 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200d7f4: a2 04 80 14 add %l2, %l4, %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) || 200d7f8: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED 200d7fc: 2a bf ff f7 bcs,a 200d7d8 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200d800: 84 10 20 02 mov 2, %g2 <== NOT EXECUTED 200d804: 80 a4 40 02 cmp %l1, %g2 <== NOT EXECUTED 200d808: 38 bf ff f4 bgu,a 200d7d8 <_Heap_Resize_block+0x3c> <== NOT EXECUTED 200d80c: 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); 200d810: c2 04 60 04 ld [ %l1 + 4 ], %g1 <== NOT EXECUTED 200d814: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200d818: 02 bf ff ef be 200d7d4 <_Heap_Resize_block+0x38> <== NOT EXECUTED 200d81c: aa 08 7f fe and %g1, -2, %l5 <== 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) || 200d820: 80 a0 80 11 cmp %g2, %l1 <== NOT EXECUTED 200d824: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED 200d828: 02 80 00 04 be 200d838 <_Heap_Resize_block+0x9c> <== NOT EXECUTED 200d82c: ba 04 40 15 add %l1, %l5, %i5 <== NOT EXECUTED 200d830: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED 200d834: 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) 200d838: 82 24 40 19 sub %l1, %i1, %g1 <== NOT EXECUTED 200d83c: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 200d840: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED if (size > old_user_size) { 200d844: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED 200d848: 1a 80 00 16 bcc 200d8a0 <_Heap_Resize_block+0x104> <== NOT EXECUTED 200d84c: 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 */ 200d850: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200d854: 12 80 00 10 bne 200d894 <_Heap_Resize_block+0xf8> <== NOT EXECUTED 200d858: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 200d85c: 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; 200d860: 40 00 22 61 call 20161e4 <.urem> <== NOT EXECUTED 200d864: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED *value = r ? v - r + a : v; 200d868: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200d86c: 02 80 00 05 be 200d880 <_Heap_Resize_block+0xe4> <== NOT EXECUTED 200d870: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 200d874: 82 04 00 13 add %l0, %l3, %g1 <== NOT EXECUTED 200d878: a0 20 40 08 sub %g1, %o0, %l0 <== NOT EXECUTED 200d87c: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED 200d880: 0a 80 00 1d bcs 200d8f4 <_Heap_Resize_block+0x158> <== NOT EXECUTED 200d884: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _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) 200d888: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 200d88c: 1a 80 00 1f bcc 200d908 <_Heap_Resize_block+0x16c> <== NOT EXECUTED 200d890: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 200d894: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED } 200d898: 81 c7 e0 08 ret <== NOT EXECUTED 200d89c: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 200d8a0: a0 20 40 1a sub %g1, %i2, %l0 <== NOT EXECUTED uint32_t *value, uint32_t alignment ) { uint32_t v = *value; *value = v - (v % alignment); 200d8a4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 200d8a8: 40 00 22 4f call 20161e4 <.urem> <== NOT EXECUTED 200d8ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 200d8b0: a0 a4 00 08 subcc %l0, %o0, %l0 <== NOT EXECUTED 200d8b4: 22 80 00 0b be,a 200d8e0 <_Heap_Resize_block+0x144> <== NOT EXECUTED 200d8b8: 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; 200d8bc: 86 25 00 10 sub %l4, %l0, %g3 <== NOT EXECUTED if (new_block_size < min_block_size) { 200d8c0: 80 a5 c0 03 cmp %l7, %g3 <== NOT EXECUTED 200d8c4: 08 80 00 1c bleu 200d934 <_Heap_Resize_block+0x198> <== NOT EXECUTED 200d8c8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 200d8cc: 82 25 c0 03 sub %l7, %g3, %g1 <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 200d8d0: a0 a4 00 01 subcc %l0, %g1, %l0 <== NOT EXECUTED 200d8d4: 32 80 00 17 bne,a 200d930 <_Heap_Resize_block+0x194> <== NOT EXECUTED 200d8d8: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 200d8dc: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200d8e0: 84 10 20 00 clr %g2 <== NOT EXECUTED 200d8e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200d8e8: c2 26 20 54 st %g1, [ %i0 + 0x54 ] <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 200d8ec: 81 c7 e0 08 ret <== NOT EXECUTED 200d8f0: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED ) { uint32_t v = *value; uint32_t a = alignment; uint32_t r = v % a; *value = r ? v - r + a : v; 200d8f4: 90 10 00 17 mov %l7, %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) 200d8f8: 80 a5 40 08 cmp %l5, %o0 <== NOT EXECUTED 200d8fc: 0a bf ff e7 bcs 200d898 <_Heap_Resize_block+0xfc> <== NOT EXECUTED 200d900: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 200d904: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200d908: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 200d90c: 7f ff e7 25 call 20075a0 <_Heap_Block_allocate> <== NOT EXECUTED 200d910: 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; 200d914: 90 02 00 14 add %o0, %l4, %o0 <== NOT EXECUTED 200d918: 90 12 00 1b or %o0, %i3, %o0 <== NOT EXECUTED 200d91c: d0 24 a0 04 st %o0, [ %l2 + 4 ] <== NOT EXECUTED --stats->used_blocks; 200d920: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED 200d924: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200d928: 10 bf ff ed b 200d8dc <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d92c: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== 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) { 200d930: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 200d934: 12 80 00 15 bne 200d988 <_Heap_Resize_block+0x1ec> <== NOT EXECUTED 200d938: 80 a4 00 17 cmp %l0, %l7 <== 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; 200d93c: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED 200d940: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200d944: 86 04 80 03 add %l2, %g3, %g3 <== 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; 200d948: 88 04 00 15 add %l0, %l5, %g4 <== NOT EXECUTED Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; Heap_Block *prev = block->prev; 200d94c: d8 04 60 0c ld [ %l1 + 0xc ], %o4 <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; new_next_block->size = new_next_block_size | HEAP_PREV_USED; next_next_block->prev_size = new_next_block_size; 200d950: c8 27 40 00 st %g4, [ %i5 ] <== NOT EXECUTED Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *block = old_block; Heap_Block *next = block->next; 200d954: da 04 60 08 ld [ %l1 + 8 ], %o5 <== 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; 200d958: 84 11 20 01 or %g4, 1, %g2 <== NOT EXECUTED 200d95c: c4 20 e0 04 st %g2, [ %g3 + 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; 200d960: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Heap_Block *prev = block->prev; block = new_block; block->next = next; 200d964: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 200d968: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED block->prev = prev; 200d96c: d8 20 e0 0c st %o4, [ %g3 + 0xc ] <== NOT EXECUTED 200d970: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 200d974: 88 01 3f fc add %g4, -4, %g4 <== NOT EXECUTED next->prev = prev->next = block; 200d978: c6 23 60 0c st %g3, [ %o5 + 0xc ] <== NOT EXECUTED 200d97c: c6 23 20 08 st %g3, [ %o4 + 8 ] <== NOT EXECUTED 200d980: 10 bf ff d7 b 200d8dc <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d984: c8 27 00 00 st %g4, [ %i4 ] <== NOT EXECUTED } else if (free_block_size >= min_block_size) { 200d988: 2a bf ff d6 bcs,a 200d8e0 <_Heap_Resize_block+0x144> <== NOT EXECUTED 200d98c: 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; 200d990: 82 10 c0 1b or %g3, %i3, %g1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200d994: 84 14 20 01 or %l0, 1, %g2 <== NOT EXECUTED the_heap->stats.free_size += free_block_size; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 200d998: c2 24 a0 04 st %g1, [ %l2 + 4 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( void *base, uint32_t offset ) { return (Heap_Block *) _Addresses_Add_offset( base, offset ); 200d99c: 92 04 80 03 add %l2, %g3, %o1 <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 200d9a0: c4 22 60 04 st %g2, [ %o1 + 4 ] <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 200d9a4: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d9a8: 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 */ 200d9ac: 82 00 60 01 inc %g1 <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d9b0: 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 */ 200d9b4: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 200d9b8: c4 26 20 50 st %g2, [ %i0 + 0x50 ] <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 200d9bc: 92 02 60 08 add %o1, 8, %o1 <== NOT EXECUTED 200d9c0: 7f ff e6 85 call 20073d4 <_Heap_Free> <== NOT EXECUTED 200d9c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 200d9c8: 82 04 3f fc add %l0, -4, %g1 <== NOT EXECUTED 200d9cc: 10 bf ff c4 b 200d8dc <_Heap_Resize_block+0x140> <== NOT EXECUTED 200d9d0: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED 0200d9d4 <_Heap_Size_of_user_area>: boolean _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 200d9d4: 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( 200d9d8: e0 06 20 20 ld [ %i0 + 0x20 ], %l0 <== NOT EXECUTED 200d9dc: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED 200d9e0: 0a 80 00 05 bcs 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200d9e4: e2 06 20 24 ld [ %i0 + 0x24 ], %l1 <== NOT EXECUTED 200d9e8: 80 a6 40 11 cmp %i1, %l1 <== NOT EXECUTED 200d9ec: 28 80 00 04 bleu,a 200d9fc <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED 200d9f0: d2 06 20 10 ld [ %i0 + 0x10 ], %o1 <== NOT EXECUTED *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); } 200d9f4: 81 c7 e0 08 ret <== NOT EXECUTED 200d9f8: 91 e8 20 00 restore %g0, 0, %o0 <== 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); 200d9fc: 40 00 21 fa call 20161e4 <.urem> <== NOT EXECUTED 200da00: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 200da04: 90 26 40 08 sub %i1, %o0, %o0 <== NOT EXECUTED 200da08: 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 ) ) 200da0c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200da10: 0a bf ff f9 bcs 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200da14: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200da18: 18 bf ff f7 bgu 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200da1c: 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 ); 200da20: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200da24: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200da28: 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 ( 200da2c: 80 a2 00 10 cmp %o0, %l0 <== NOT EXECUTED 200da30: 0a bf ff f1 bcs 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200da34: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED 200da38: 18 bf ff ef bgu 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200da3c: 01 00 00 00 nop <== NOT EXECUTED 200da40: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 200da44: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200da48: 02 bf ff eb be 200d9f4 <_Heap_Size_of_user_area+0x20> <== NOT EXECUTED 200da4c: 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 ) 200da50: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED 200da54: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED 200da58: 81 c7 e0 08 ret <== NOT EXECUTED 200da5c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 02006adc <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 2006adc: 9d e3 bf 98 save %sp, -104, %sp /* * If the user claims there are less drivers than are actually in * the table, then let's just go with the table's count. */ if ( number_of_drivers <= drivers_in_table ) 2006ae0: 80 a6 80 19 cmp %i2, %i1 2006ae4: 08 80 00 27 bleu 2006b80 <_IO_Manager_initialization+0xa4> 2006ae8: 03 00 80 68 sethi %hi(0x201a000), %g1 /* * 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 *) 2006aec: 83 2e a0 03 sll %i2, 3, %g1 <== NOT EXECUTED 2006af0: a1 2e a0 05 sll %i2, 5, %l0 <== NOT EXECUTED 2006af4: a0 24 00 01 sub %l0, %g1, %l0 <== NOT EXECUTED 2006af8: 40 00 10 09 call 200ab1c <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 2006afc: 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; 2006b00: 03 00 80 68 sethi %hi(0x201a000), %g1 <== NOT EXECUTED memset( 2006b04: 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; 2006b08: f4 20 62 74 st %i2, [ %g1 + 0x274 ] <== 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 *) 2006b0c: 21 00 80 68 sethi %hi(0x201a000), %l0 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; memset( 2006b10: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006b14: 40 00 23 6d call 200f8c8 <== NOT EXECUTED 2006b18: d0 24 22 78 st %o0, [ %l0 + 0x278 ] <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b1c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2006b20: 02 80 00 16 be 2006b78 <_IO_Manager_initialization+0x9c> <== NOT EXECUTED 2006b24: d4 04 22 78 ld [ %l0 + 0x278 ], %o2 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b28: 96 10 20 00 clr %o3 <== NOT EXECUTED 2006b2c: 98 10 20 00 clr %o4 <== NOT EXECUTED 2006b30: c2 03 00 18 ld [ %o4 + %i0 ], %g1 <== NOT EXECUTED 2006b34: 9a 03 00 18 add %o4, %i0, %o5 <== NOT EXECUTED 2006b38: c2 23 00 0a st %g1, [ %o4 + %o2 ] <== NOT EXECUTED 2006b3c: c4 03 60 04 ld [ %o5 + 4 ], %g2 <== NOT EXECUTED 2006b40: 86 03 00 0a add %o4, %o2, %g3 <== NOT EXECUTED 2006b44: c4 20 e0 04 st %g2, [ %g3 + 4 ] <== NOT EXECUTED 2006b48: c2 03 60 08 ld [ %o5 + 8 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b4c: 96 02 e0 01 inc %o3 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b50: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED 2006b54: c4 03 60 0c ld [ %o5 + 0xc ], %g2 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b58: 98 03 20 18 add %o4, 0x18, %o4 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b5c: c4 20 e0 0c st %g2, [ %g3 + 0xc ] <== NOT EXECUTED 2006b60: c8 03 60 10 ld [ %o5 + 0x10 ], %g4 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b64: 80 a2 c0 19 cmp %o3, %i1 <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 2006b68: c8 20 e0 10 st %g4, [ %g3 + 0x10 ] <== NOT EXECUTED 2006b6c: c2 03 60 14 ld [ %o5 + 0x14 ], %g1 <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 2006b70: 12 bf ff f0 bne 2006b30 <_IO_Manager_initialization+0x54> <== NOT EXECUTED 2006b74: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] <== NOT EXECUTED 2006b78: 81 c7 e0 08 ret <== NOT EXECUTED 2006b7c: 81 e8 00 00 restore <== NOT EXECUTED * 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; _IO_Number_of_drivers = number_of_drivers; 2006b80: 05 00 80 68 sethi %hi(0x201a000), %g2 * If the maximum number of driver is the same as the number in the * table, then we do not have to copy the driver table. They can't * register any dynamically. */ if ( number_of_drivers == drivers_in_table ) { _IO_Driver_address_table = driver_table; 2006b84: f0 20 62 78 st %i0, [ %g1 + 0x278 ] _IO_Number_of_drivers = number_of_drivers; 2006b88: f2 20 a2 74 st %i1, [ %g2 + 0x274 ] 2006b8c: 81 c7 e0 08 ret 2006b90: 81 e8 00 00 restore 02007814 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 2007814: 9d e3 bf 98 save %sp, -104, %sp _ISR_Signals_to_thread_executing = FALSE; 2007818: 03 00 80 66 sethi %hi(0x2019800), %g1 _ISR_Nest_level = 0; 200781c: 05 00 80 66 sethi %hi(0x2019800), %g2 * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { _ISR_Signals_to_thread_executing = FALSE; 2007820: c0 20 61 c8 clr [ %g1 + 0x1c8 ] _ISR_Nest_level = 0; 2007824: c0 20 a1 08 clr [ %g2 + 0x108 ] _ISR_Vector_table = _Workspace_Allocate_or_fatal_error( 2007828: 40 00 0c bd call 200ab1c <_Workspace_Allocate_or_fatal_error> 200782c: 90 10 24 00 mov 0x400, %o0 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007830: 03 00 80 66 sethi %hi(0x2019800), %g1 2007834: a0 10 60 54 or %g1, 0x54, %l0 ! 2019854 <_CPU_Table> 2007838: 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( 200783c: 03 00 80 66 sethi %hi(0x2019800), %g1 _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( _CPU_Table.interrupt_stack_size < STACK_MINIMUM_SIZE ) 2007840: 80 a0 af ff cmp %g2, 0xfff 2007844: 18 80 00 07 bgu 2007860 <_ISR_Handler_initialization+0x4c> 2007848: d0 20 60 e4 st %o0, [ %g1 + 0xe4 ] _Internal_error_Occurred( 200784c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007850: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2007854: 7f ff ff e0 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2007858: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 200785c: c4 04 20 18 ld [ %l0 + 0x18 ], %g2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 2007860: 40 00 0c af call 200ab1c <_Workspace_Allocate_or_fatal_error> 2007864: 90 10 00 02 mov %g2, %o0 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 2007868: c6 04 20 18 ld [ %l0 + 0x18 ], %g3 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 200786c: 03 00 80 66 sethi %hi(0x2019800), %g1 _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 2007870: 86 02 00 03 add %o0, %g3, %g3 2007874: 05 00 80 65 sethi %hi(0x2019400), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = 2007878: d0 20 60 50 st %o0, [ %g1 + 0x50 ] _Workspace_Allocate_or_fatal_error( _CPU_Table.interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 200787c: c6 20 a3 9c st %g3, [ %g2 + 0x39c ] #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 2007880: 81 c7 e0 08 ret 2007884: 81 e8 00 00 restore 0201a224 <_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; 201a224: 95 32 a0 02 srl %o2, 2, %o2 <== NOT EXECUTED while ( tmp_length-- ) 201a228: 80 a2 a0 00 cmp %o2, 0 <== NOT EXECUTED 201a22c: 02 80 00 09 be 201a250 <_Objects_Copy_name_raw+0x2c> <== NOT EXECUTED 201a230: 86 10 20 00 clr %g3 <== NOT EXECUTED 201a234: 84 10 20 00 clr %g2 <== NOT EXECUTED *destination_p++ = *source_p++; 201a238: c2 00 80 08 ld [ %g2 + %o0 ], %g1 <== NOT EXECUTED 201a23c: 86 00 e0 01 inc %g3 <== NOT EXECUTED 201a240: c2 20 80 09 st %g1, [ %g2 + %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-- ) 201a244: 80 a0 c0 0a cmp %g3, %o2 <== NOT EXECUTED 201a248: 12 bf ff fc bne 201a238 <_Objects_Copy_name_raw+0x14> <== NOT EXECUTED 201a24c: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED 201a250: 81 c3 e0 08 retl <== NOT EXECUTED 201a254: 01 00 00 00 nop 0200793c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 200793c: 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; 2007940: 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 ) 2007944: e4 16 20 10 lduh [ %i0 + 0x10 ], %l2 2007948: 03 00 00 3f sethi %hi(0xfc00), %g1 200794c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2007950: a2 08 80 01 and %g2, %g1, %l1 2007954: 80 a4 40 12 cmp %l1, %l2 2007958: 08 80 00 8c bleu 2007b88 <_Objects_Extend_information+0x24c> 200795c: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007960: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 2007964: a8 10 00 11 mov %l1, %l4 2007968: ac 10 20 00 clr %l6 200796c: a6 10 20 01 mov 1, %l3 2007970: 90 10 20 03 mov 3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007974: 80 a0 60 00 cmp %g1, 0 2007978: 12 80 00 a4 bne 2007c08 <_Objects_Extend_information+0x2cc> 200797c: ba 04 00 12 add %l0, %l2, %i5 if ( !object_blocks ) return; } else { object_blocks = (void**) 2007980: 90 02 00 11 add %o0, %l1, %o0 2007984: 90 02 00 1d add %o0, %i5, %o0 2007988: 40 00 0c 65 call 200ab1c <_Workspace_Allocate_or_fatal_error> 200798c: 91 2a 20 02 sll %o0, 2, %o0 2007990: ae 10 00 08 mov %o0, %l7 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 2007994: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2007998: 83 2c e0 02 sll %l3, 2, %g1 /* * Take the block count down. Saves all the (block_count - 1) * in the copies. */ block_count--; 200799c: 86 04 ff ff add %l3, -1, %g3 if ( information->maximum > minimum_index ) { 20079a0: 80 a4 40 02 cmp %l1, %g2 /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 20079a4: a6 05 c0 01 add %l7, %g1, %l3 object_blocks, block_count * sizeof(void*) ); name_table = (Objects_Name *) _Addresses_Add_offset( 20079a8: aa 00 40 13 add %g1, %l3, %l5 * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 20079ac: 0a 80 00 ac bcs 2007c5c <_Objects_Extend_information+0x320> 20079b0: a4 00 40 15 add %g1, %l5, %l2 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 20079b4: 80 a4 60 00 cmp %l1, 0 20079b8: 02 80 00 09 be 20079dc <_Objects_Extend_information+0xa0> 20079bc: a1 28 e0 02 sll %g3, 2, %l0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 20079c0: 84 10 20 00 clr %g2 /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 20079c4: 83 28 a0 02 sll %g2, 2, %g1 else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 20079c8: 84 00 a0 01 inc %g2 20079cc: 80 a0 80 11 cmp %g2, %l1 20079d0: 12 bf ff fd bne 20079c4 <_Objects_Extend_information+0x88> 20079d4: c0 20 40 12 clr [ %g1 + %l2 ] 20079d8: a1 28 e0 02 sll %g3, 2, %l0 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 20079dc: c0 24 00 17 clr [ %l0 + %l7 ] inactive_per_block[block_count] = 0; 20079e0: c0 24 00 13 clr [ %l0 + %l3 ] name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); 20079e4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20079e8: 86 05 00 01 add %l4, %g1, %g3 20079ec: 80 a0 c0 14 cmp %g3, %l4 20079f0: 08 80 00 0a bleu 2007a18 <_Objects_Extend_information+0xdc> 20079f4: c0 25 40 10 clr [ %l5 + %l0 ] 20079f8: 83 2d 20 02 sll %l4, 2, %g1 20079fc: 84 04 80 01 add %l2, %g1, %g2 2007a00: 82 10 00 14 mov %l4, %g1 index++ ) { local_table[ index ] = NULL; 2007a04: c0 20 80 00 clr [ %g2 ] inactive_per_block[block_count] = 0; name_table[block_count] = NULL; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 2007a08: 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 ); 2007a0c: 80 a0 40 03 cmp %g1, %g3 2007a10: 12 bf ff fd bne 2007a04 <_Objects_Extend_information+0xc8> 2007a14: 84 00 a0 04 add %g2, 4, %g2 index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 2007a18: 7f ff e8 f9 call 2001dfc 2007a1c: 01 00 00 00 nop 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( 2007a20: c4 06 00 00 ld [ %i0 ], %g2 2007a24: c8 16 20 04 lduh [ %i0 + 4 ], %g4 2007a28: 87 2f 60 10 sll %i5, 0x10, %g3 2007a2c: 89 29 20 1b sll %g4, 0x1b, %g4 2007a30: 87 30 e0 10 srl %g3, 0x10, %g3 local_table[ index ] = NULL; } _ISR_Disable( level ); old_tables = information->object_blocks; 2007a34: e0 06 20 3c ld [ %i0 + 0x3c ], %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( 2007a38: 03 00 00 40 sethi %hi(0x10000), %g1 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; information->inactive_per_block = inactive_per_block; 2007a3c: e6 26 20 38 st %l3, [ %i0 + 0x38 ] information->name_table = name_table; 2007a40: ea 26 20 24 st %l5, [ %i0 + 0x24 ] information->local_table = local_table; 2007a44: e4 26 20 20 st %l2, [ %i0 + 0x20 ] information->maximum = maximum; information->maximum_id = _Objects_Build_id( 2007a48: 85 28 a0 18 sll %g2, 0x18, %g2 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; 2007a4c: fa 36 20 10 sth %i5, [ %i0 + 0x10 ] information->maximum_id = _Objects_Build_id( 2007a50: 84 10 80 01 or %g2, %g1, %g2 _ISR_Disable( level ); old_tables = information->object_blocks; information->object_blocks = object_blocks; 2007a54: ee 26 20 3c st %l7, [ %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( 2007a58: 84 10 80 04 or %g2, %g4, %g2 2007a5c: 84 10 80 03 or %g2, %g3, %g2 2007a60: c4 26 20 0c st %g2, [ %i0 + 0xc ] information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 2007a64: 7f ff e8 ea call 2001e0c 2007a68: 01 00 00 00 nop if ( old_tables ) 2007a6c: 80 a4 20 00 cmp %l0, 0 2007a70: 02 80 00 05 be 2007a84 <_Objects_Extend_information+0x148> 2007a74: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2007a78: 11 00 80 66 sethi %hi(0x2019800), %o0 2007a7c: 7f ff fe 56 call 20073d4 <_Heap_Free> 2007a80: 90 12 20 8c or %o0, 0x8c, %o0 ! 201988c <_Workspace_Area> /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 2007a84: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007a88: 80 a0 60 00 cmp %g1, 0 2007a8c: 02 80 00 6a be 2007c34 <_Objects_Extend_information+0x2f8> 2007a90: c2 16 20 44 lduh [ %i0 + 0x44 ], %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2007a94: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007a98: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 information->object_blocks[ block ] = 2007a9c: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 2007aa0: 40 00 38 eb call 2015e4c <.umul> 2007aa4: 90 00 40 08 add %g1, %o0, %o0 2007aa8: 92 10 00 08 mov %o0, %o1 2007aac: 11 00 80 66 sethi %hi(0x2019800), %o0 2007ab0: 7f ff fe 17 call 200730c <_Heap_Allocate> 2007ab4: 90 12 20 8c or %o0, 0x8c, %o0 ! 201988c <_Workspace_Area> _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2007ab8: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { information->object_blocks[ block ] = 2007abc: a7 2d a0 02 sll %l6, 2, %l3 2007ac0: d0 24 c0 10 st %o0, [ %l3 + %l0 ] _Workspace_Allocate( (information->allocation_size * information->name_length) + (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 2007ac4: c2 04 c0 12 ld [ %l3 + %l2 ], %g1 2007ac8: 80 a0 60 00 cmp %g1, 0 2007acc: 02 80 00 7b be 2007cb8 <_Objects_Extend_information+0x37c> 2007ad0: 01 00 00 00 nop 2007ad4: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007ad8: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007adc: 40 00 38 dc call 2015e4c <.umul> 2007ae0: a2 10 00 14 mov %l4, %l1 2007ae4: c2 04 80 13 ld [ %l2 + %l3 ], %g1 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007ae8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 2007aec: a0 02 00 01 add %o0, %g1, %l0 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007af0: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 name_area = (Objects_Name *) _Addresses_Add_offset( information->object_blocks[ block ], (information->allocation_size * information->size) ); information->name_table[ block ] = name_area; 2007af4: e0 20 80 13 st %l0, [ %g2 + %l3 ] /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007af8: d6 06 20 1c ld [ %i0 + 0x1c ], %o3 2007afc: d2 04 80 13 ld [ %l2 + %l3 ], %o1 2007b00: a8 07 bf ec add %fp, -20, %l4 index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007b04: 2b 00 00 40 sethi %hi(0x10000), %l5 /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 2007b08: 90 10 00 14 mov %l4, %o0 2007b0c: 40 00 16 c0 call 200d60c <_Chain_Initialize> 2007b10: a4 06 20 28 add %i0, 0x28, %l2 2007b14: 30 80 00 0f b,a 2007b50 <_Objects_Extend_information+0x214> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007b18: c4 16 20 04 lduh [ %i0 + 4 ], %g2 2007b1c: c6 16 20 44 lduh [ %i0 + 0x44 ], %g3 2007b20: 83 28 60 18 sll %g1, 0x18, %g1 2007b24: 85 28 a0 1b sll %g2, 0x1b, %g2 2007b28: 82 10 40 15 or %g1, %l5, %g1 2007b2c: 82 10 40 02 or %g1, %g2, %g1 2007b30: 82 10 40 11 or %g1, %l1, %g1 information->the_class, _Objects_Local_node, index ); the_object->name = (void *) name_area; 2007b34: e0 22 20 0c st %l0, [ %o0 + 0xc ] index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 2007b38: c2 22 20 08 st %g1, [ %o0 + 8 ] the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 2007b3c: 92 10 00 08 mov %o0, %o1 2007b40: a0 04 00 03 add %l0, %g3, %l0 index++; 2007b44: a2 04 60 01 inc %l1 the_object->name = (void *) name_area; name_area = _Addresses_Add_offset( name_area, information->name_length ); _Chain_Append( &information->Inactive, &the_object->Node ); 2007b48: 7f ff fc a0 call 2006dc8 <_Chain_Append> 2007b4c: 90 10 00 12 mov %l2, %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 ) { 2007b50: 7f ff fc aa call 2006df8 <_Chain_Get> 2007b54: 90 10 00 14 mov %l4, %o0 2007b58: 80 a2 20 00 cmp %o0, 0 2007b5c: 32 bf ff ef bne,a 2007b18 <_Objects_Extend_information+0x1dc> 2007b60: c2 06 00 00 ld [ %i0 ], %g1 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2007b64: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 2007b68: c4 06 20 18 ld [ %i0 + 0x18 ], %g2 information->inactive += information->allocation_size; 2007b6c: c8 16 20 34 lduh [ %i0 + 0x34 ], %g4 _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 2007b70: c4 20 c0 13 st %g2, [ %g3 + %l3 ] information->inactive += information->allocation_size; 2007b74: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2007b78: 82 00 40 04 add %g1, %g4, %g1 2007b7c: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 2007b80: 81 c7 e0 08 ret 2007b84: 81 e8 00 00 restore block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 2007b88: 90 10 00 12 mov %l2, %o0 2007b8c: 40 00 38 ea call 2015f34 <.udiv> 2007b90: 92 10 00 10 mov %l0, %o1 for ( ; block < block_count; block++ ) { 2007b94: 80 a2 20 00 cmp %o0, 0 2007b98: 02 80 00 46 be 2007cb0 <_Objects_Extend_information+0x374> 2007b9c: a8 10 00 11 mov %l1, %l4 if ( information->object_blocks[ block ] == NULL ) 2007ba0: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 2007ba4: c2 00 80 00 ld [ %g2 ], %g1 2007ba8: 80 a0 60 00 cmp %g1, 0 2007bac: 12 80 00 08 bne 2007bcc <_Objects_Extend_information+0x290> 2007bb0: ac 10 20 00 clr %l6 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007bb4: 10 80 00 0c b 2007be4 <_Objects_Extend_information+0x2a8> <== NOT EXECUTED 2007bb8: 80 a5 00 12 cmp %l4, %l2 <== NOT EXECUTED block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 2007bbc: c2 00 40 02 ld [ %g1 + %g2 ], %g1 2007bc0: 80 a0 60 00 cmp %g1, 0 2007bc4: 02 80 00 08 be 2007be4 <_Objects_Extend_information+0x2a8> 2007bc8: 80 a5 00 12 cmp %l4, %l2 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007bcc: ac 05 a0 01 inc %l6 if ( information->object_blocks[ block ] == NULL ) break; else index_base += information->allocation_size; 2007bd0: a8 05 00 10 add %l4, %l0, %l4 if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007bd4: 80 a5 80 08 cmp %l6, %o0 2007bd8: 12 bf ff f9 bne 2007bbc <_Objects_Extend_information+0x280> 2007bdc: 83 2d a0 02 sll %l6, 2, %g1 /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 2007be0: 80 a5 00 12 cmp %l4, %l2 2007be4: 2a bf ff a9 bcs,a 2007a88 <_Objects_Extend_information+0x14c> 2007be8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007bec: a6 02 20 01 add %o0, 1, %l3 2007bf0: 83 2c e0 01 sll %l3, 1, %g1 2007bf4: 90 00 40 13 add %g1, %l3, %o0 /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 2007bf8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 2007bfc: 80 a0 60 00 cmp %g1, 0 2007c00: 02 bf ff 60 be 2007980 <_Objects_Extend_information+0x44> 2007c04: ba 04 00 12 add %l0, %l2, %i5 2007c08: 92 02 00 11 add %o0, %l1, %o1 2007c0c: 11 00 80 66 sethi %hi(0x2019800), %o0 2007c10: 92 02 40 1d add %o1, %i5, %o1 2007c14: 90 12 20 8c or %o0, 0x8c, %o0 2007c18: 7f ff fd bd call 200730c <_Heap_Allocate> 2007c1c: 93 2a 60 02 sll %o1, 2, %o1 block_count * (sizeof(void *) + sizeof(uint32_t ) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 2007c20: ae 92 20 00 orcc %o0, 0, %l7 2007c24: 32 bf ff 5d bne,a 2007998 <_Objects_Extend_information+0x5c> 2007c28: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2007c2c: 81 c7 e0 08 ret <== NOT EXECUTED 2007c30: 81 e8 00 00 restore <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 2007c34: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 2007c38: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 2007c3c: 40 00 38 84 call 2015e4c <.umul> 2007c40: 90 00 40 08 add %g1, %o0, %o0 2007c44: 40 00 0b b6 call 200ab1c <_Workspace_Allocate_or_fatal_error> 2007c48: e0 06 20 3c ld [ %i0 + 0x3c ], %l0 2007c4c: e4 06 20 3c ld [ %i0 + 0x3c ], %l2 2007c50: a7 2d a0 02 sll %l6, 2, %l3 2007c54: 10 bf ff a0 b 2007ad4 <_Objects_Extend_information+0x198> 2007c58: d0 24 c0 10 st %o0, [ %l3 + %l0 ] /* * 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, 2007c5c: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 2007c60: a1 28 e0 02 sll %g3, 2, %l0 2007c64: 90 10 00 17 mov %l7, %o0 2007c68: 40 00 1e eb call 200f814 2007c6c: 94 10 00 10 mov %l0, %o2 information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 2007c70: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 2007c74: 94 10 00 10 mov %l0, %o2 2007c78: 40 00 1e e7 call 200f814 2007c7c: 90 10 00 13 mov %l3, %o0 information->inactive_per_block, block_count * sizeof(uint32_t ) ); memcpy( name_table, 2007c80: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 2007c84: 94 10 00 10 mov %l0, %o2 2007c88: 40 00 1e e3 call 200f814 2007c8c: 90 10 00 15 mov %l5, %o0 information->name_table, block_count * sizeof(Objects_Name *) ); memcpy( local_table, 2007c90: d4 16 20 10 lduh [ %i0 + 0x10 ], %o2 2007c94: d2 06 20 20 ld [ %i0 + 0x20 ], %o1 2007c98: 94 02 80 11 add %o2, %l1, %o2 2007c9c: 90 10 00 12 mov %l2, %o0 2007ca0: 40 00 1e dd call 200f814 2007ca4: 95 2a a0 02 sll %o2, 2, %o2 /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 2007ca8: 10 bf ff 4e b 20079e0 <_Objects_Extend_information+0xa4> 2007cac: c0 24 00 17 clr [ %l0 + %l7 ] if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 2007cb0: 10 bf ff cc b 2007be0 <_Objects_Extend_information+0x2a4> <== NOT EXECUTED 2007cb4: ac 10 20 00 clr %l6 <== NOT EXECUTED 2007cb8: 81 c7 e0 08 ret <== NOT EXECUTED 2007cbc: 81 e8 00 00 restore <== NOT EXECUTED 02009868 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 2009868: 9d e3 bf 88 save %sp, -120, %sp 200986c: 92 10 00 18 mov %i0, %o1 uint32_t i; char lname[5]; Objects_Control *the_object; Objects_Locations location; if ( length == 0 ) 2009870: 80 a6 60 00 cmp %i1, 0 2009874: 12 80 00 04 bne 2009884 <_Objects_Get_name_as_string+0x1c> 2009878: b0 10 00 1a mov %i2, %i0 _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 200987c: 81 c7 e0 08 ret <== NOT EXECUTED 2009880: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED Objects_Locations location; if ( length == 0 ) return NULL; if ( name == NULL ) 2009884: 80 a6 a0 00 cmp %i2, 0 2009888: 02 80 00 40 be 2009988 <_Objects_Get_name_as_string+0x120> 200988c: 87 32 60 16 srl %o1, 0x16, %g3 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 2009890: 03 00 80 99 sethi %hi(0x2026400), %g1 2009894: 86 08 e0 1c and %g3, 0x1c, %g3 2009898: 82 10 60 b0 or %g1, 0xb0, %g1 200989c: c8 00 40 03 ld [ %g1 + %g3 ], %g4 20098a0: 85 32 60 1b srl %o1, 0x1b, %g2 20098a4: 85 28 a0 02 sll %g2, 2, %g2 20098a8: f4 01 00 02 ld [ %g4 + %g2 ], %i2 return NULL; information = _Objects_Get_information( id ); if ( !information ) 20098ac: 80 a6 a0 00 cmp %i2, 0 20098b0: 22 80 00 36 be,a 2009988 <_Objects_Get_name_as_string+0x120> 20098b4: b0 10 20 00 clr %i0 <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, id, &location ); 20098b8: 90 10 00 1a mov %i2, %o0 20098bc: 40 00 00 3f call 20099b8 <_Objects_Get> 20098c0: 94 07 bf f4 add %fp, -12, %o2 switch ( location ) { 20098c4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20098c8: 80 a0 60 00 cmp %g1, 0 20098cc: 32 80 00 2f bne,a 2009988 <_Objects_Get_name_as_string+0x120> 20098d0: b0 10 20 00 clr %i0 <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 20098d4: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1 20098d8: 80 a0 60 00 cmp %g1, 0 20098dc: 22 80 00 2d be,a 2009990 <_Objects_Get_name_as_string+0x128> 20098e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 s = the_object->name; 20098e4: d0 02 20 0c ld [ %o0 + 0xc ], %o0 lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 20098e8: 80 a6 60 01 cmp %i1, 1 20098ec: 02 80 00 1c be 200995c <_Objects_Get_name_as_string+0xf4> 20098f0: 9a 10 00 18 mov %i0, %o5 20098f4: c8 0a 00 00 ldub [ %o0 ], %g4 20098f8: 85 29 20 18 sll %g4, 0x18, %g2 20098fc: 80 a0 a0 00 cmp %g2, 0 2009900: 22 80 00 18 be,a 2009960 <_Objects_Get_name_as_string+0xf8> 2009904: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED 2009908: b2 06 7f ff add %i1, -1, %i1 200990c: 98 10 20 00 clr %o4 2009910: 10 80 00 07 b 200992c <_Objects_Get_name_as_string+0xc4> 2009914: 17 00 80 77 sethi %hi(0x201dc00), %o3 2009918: c8 0a 00 00 ldub [ %o0 ], %g4 200991c: 85 29 20 18 sll %g4, 0x18, %g2 2009920: 80 a0 a0 00 cmp %g2, 0 2009924: 22 80 00 0f be,a 2009960 <_Objects_Get_name_as_string+0xf8> 2009928: c0 2b 40 00 clrb [ %o5 ] <== NOT EXECUTED *d = (!isprint(*s)) ? '*' : *s; 200992c: c2 02 e1 e8 ld [ %o3 + 0x1e8 ], %g1 2009930: 85 38 a0 18 sra %g2, 0x18, %g2 2009934: c6 48 80 01 ldsb [ %g2 + %g1 ], %g3 2009938: 80 88 e0 97 btst 0x97, %g3 200993c: 12 80 00 03 bne 2009948 <_Objects_Get_name_as_string+0xe0> 2009940: 90 02 20 01 inc %o0 2009944: 88 10 20 2a mov 0x2a, %g4 <== NOT EXECUTED 2009948: c8 2b 40 00 stb %g4, [ %o5 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; s = lname; } for ( i=0, d=name ; i<(length-1) && *s ; i++, s++, d++ ) { 200994c: 98 03 20 01 inc %o4 2009950: 80 a3 00 19 cmp %o4, %i1 2009954: 12 bf ff f1 bne 2009918 <_Objects_Get_name_as_string+0xb0> 2009958: 9a 03 60 01 inc %o5 *d = (!isprint(*s)) ? '*' : *s; } *d = '\0'; 200995c: c0 2b 40 00 clrb [ %o5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2009960: 03 00 80 99 sethi %hi(0x2026400), %g1 2009964: c4 00 61 50 ld [ %g1 + 0x150 ], %g2 ! 2026550 <_Thread_Dispatch_disable_level> 2009968: 84 00 bf ff add %g2, -1, %g2 200996c: c4 20 61 50 st %g2, [ %g1 + 0x150 ] 2009970: c6 00 61 50 ld [ %g1 + 0x150 ], %g3 2009974: 80 a0 e0 00 cmp %g3, 0 2009978: 12 80 00 04 bne 2009988 <_Objects_Get_name_as_string+0x120> 200997c: 01 00 00 00 nop _Thread_Dispatch(); 2009980: 40 00 05 06 call 200ad98 <_Thread_Dispatch> 2009984: 01 00 00 00 nop 2009988: 81 c7 e0 08 ret 200998c: 81 e8 00 00 restore lname[ 0 ] = (u32_name >> 24) & 0xff; lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 2009990: c0 2f bf f3 clrb [ %fp + -13 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 2009994: 85 30 60 18 srl %g1, 0x18, %g2 lname[ 1 ] = (u32_name >> 16) & 0xff; 2009998: 87 30 60 10 srl %g1, 0x10, %g3 lname[ 2 ] = (u32_name >> 8) & 0xff; lname[ 3 ] = (u32_name >> 0) & 0xff; 200999c: c2 2f bf f2 stb %g1, [ %fp + -14 ] if ( information->is_string ) { s = the_object->name; } else { uint32_t u32_name = (uint32_t) the_object->name; lname[ 0 ] = (u32_name >> 24) & 0xff; 20099a0: c4 2f bf ef stb %g2, [ %fp + -17 ] lname[ 1 ] = (u32_name >> 16) & 0xff; lname[ 2 ] = (u32_name >> 8) & 0xff; 20099a4: 83 30 60 08 srl %g1, 8, %g1 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; 20099a8: c6 2f bf f0 stb %g3, [ %fp + -16 ] lname[ 2 ] = (u32_name >> 8) & 0xff; 20099ac: c2 2f bf f1 stb %g1, [ %fp + -15 ] lname[ 3 ] = (u32_name >> 0) & 0xff; lname[ 4 ] = '\0'; 20099b0: 10 bf ff ce b 20098e8 <_Objects_Get_name_as_string+0x80> 20099b4: 90 07 bf ef add %fp, -17, %o0 0201a258 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 201a258: 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) 201a25c: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 201a260: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 201a264: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED 201a268: 22 80 00 02 be,a 201a270 <_Objects_Get_next+0x18> <== NOT EXECUTED 201a26c: 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) 201a270: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 201a274: a0 10 63 ff or %g1, 0x3ff, %l0 ! ffff <== NOT EXECUTED 201a278: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED 201a27c: 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); 201a280: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 201a284: 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) 201a288: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 201a28c: 18 80 00 0b bgu 201a2b8 <_Objects_Get_next+0x60> <== NOT EXECUTED 201a290: 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); 201a294: 7f ff d3 63 call 200f020 <_Objects_Get> <== NOT EXECUTED 201a298: b2 06 60 01 inc %i1 <== NOT EXECUTED next_id++; } while (*location_p != OBJECTS_LOCAL); 201a29c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 201a2a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201a2a4: 32 bf ff f6 bne,a 201a27c <_Objects_Get_next+0x24> <== NOT EXECUTED 201a2a8: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 <== NOT EXECUTED *next_id_p = next_id; 201a2ac: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 201a2b0: 81 c7 e0 08 ret <== NOT EXECUTED 201a2b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 201a2b8: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 201a2bc: 84 10 3f ff mov -1, %g2 <== NOT EXECUTED 201a2c0: 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; 201a2c4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 201a2c8: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED return 0; } 201a2cc: 81 c7 e0 08 ret <== NOT EXECUTED 201a2d0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 020155c4 <_Objects_Get_no_protection>: ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 20155c4: c2 02 20 08 ld [ %o0 + 8 ], %g1 if ( information->maximum >= index ) { 20155c8: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 ) { Objects_Control *the_object; uint32_t index; index = id - information->minimum_id + 1; 20155cc: 92 22 40 01 sub %o1, %g1, %o1 20155d0: 82 02 60 01 add %o1, 1, %g1 if ( information->maximum >= index ) { 20155d4: 80 a0 40 02 cmp %g1, %g2 20155d8: 18 80 00 09 bgu 20155fc <_Objects_Get_no_protection+0x38> 20155dc: 83 28 60 02 sll %g1, 2, %g1 if ( (the_object = information->local_table[ index ]) != NULL ) { 20155e0: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20155e4: d0 00 80 01 ld [ %g2 + %g1 ], %o0 20155e8: 80 a2 20 00 cmp %o0, 0 20155ec: 02 80 00 08 be 201560c <_Objects_Get_no_protection+0x48> 20155f0: 82 10 20 02 mov 2, %g1 *location = OBJECTS_LOCAL; 20155f4: 81 c3 e0 08 retl 20155f8: c0 22 80 00 clr [ %o2 ] return the_object; } *location = OBJECTS_ERROR; return NULL; } *location = OBJECTS_ERROR; 20155fc: 82 10 20 02 mov 2, %g1 2015600: 90 10 20 00 clr %o0 /* * Not supported for multiprocessing */ return NULL; } 2015604: 81 c3 e0 08 retl 2015608: c2 22 80 00 st %g1, [ %o2 ] if ( information->maximum >= index ) { if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; return the_object; } *location = OBJECTS_ERROR; 201560c: 81 c3 e0 08 retl <== NOT EXECUTED 2015610: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED 02008030 <_Objects_Handler_initialization>: uint32_t node, uint32_t maximum_nodes, uint32_t maximum_global_objects ) { if ( node < 1 || node > maximum_nodes ) 2008030: 80 a2 20 00 cmp %o0, 0 2008034: 22 80 00 07 be,a 2008050 <_Objects_Handler_initialization+0x20> 2008038: 90 10 20 00 clr %o0 <== NOT EXECUTED 200803c: 80 a2 00 09 cmp %o0, %o1 2008040: 18 80 00 04 bgu 2008050 <_Objects_Handler_initialization+0x20> 2008044: 90 10 20 00 clr %o0 2008048: 81 c3 e0 08 retl 200804c: 01 00 00 00 nop _Internal_error_Occurred( 2008050: 92 10 20 01 mov 1, %o1 ! 1 <== NOT EXECUTED 2008054: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED 2008058: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200805c: 7f ff fd de call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2008060: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2008064: 01 00 00 00 nop 02009364 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 2009364: 9d e3 bf 90 save %sp, -112, %sp 2009368: 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 ) 200936c: 80 a6 60 00 cmp %i1, 0 2009370: 02 80 00 24 be 2009400 <_Objects_Id_to_name+0x9c> 2009374: 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); 2009378: 83 32 60 18 srl %o1, 0x18, %g1 200937c: 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 ) 2009380: 80 a0 60 04 cmp %g1, 4 2009384: 18 80 00 25 bgu 2009418 <_Objects_Id_to_name+0xb4> 2009388: 87 28 60 02 sll %g1, 2, %g3 return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( id ); information = _Objects_Information_table[ the_api ][ the_class ]; 200938c: 03 00 80 78 sethi %hi(0x201e000), %g1 2009390: 82 10 62 20 or %g1, 0x220, %g1 ! 201e220 <_Objects_Information_table> 2009394: c8 00 40 03 ld [ %g1 + %g3 ], %g4 2009398: 85 32 60 1b srl %o1, 0x1b, %g2 200939c: 85 28 a0 02 sll %g2, 2, %g2 20093a0: d0 01 00 02 ld [ %g4 + %g2 ], %o0 if ( !information ) 20093a4: 80 a2 20 00 cmp %o0, 0 20093a8: 02 80 00 1c be 2009418 <_Objects_Id_to_name+0xb4> 20093ac: 01 00 00 00 nop return OBJECTS_INVALID_ID; if ( information->is_string ) 20093b0: c2 02 20 40 ld [ %o0 + 0x40 ], %g1 20093b4: 80 a0 60 00 cmp %g1, 0 20093b8: 12 80 00 18 bne 2009418 <_Objects_Id_to_name+0xb4> 20093bc: 01 00 00 00 nop return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, id, &ignored_location ); 20093c0: 7f ff ff c2 call 20092c8 <_Objects_Get> 20093c4: 94 07 bf f4 add %fp, -12, %o2 if ( !the_object ) 20093c8: 80 a2 20 00 cmp %o0, 0 20093cc: 02 80 00 13 be 2009418 <_Objects_Id_to_name+0xb4> 20093d0: 01 00 00 00 nop return OBJECTS_INVALID_ID; *name = the_object->name; 20093d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 20093d8: 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 ) 20093dc: 07 00 80 78 sethi %hi(0x201e000), %g3 20093e0: c2 00 e2 c0 ld [ %g3 + 0x2c0 ], %g1 ! 201e2c0 <_Thread_Dispatch_disable_level> 20093e4: b0 10 20 00 clr %i0 20093e8: 82 00 7f ff add %g1, -1, %g1 20093ec: c2 20 e2 c0 st %g1, [ %g3 + 0x2c0 ] 20093f0: c4 00 e2 c0 ld [ %g3 + 0x2c0 ], %g2 20093f4: 80 a0 a0 00 cmp %g2, 0 20093f8: 02 80 00 04 be 2009408 <_Objects_Id_to_name+0xa4> 20093fc: 01 00 00 00 nop _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 2009400: 81 c7 e0 08 ret <== NOT EXECUTED 2009404: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2009408: 40 00 05 13 call 200a854 <_Thread_Dispatch> 200940c: 01 00 00 00 nop 2009410: 81 c7 e0 08 ret 2009414: 81 e8 00 00 restore 2009418: 81 c7 e0 08 ret <== NOT EXECUTED 200941c: 91 e8 20 03 restore %g0, 3, %o0 <== NOT EXECUTED 02007f40 <_Objects_Name_to_id>: Objects_Information *information, Objects_Name name, uint32_t node, Objects_Id *id ) { 2007f40: 9d e3 bf 98 save %sp, -104, %sp 2007f44: 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 ) 2007f48: 80 a6 e0 00 cmp %i3, 0 2007f4c: 02 80 00 2d be 2008000 <_Objects_Name_to_id+0xc0> 2007f50: b0 10 20 02 mov 2, %i0 return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 2007f54: 80 a6 60 00 cmp %i1, 0 2007f58: 02 80 00 28 be 2007ff8 <_Objects_Name_to_id+0xb8> 2007f5c: 01 00 00 00 nop return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007f60: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 2007f64: 86 90 60 00 orcc %g1, 0, %g3 2007f68: 02 80 00 24 be 2007ff8 <_Objects_Name_to_id+0xb8> 2007f6c: 80 a6 a0 00 cmp %i2, 0 2007f70: 12 80 00 26 bne 2008008 <_Objects_Name_to_id+0xc8> 2007f74: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; if ( information->is_string ) compare_them = _Objects_Compare_name_string; 2007f78: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2007f7c: 05 00 80 36 sethi %hi(0x200d800), %g2 2007f80: 80 a0 60 00 cmp %g1, 0 2007f84: a4 10 a2 60 or %g2, 0x260, %l2 2007f88: 02 80 00 04 be 2007f98 <_Objects_Name_to_id+0x58> 2007f8c: c8 14 60 44 lduh [ %l1 + 0x44 ], %g4 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007f90: 03 00 80 36 sethi %hi(0x200d800), %g1 2007f94: a4 10 62 70 or %g1, 0x270, %l2 ! 200da70 <_Objects_Compare_name_string> 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 ) ) { 2007f98: 83 29 20 10 sll %g4, 0x10, %g1 if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2007f9c: 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 ) ) { 2007fa0: 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 ]; 2007fa4: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2007fa8: 83 2c 20 02 sll %l0, 2, %g1 2007fac: f4 00 80 01 ld [ %g2 + %g1 ], %i2 if ( !the_object || !the_object->name ) 2007fb0: 80 a6 a0 00 cmp %i2, 0 2007fb4: 02 80 00 0c be 2007fe4 <_Objects_Name_to_id+0xa4> 2007fb8: a0 04 20 01 inc %l0 2007fbc: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 2007fc0: 80 a2 60 00 cmp %o1, 0 2007fc4: 02 80 00 08 be 2007fe4 <_Objects_Name_to_id+0xa4> 2007fc8: 90 10 00 19 mov %i1, %o0 continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { 2007fcc: 9f c4 80 00 call %l2 2007fd0: 94 10 00 18 mov %i0, %o2 2007fd4: 80 a2 20 00 cmp %o0, 0 2007fd8: 32 80 00 13 bne,a 2008024 <_Objects_Name_to_id+0xe4> 2007fdc: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2007fe0: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 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++ ) { 2007fe4: 83 28 e0 10 sll %g3, 0x10, %g1 2007fe8: 83 30 60 10 srl %g1, 0x10, %g1 2007fec: 80 a0 40 10 cmp %g1, %l0 2007ff0: 3a bf ff ee bcc,a 2007fa8 <_Objects_Name_to_id+0x68> 2007ff4: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2007ff8: 81 c7 e0 08 ret 2007ffc: 91 e8 20 01 restore %g0, 1, %o0 return ( _Objects_MP_Global_name_search( information, name, node, id ) ); #else return OBJECTS_INVALID_NAME; #endif } 2008000: 81 c7 e0 08 ret <== NOT EXECUTED 2008004: 81 e8 00 00 restore <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 2008008: 82 10 63 ff or %g1, 0x3ff, %g1 200800c: 80 a6 80 01 cmp %i2, %g1 2008010: 02 bf ff da be 2007f78 <_Objects_Name_to_id+0x38> 2008014: 80 a6 a0 01 cmp %i2, 1 2008018: 22 bf ff d9 be,a 2007f7c <_Objects_Name_to_id+0x3c> 200801c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2008020: 30 bf ff f6 b,a 2007ff8 <_Objects_Name_to_id+0xb8> the_object = information->local_table[ index ]; if ( !the_object || !the_object->name ) continue; if ( (*compare_them)( name, the_object->name, name_length ) ) { *id = the_object->id; 2008024: c2 26 c0 00 st %g1, [ %i3 ] 2008028: 81 c7 e0 08 ret 200802c: 91 e8 20 00 restore %g0, 0, %o0 02008068 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 2008068: 9d e3 bf 98 save %sp, -104, %sp 200806c: 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; 2008070: e0 06 20 18 ld [ %i0 + 0x18 ], %l0 2008074: d0 16 20 10 lduh [ %i0 + 0x10 ], %o0 2008078: 03 00 00 3f sethi %hi(0xfc00), %g1 200807c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2008080: 92 10 00 10 mov %l0, %o1 2008084: a2 08 80 01 and %g2, %g1, %l1 2008088: 40 00 37 ab call 2015f34 <.udiv> 200808c: 90 22 00 11 sub %o0, %l1, %o0 for ( block = 0; block < block_count; block++ ) { 2008090: 80 a2 20 00 cmp %o0, 0 2008094: 02 80 00 15 be 20080e8 <_Objects_Shrink_information+0x80> 2008098: 86 10 20 00 clr %g3 if ( information->inactive_per_block[ block ] == information->allocation_size ) { 200809c: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 20080a0: c2 01 00 00 ld [ %g4 ], %g1 20080a4: 84 10 20 04 mov 4, %g2 20080a8: 80 a4 00 01 cmp %l0, %g1 20080ac: a8 10 20 00 clr %l4 20080b0: 12 80 00 0a bne 20080d8 <_Objects_Shrink_information+0x70> 20080b4: a4 10 20 00 clr %l2 /* * 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; 20080b8: 10 80 00 10 b 20080f8 <_Objects_Shrink_information+0x90> <== NOT EXECUTED 20080bc: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 <== NOT EXECUTED information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 20080c0: 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++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 20080c4: 80 a4 00 01 cmp %l0, %g1 information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 20080c8: a4 10 00 02 mov %g2, %l2 index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == information->allocation_size ) { 20080cc: 02 80 00 09 be 20080f0 <_Objects_Shrink_information+0x88> 20080d0: 82 00 a0 04 add %g2, 4, %g1 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 20080d4: 84 10 00 01 mov %g1, %g2 */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 20080d8: 86 00 e0 01 inc %g3 20080dc: 80 a0 c0 08 cmp %g3, %o0 20080e0: 32 bf ff f8 bne,a 20080c0 <_Objects_Shrink_information+0x58> 20080e4: c2 00 80 04 ld [ %g2 + %g4 ], %g1 20080e8: 81 c7 e0 08 ret 20080ec: 81 e8 00 00 restore if ( information->inactive_per_block[ block ] == information->allocation_size ) { 20080f0: a8 10 00 02 mov %g2, %l4 /* * 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; 20080f4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0 20080f8: 03 00 00 3f sethi %hi(0xfc00), %g1 20080fc: e0 02 00 00 ld [ %o0 ], %l0 2008100: 10 80 00 10 b 2008140 <_Objects_Shrink_information+0xd8> 2008104: a6 10 63 ff or %g1, 0x3ff, %l3 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2008108: 82 04 40 01 add %l1, %g1, %g1 200810c: 80 a0 80 01 cmp %g2, %g1 2008110: 3a 80 00 12 bcc,a 2008158 <_Objects_Shrink_information+0xf0> 2008114: 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 ); 2008118: 40 00 15 33 call 200d5e4 <_Chain_Extract> 200811c: 01 00 00 00 nop 2008120: 90 10 00 10 mov %l0, %o0 } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2008124: 80 a2 20 00 cmp %o0, 0 2008128: 22 80 00 10 be,a 2008168 <_Objects_Shrink_information+0x100> 200812c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_last( const Chain_Node *the_node ) { return (the_node->next == NULL); 2008130: e0 02 00 00 ld [ %o0 ], %l0 2008134: 80 a4 20 00 cmp %l0, 0 2008138: 22 80 00 0c be,a 2008168 <_Objects_Shrink_information+0x100> 200813c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 2008140: c2 02 20 08 ld [ %o0 + 8 ], %g1 2008144: 84 08 40 13 and %g1, %l3, %g2 */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 2008148: 80 a4 40 02 cmp %l1, %g2 200814c: 28 bf ff ef bleu,a 2008108 <_Objects_Shrink_information+0xa0> 2008150: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 2008154: 90 10 00 10 mov %l0, %o0 } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 2008158: 80 a2 20 00 cmp %o0, 0 200815c: 32 bf ff f6 bne,a 2008134 <_Objects_Shrink_information+0xcc> 2008160: e0 02 00 00 ld [ %o0 ], %l0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2008164: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2008168: 11 00 80 66 sethi %hi(0x2019800), %o0 200816c: d2 00 40 14 ld [ %g1 + %l4 ], %o1 2008170: 7f ff fc 99 call 20073d4 <_Heap_Free> 2008174: 90 12 20 8c or %o0, 0x8c, %o0 */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2008178: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 200817c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; 2008180: c0 24 80 02 clr [ %l2 + %g2 ] information->inactive -= information->allocation_size; 2008184: c2 16 20 34 lduh [ %i0 + 0x34 ], %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; 2008188: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 200818c: c6 06 20 18 ld [ %i0 + 0x18 ], %g3 /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); information->name_table[ block ] = NULL; 2008190: c0 25 00 04 clr [ %l4 + %g4 ] information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 2008194: 82 20 40 03 sub %g1, %g3, %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; 2008198: c0 25 00 02 clr [ %l4 + %g2 ] information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; 200819c: c2 36 20 34 sth %g1, [ %i0 + 0x34 ] 20081a0: 81 c7 e0 08 ret 20081a4: 81 e8 00 00 restore 02006b94 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 2006b94: 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; 2006b98: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 if ( !api_configuration ) 2006b9c: 80 a6 20 00 cmp %i0, 0 2006ba0: 02 80 00 1f be 2006c1c <_POSIX_API_Initialize+0x88> 2006ba4: 03 00 80 65 sethi %hi(0x2019400), %g1 api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_signals_Manager_Initialization( 2006ba8: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 2006bac: 05 00 80 65 sethi %hi(0x2019400), %g2 2006bb0: 03 00 80 67 sethi %hi(0x2019c00), %g1 2006bb4: 82 10 61 d8 or %g1, 0x1d8, %g1 ! 2019dd8 <_POSIX_Objects> _POSIX_signals_Manager_Initialization( 2006bb8: 40 00 17 e7 call 200cb54 <_POSIX_signals_Manager_Initialization> 2006bbc: c2 20 a3 ac st %g1, [ %g2 + 0x3ac ] api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 2006bc0: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 2006bc4: d4 06 20 30 ld [ %i0 + 0x30 ], %o2 2006bc8: 40 00 18 58 call 200cd28 <_POSIX_Threads_Manager_initialization> 2006bcc: 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( 2006bd0: 40 00 17 8f call 200ca0c <_POSIX_Condition_variables_Manager_initialization> 2006bd4: d0 06 20 08 ld [ %i0 + 8 ], %o0 api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 2006bd8: 40 00 17 99 call 200ca3c <_POSIX_Key_Manager_initialization> 2006bdc: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _POSIX_Mutex_Manager_initialization( 2006be0: 40 00 17 b9 call 200cac4 <_POSIX_Mutex_Manager_initialization> 2006be4: d0 06 20 04 ld [ %i0 + 4 ], %o0 api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 2006be8: 40 00 17 a1 call 200ca6c <_POSIX_Message_queue_Manager_initialization> 2006bec: d0 06 20 18 ld [ %i0 + 0x18 ], %o0 api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 2006bf0: 40 00 19 23 call 200d07c <_POSIX_Semaphore_Manager_initialization> 2006bf4: d0 06 20 1c ld [ %i0 + 0x1c ], %o0 api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 2006bf8: 40 00 19 14 call 200d048 <_POSIX_Timer_Manager_initialization> 2006bfc: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 2006c00: 40 00 17 bd call 200caf4 <_POSIX_Barrier_Manager_initialization> 2006c04: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 2006c08: 40 00 17 c7 call 200cb24 <_POSIX_RWLock_Manager_initialization> 2006c0c: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 2006c10: f0 06 20 28 ld [ %i0 + 0x28 ], %i0 2006c14: 40 00 18 2f call 200ccd0 <_POSIX_Spinlock_Manager_initialization> 2006c18: 81 e8 00 00 restore /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; if ( !api_configuration ) 2006c1c: 10 bf ff e3 b 2006ba8 <_POSIX_API_Initialize+0x14> <== NOT EXECUTED 2006c20: b0 10 60 2c or %g1, 0x2c, %i0 <== NOT EXECUTED 0200e1ac <_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 ) 200e1ac: 80 a2 20 03 cmp %o0, 3 200e1b0: 18 80 00 06 bgu 200e1c8 <_POSIX_Barrier_Translate_core_barrier_return_code+0x1c> 200e1b4: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); } 200e1b8: 03 00 80 65 sethi %hi(0x2019400), %g1 200e1bc: 82 10 60 b8 or %g1, 0xb8, %g1 ! 20194b8 <_POSIX_Barrier_Return_codes> 200e1c0: 81 c3 e0 08 retl 200e1c4: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_barrier_Status the_barrier_status ) { if ( the_barrier_status <= CORE_BARRIER_TIMEOUT ) return _POSIX_Barrier_Return_codes[the_barrier_status]; return POSIX_BOTTOM_REACHED(); 200e1c8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200e1cc: 7f ff e1 21 call 2006650 <== NOT EXECUTED 200e1d0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 200e1d4: 01 00 00 00 nop 020068cc <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, boolean is_broadcast ) { 20068cc: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 20068d0: 80 a6 20 00 cmp %i0, 0 20068d4: 32 80 00 05 bne,a 20068e8 <_POSIX_Condition_variables_Signal_support+0x1c> 20068d8: d2 06 00 00 ld [ %i0 ], %o1 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20068dc: 90 10 20 16 mov 0x16, %o0 } 20068e0: 81 c7 e0 08 ret 20068e4: 91 e8 00 08 restore %g0, %o0, %o0 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 20068e8: 80 a2 7f ff cmp %o1, -1 20068ec: 22 80 00 27 be,a 2006988 <_POSIX_Condition_variables_Signal_support+0xbc> 20068f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 20068f4: 11 00 80 66 sethi %hi(0x2019800), %o0 20068f8: 94 07 bf f4 add %fp, -12, %o2 20068fc: 40 00 0f 67 call 200a698 <_Objects_Get> 2006900: 90 12 23 3c or %o0, 0x33c, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 2006904: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006908: a0 10 00 08 mov %o0, %l0 200690c: 80 a0 60 00 cmp %g1, 0 2006910: 02 80 00 08 be 2006930 <_POSIX_Condition_variables_Signal_support+0x64> 2006914: b0 02 20 18 add %o0, 0x18, %i0 2006918: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200691c: 28 bf ff f1 bleu,a 20068e0 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED 2006920: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006924: 40 00 04 b6 call 2007bfc <== NOT EXECUTED 2006928: 01 00 00 00 nop <== NOT EXECUTED 200692c: 30 bf ff ed b,a 20068e0 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 2006930: 40 00 15 7d call 200bf24 <_Thread_queue_Dequeue> 2006934: 90 10 00 18 mov %i0, %o0 if ( !the_thread ) 2006938: 80 a2 20 00 cmp %o0, 0 200693c: 02 80 00 11 be 2006980 <_POSIX_Condition_variables_Signal_support+0xb4> 2006940: 80 a6 60 00 cmp %i1, 0 the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 2006944: 12 bf ff fb bne 2006930 <_POSIX_Condition_variables_Signal_support+0x64> 2006948: 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 ) 200694c: 03 00 80 65 sethi %hi(0x2019400), %g1 2006950: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20195f0 <_Thread_Dispatch_disable_level> 2006954: 90 10 20 00 clr %o0 2006958: 84 00 bf ff add %g2, -1, %g2 200695c: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 2006960: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 2006964: 80 a0 e0 00 cmp %g3, 0 2006968: 12 bf ff de bne 20068e0 <_POSIX_Condition_variables_Signal_support+0x14> 200696c: 01 00 00 00 nop _Thread_Dispatch(); 2006970: 40 00 14 42 call 200ba78 <_Thread_Dispatch> 2006974: 01 00 00 00 nop 2006978: 10 bf ff da b 20068e0 <_POSIX_Condition_variables_Signal_support+0x14> 200697c: 90 10 20 00 clr %o0 ! 0 case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 2006980: 10 bf ff f3 b 200694c <_POSIX_Condition_variables_Signal_support+0x80> 2006984: c0 24 20 14 clr [ %l0 + 0x14 ] if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 2006988: 7f ff ff 83 call 2006794 <== NOT EXECUTED 200698c: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 2006990: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006994: 32 bf ff d3 bne,a 20068e0 <_POSIX_Condition_variables_Signal_support+0x14> <== NOT EXECUTED 2006998: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 200699c: 10 bf ff d6 b 20068f4 <_POSIX_Condition_variables_Signal_support+0x28> <== NOT EXECUTED 20069a0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 02006a1c <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, boolean already_timedout ) { 2006a1c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2006a20: 80 a6 60 00 cmp %i1, 0 2006a24: 32 80 00 04 bne,a 2006a34 <_POSIX_Condition_variables_Wait_support+0x18> 2006a28: d2 06 40 00 ld [ %i1 ], %o1 return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 2006a2c: 81 c7 e0 08 ret 2006a30: 91 e8 20 16 restore %g0, 0x16, %o0 2006a34: 80 a2 7f ff cmp %o1, -1 2006a38: 22 80 00 37 be,a 2006b14 <_POSIX_Condition_variables_Wait_support+0xf8> 2006a3c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2006a40: a2 07 bf f4 add %fp, -12, %l1 2006a44: 11 00 80 66 sethi %hi(0x2019800), %o0 2006a48: 94 10 00 11 mov %l1, %o2 2006a4c: 40 00 0f 13 call 200a698 <_Objects_Get> 2006a50: 90 12 22 54 or %o0, 0x254, %o0 register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 2006a54: 80 a2 20 00 cmp %o0, 0 2006a58: 02 bf ff f5 be 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> 2006a5c: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 2006a60: 21 00 80 65 sethi %hi(0x2019400), %l0 2006a64: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 ! 20195f0 <_Thread_Dispatch_disable_level> ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 2006a68: 80 a6 20 00 cmp %i0, 0 2006a6c: 82 00 7f ff add %g1, -1, %g1 2006a70: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] 2006a74: 02 bf ff ee be 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> 2006a78: 01 00 00 00 nop *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 2006a7c: d2 06 00 00 ld [ %i0 ], %o1 2006a80: 80 a2 7f ff cmp %o1, -1 2006a84: 22 80 00 42 be,a 2006b8c <_POSIX_Condition_variables_Wait_support+0x170> 2006a88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 2006a8c: 94 10 00 11 mov %l1, %o2 2006a90: 11 00 80 66 sethi %hi(0x2019800), %o0 2006a94: 40 00 0f 01 call 200a698 <_Objects_Get> 2006a98: 90 12 23 3c or %o0, 0x33c, %o0 ! 2019b3c <_POSIX_Condition_variables_Information> } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 2006a9c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006aa0: 80 a0 60 00 cmp %g1, 0 2006aa4: 12 80 00 15 bne 2006af8 <_POSIX_Condition_variables_Wait_support+0xdc> 2006aa8: a2 10 00 08 mov %o0, %l1 #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 2006aac: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 2006ab0: 80 a0 a0 00 cmp %g2, 0 2006ab4: 02 80 00 1f be 2006b30 <_POSIX_Condition_variables_Wait_support+0x114> 2006ab8: 01 00 00 00 nop 2006abc: c2 06 40 00 ld [ %i1 ], %g1 2006ac0: 80 a0 80 01 cmp %g2, %g1 2006ac4: 02 80 00 1b be 2006b30 <_POSIX_Condition_variables_Wait_support+0x114> 2006ac8: 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 ) 2006acc: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 <== NOT EXECUTED 2006ad0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2006ad4: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] <== NOT EXECUTED 2006ad8: c4 04 21 f0 ld [ %l0 + 0x1f0 ], %g2 <== NOT EXECUTED 2006adc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2006ae0: 12 bf ff d3 bne 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 2006ae4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2006ae8: 40 00 13 e4 call 200ba78 <_Thread_Dispatch> <== NOT EXECUTED 2006aec: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 2006af0: 81 c7 e0 08 ret <== NOT EXECUTED 2006af4: 81 e8 00 00 restore <== NOT EXECUTED } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 2006af8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006afc: 08 bf ff cc bleu 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 2006b00: 01 00 00 00 nop <== NOT EXECUTED if ( mutex_status ) return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); 2006b04: 40 00 04 3e call 2007bfc <== NOT EXECUTED 2006b08: 01 00 00 00 nop <== NOT EXECUTED 2006b0c: 81 c7 e0 08 ret <== NOT EXECUTED 2006b10: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2006b14: 40 00 00 94 call 2006d64 <== NOT EXECUTED 2006b18: 92 10 20 00 clr %o1 <== NOT EXECUTED 2006b1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006b20: 12 bf ff c3 bne 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 2006b24: 01 00 00 00 nop <== NOT EXECUTED 2006b28: 10 bf ff c6 b 2006a40 <_POSIX_Condition_variables_Wait_support+0x24> <== NOT EXECUTED 2006b2c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 2006b30: 40 00 01 a2 call 20071b8 2006b34: 90 10 00 19 mov %i1, %o0 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 2006b38: 80 a6 e0 00 cmp %i3, 0 2006b3c: 22 80 00 1b be,a 2006ba8 <_POSIX_Condition_variables_Wait_support+0x18c> 2006b40: c2 06 40 00 ld [ %i1 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006b44: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 2006b48: b0 10 20 74 mov 0x74, %i0 2006b4c: 82 00 7f ff add %g1, -1, %g1 2006b50: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] 2006b54: c4 04 21 f0 ld [ %l0 + 0x1f0 ], %g2 2006b58: 80 a0 a0 00 cmp %g2, 0 2006b5c: 02 80 00 09 be 2006b80 <_POSIX_Condition_variables_Wait_support+0x164> 2006b60: 01 00 00 00 nop /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 2006b64: 40 00 00 e8 call 2006f04 2006b68: 90 10 00 19 mov %i1, %o0 if ( mutex_status ) 2006b6c: 80 a2 20 00 cmp %o0, 0 2006b70: 12 bf ff af bne 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> 2006b74: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 2006b78: 81 c7 e0 08 ret 2006b7c: 81 e8 00 00 restore _Thread_Dispatch(); 2006b80: 40 00 13 be call 200ba78 <_Thread_Dispatch> 2006b84: 01 00 00 00 nop 2006b88: 30 bf ff f7 b,a 2006b64 <_POSIX_Condition_variables_Wait_support+0x148> if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 2006b8c: 7f ff ff 02 call 2006794 <== NOT EXECUTED 2006b90: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 2006b94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006b98: 12 bf ff a5 bne 2006a2c <_POSIX_Condition_variables_Wait_support+0x10> <== NOT EXECUTED 2006b9c: 01 00 00 00 nop <== NOT EXECUTED 2006ba0: 10 bf ff bb b 2006a8c <_POSIX_Condition_variables_Wait_support+0x70> <== NOT EXECUTED 2006ba4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006ba8: 37 00 80 65 sethi %hi(0x2019400), %i3 return EINVAL; } */ if ( !already_timedout ) { the_cond->Mutex = *mutex; 2006bac: c2 24 60 14 st %g1, [ %l1 + 0x14 ] _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006bb0: c2 06 e2 d0 ld [ %i3 + 0x2d0 ], %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; 2006bb4: c4 06 00 00 ld [ %i0 ], %g2 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; 2006bb8: 90 04 60 18 add %l1, 0x18, %o0 _Thread_Executing->Wait.id = *cond; 2006bbc: c4 20 60 20 st %g2, [ %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; 2006bc0: d0 20 60 44 st %o0, [ %g1 + 0x44 ] if ( !already_timedout ) { the_cond->Mutex = *mutex; _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 2006bc4: c0 20 60 34 clr [ %g1 + 0x34 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2006bc8: 82 10 20 01 mov 1, %g1 _Thread_Executing->Wait.queue = &the_cond->Wait_queue; _Thread_Executing->Wait.id = *cond; _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 2006bcc: 92 10 00 1a mov %i2, %o1 2006bd0: c2 24 60 48 st %g1, [ %l1 + 0x48 ] 2006bd4: 15 00 80 31 sethi %hi(0x200c400), %o2 2006bd8: 40 00 15 41 call 200c0dc <_Thread_queue_Enqueue_with_handler> 2006bdc: 94 12 a2 a4 or %o2, 0x2a4, %o2 ! 200c6a4 <_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 ) 2006be0: c2 04 21 f0 ld [ %l0 + 0x1f0 ], %g1 2006be4: 82 00 7f ff add %g1, -1, %g1 2006be8: c2 24 21 f0 st %g1, [ %l0 + 0x1f0 ] 2006bec: c4 04 21 f0 ld [ %l0 + 0x1f0 ], %g2 2006bf0: 80 a0 a0 00 cmp %g2, 0 2006bf4: 12 80 00 05 bne 2006c08 <_POSIX_Condition_variables_Wait_support+0x1ec> 2006bf8: c2 06 e2 d0 ld [ %i3 + 0x2d0 ], %g1 _Thread_Dispatch(); 2006bfc: 40 00 13 9f call 200ba78 <_Thread_Dispatch> 2006c00: 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; 2006c04: c2 06 e2 d0 ld [ %i3 + 0x2d0 ], %g1 2006c08: f0 00 60 34 ld [ %g1 + 0x34 ], %i0 if ( status && status != ETIMEDOUT ) 2006c0c: 80 a6 20 00 cmp %i0, 0 2006c10: 02 bf ff d5 be 2006b64 <_POSIX_Condition_variables_Wait_support+0x148> 2006c14: 80 a6 20 74 cmp %i0, 0x74 2006c18: 02 bf ff d3 be 2006b64 <_POSIX_Condition_variables_Wait_support+0x148> 2006c1c: 01 00 00 00 nop return EINVAL; return status; } return POSIX_BOTTOM_REACHED(); } 2006c20: 81 c7 e0 08 ret <== NOT EXECUTED 2006c24: 81 e8 00 00 restore <== NOT EXECUTED 0200e604 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 200e604: 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 ); 200e608: 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 ]; 200e60c: 05 00 00 3f sethi %hi(0xfc00), %g2 200e610: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e614: 84 08 40 02 and %g1, %g2, %g2 200e618: aa 10 20 00 clr %l5 200e61c: a9 28 a0 02 sll %g2, 2, %l4 */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 200e620: 83 30 60 16 srl %g1, 0x16, %g1 200e624: 05 00 80 67 sethi %hi(0x2019c00), %g2 200e628: a6 08 60 1c and %g1, 0x1c, %l3 200e62c: a2 10 a1 40 or %g2, 0x140, %l1 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200e630: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 200e634: 80 a0 60 00 cmp %g1, 0 200e638: 02 80 00 27 be 200e6d4 <_POSIX_Keys_Run_destructors+0xd0> 200e63c: b0 10 20 01 mov 1, %i0 200e640: a4 10 20 01 mov 1, %l2 the_key = (POSIX_Keys_Control *) 200e644: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 200e648: 83 2e 20 02 sll %i0, 2, %g1 200e64c: c4 00 80 01 ld [ %g2 + %g1 ], %g2 _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 200e650: 80 a0 a0 00 cmp %g2, 0 200e654: 02 80 00 16 be 200e6ac <_POSIX_Keys_Run_destructors+0xa8> 200e658: b0 06 20 01 inc %i0 200e65c: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 200e660: 80 a0 60 00 cmp %g1, 0 200e664: 02 80 00 12 be 200e6ac <_POSIX_Keys_Run_destructors+0xa8> 200e668: a0 04 c0 02 add %l3, %g2, %l0 200e66c: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 200e670: 80 a0 e0 00 cmp %g3, 0 200e674: 22 80 00 0f be,a 200e6b0 <_POSIX_Keys_Run_destructors+0xac> 200e678: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 200e67c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 200e680: c4 00 40 14 ld [ %g1 + %l4 ], %g2 if ( value ) { 200e684: 90 90 a0 00 orcc %g2, 0, %o0 200e688: 22 80 00 0a be,a 200e6b0 <_POSIX_Keys_Run_destructors+0xac> 200e68c: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 <== NOT EXECUTED (*the_key->destructor)( value ); 200e690: 9f c0 c0 00 call %g3 200e694: 01 00 00 00 nop if ( the_key->Values[ thread_api ][ thread_index ] ) 200e698: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 200e69c: c4 05 00 01 ld [ %l4 + %g1 ], %g2 200e6a0: 80 a0 00 02 cmp %g0, %g2 200e6a4: 82 40 3f ff addx %g0, -1, %g1 200e6a8: a4 0c 80 01 and %l2, %g1, %l2 for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 200e6ac: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 200e6b0: 80 a0 40 18 cmp %g1, %i0 200e6b4: 3a bf ff e5 bcc,a 200e648 <_POSIX_Keys_Run_destructors+0x44> 200e6b8: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 200e6bc: 80 a4 a0 01 cmp %l2, 1 200e6c0: 02 80 00 05 be 200e6d4 <_POSIX_Keys_Run_destructors+0xd0> 200e6c4: aa 05 60 01 inc %l5 * 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 ) 200e6c8: 80 a5 60 04 cmp %l5, 4 200e6cc: 32 bf ff da bne,a 200e634 <_POSIX_Keys_Run_destructors+0x30> 200e6d0: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 200e6d4: 81 c7 e0 08 ret 200e6d8: 81 e8 00 00 restore 02013b94 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 2013b94: 9d e3 bf 98 save %sp, -104, %sp CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 2013b98: 92 10 20 ff mov 0xff, %o1 2013b9c: 90 10 00 18 mov %i0, %o0 2013ba0: 40 00 12 90 call 20185e0 2013ba4: aa 10 00 18 mov %i0, %l5 if ( n > NAME_MAX ) 2013ba8: b0 10 20 5b mov 0x5b, %i0 2013bac: 80 a2 20 ff cmp %o0, 0xff 2013bb0: 18 80 00 42 bgu 2013cb8 <_POSIX_Message_queue_Create_support+0x124> 2013bb4: a4 10 00 08 mov %o0, %l2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2013bb8: 27 00 80 93 sethi %hi(0x2024c00), %l3 2013bbc: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 2013bc0: 82 00 60 01 inc %g1 2013bc4: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] * 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 ) { 2013bc8: 80 a6 a0 00 cmp %i2, 0 2013bcc: 22 80 00 41 be,a 2013cd0 <_POSIX_Message_queue_Create_support+0x13c> 2013bd0: b4 10 20 10 mov 0x10, %i2 attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 2013bd4: e2 06 a0 04 ld [ %i2 + 4 ], %l1 2013bd8: 80 a4 60 00 cmp %l1, 0 2013bdc: 04 80 00 4c ble 2013d0c <_POSIX_Message_queue_Create_support+0x178> 2013be0: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 2013be4: f4 06 a0 08 ld [ %i2 + 8 ], %i2 2013be8: 80 a6 a0 00 cmp %i2, 0 2013bec: 04 80 00 48 ble 2013d0c <_POSIX_Message_queue_Create_support+0x178> 2013bf0: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Allocate( void ) { return (POSIX_Message_queue_Control *) 2013bf4: 29 00 80 94 sethi %hi(0x2025000), %l4 2013bf8: 7f ff eb 37 call 200e8d4 <_Objects_Allocate> 2013bfc: 90 15 20 e8 or %l4, 0xe8, %o0 ! 20250e8 <_POSIX_Message_queue_Information> rtems_set_errno_and_return_minus_one( ENFILE ); } #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 2013c00: a0 92 20 00 orcc %o0, 0, %l0 2013c04: 02 80 00 35 be 2013cd8 <_POSIX_Message_queue_Create_support+0x144> 2013c08: 82 10 20 01 mov 1, %g1 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 2013c0c: f2 24 20 10 st %i1, [ %l0 + 0x10 ] 2013c10: 92 10 00 12 mov %l2, %o1 the_mq->named = TRUE; the_mq->open_count = 1; the_mq->linked = TRUE; 2013c14: c2 24 20 18 st %g1, [ %l0 + 0x18 ] _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; the_mq->named = TRUE; 2013c18: c2 24 20 14 st %g1, [ %l0 + 0x14 ] the_mq->open_count = 1; 2013c1c: c2 24 20 1c st %g1, [ %l0 + 0x1c ] 2013c20: 25 00 80 93 sethi %hi(0x2024c00), %l2 2013c24: 7f ff e9 cd call 200e358 <_Heap_Allocate> 2013c28: 90 14 a1 1c or %l2, 0x11c, %o0 ! 2024d1c <_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) { 2013c2c: b2 92 20 00 orcc %o0, 0, %i1 2013c30: 22 80 00 56 be,a 2013d88 <_POSIX_Message_queue_Create_support+0x1f4> 2013c34: 90 15 20 e8 or %l4, 0xe8, %o0 <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strcpy( name, name_arg ); 2013c38: 40 00 10 05 call 2017c4c 2013c3c: 92 10 00 15 mov %l5, %o1 */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 2013c40: 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; 2013c44: c0 24 20 60 clr [ %l0 + 0x60 ] if ( ! _CORE_message_queue_Initialize( 2013c48: 96 10 00 1a mov %i2, %o3 2013c4c: 90 04 20 20 add %l0, 0x20, %o0 2013c50: 40 00 03 cd call 2014b84 <_CORE_message_queue_Initialize> 2013c54: 92 04 20 60 add %l0, 0x60, %o1 2013c58: 80 a2 20 00 cmp %o0, 0 2013c5c: 02 80 00 39 be 2013d40 <_POSIX_Message_queue_Create_support+0x1ac> 2013c60: 90 15 20 e8 or %l4, 0xe8, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2013c64: c2 04 20 08 ld [ %l0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2013c68: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2013c6c: 05 00 00 3f sethi %hi(0xfc00), %g2 2013c70: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2013c74: 82 08 40 02 and %g1, %g2, %g1 2013c78: 80 a0 40 03 cmp %g1, %g3 2013c7c: 38 80 00 06 bgu,a 2013c94 <_POSIX_Message_queue_Create_support+0x100> 2013c80: e0 26 c0 00 st %l0, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2013c84: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2013c88: 83 28 60 02 sll %g1, 2, %g1 2013c8c: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_Message_queue_Information, &the_mq->Object, (char *) name ); *message_queue = the_mq; 2013c90: e0 26 c0 00 st %l0, [ %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; 2013c94: f2 24 20 0c st %i1, [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013c98: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 2013c9c: b0 10 20 00 clr %i0 2013ca0: 82 00 7f ff add %g1, -1, %g1 2013ca4: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] 2013ca8: c4 04 e0 d0 ld [ %l3 + 0xd0 ], %g2 2013cac: 80 a0 a0 00 cmp %g2, 0 2013cb0: 02 80 00 04 be 2013cc0 <_POSIX_Message_queue_Create_support+0x12c> 2013cb4: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return 0; } 2013cb8: 81 c7 e0 08 ret 2013cbc: 81 e8 00 00 restore _Thread_Dispatch(); 2013cc0: 7f ff f1 4e call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2013cc4: 01 00 00 00 nop <== NOT EXECUTED 2013cc8: 81 c7 e0 08 ret <== NOT EXECUTED 2013ccc: 81 e8 00 00 restore <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 2013cd0: 10 bf ff c9 b 2013bf4 <_POSIX_Message_queue_Create_support+0x60> 2013cd4: a2 10 20 0a mov 0xa, %l1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013cd8: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 <== NOT EXECUTED 2013cdc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2013ce0: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] <== NOT EXECUTED 2013ce4: c4 04 e0 d0 ld [ %l3 + 0xd0 ], %g2 <== NOT EXECUTED 2013ce8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2013cec: 02 80 00 36 be 2013dc4 <_POSIX_Message_queue_Create_support+0x230> <== NOT EXECUTED 2013cf0: 01 00 00 00 nop <== NOT EXECUTED #endif the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 2013cf4: 40 00 0a f2 call 20168bc <__errno> <== NOT EXECUTED 2013cf8: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2013cfc: 82 10 20 17 mov 0x17, %g1 <== NOT EXECUTED 2013d00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2013d04: 81 c7 e0 08 ret <== NOT EXECUTED 2013d08: 81 e8 00 00 restore <== NOT EXECUTED 2013d0c: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 2013d10: 82 00 7f ff add %g1, -1, %g1 2013d14: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] 2013d18: c4 04 e0 d0 ld [ %l3 + 0xd0 ], %g2 2013d1c: 80 a0 a0 00 cmp %g2, 0 2013d20: 02 80 00 2c be 2013dd0 <_POSIX_Message_queue_Create_support+0x23c> 2013d24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 2013d28: 40 00 0a e5 call 20168bc <__errno> 2013d2c: b0 10 3f ff mov -1, %i0 ! ffffffff 2013d30: 82 10 20 16 mov 0x16, %g1 2013d34: c2 22 00 00 st %g1, [ %o0 ] 2013d38: 81 c7 e0 08 ret 2013d3c: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free ( POSIX_Message_queue_Control *the_mq ) { _Objects_Free( &_POSIX_Message_queue_Information, &the_mq->Object ); 2013d40: 7f ff eb f3 call 200ed0c <_Objects_Free> <== NOT EXECUTED 2013d44: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2013d48: 90 14 a1 1c or %l2, 0x11c, %o0 <== NOT EXECUTED 2013d4c: 7f ff e9 b5 call 200e420 <_Heap_Free> <== NOT EXECUTED 2013d50: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2013d54: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 <== NOT EXECUTED 2013d58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2013d5c: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] <== NOT EXECUTED 2013d60: c4 04 e0 d0 ld [ %l3 + 0xd0 ], %g2 <== NOT EXECUTED 2013d64: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2013d68: 02 80 00 1d be 2013ddc <_POSIX_Message_queue_Create_support+0x248> <== NOT EXECUTED 2013d6c: 01 00 00 00 nop <== NOT EXECUTED #endif _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); 2013d70: 40 00 0a d3 call 20168bc <__errno> <== NOT EXECUTED 2013d74: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2013d78: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED 2013d7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2013d80: 81 c7 e0 08 ret <== NOT EXECUTED 2013d84: 81 e8 00 00 restore <== NOT EXECUTED 2013d88: 7f ff eb e1 call 200ed0c <_Objects_Free> <== NOT EXECUTED 2013d8c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2013d90: c2 04 e0 d0 ld [ %l3 + 0xd0 ], %g1 <== NOT EXECUTED 2013d94: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2013d98: c2 24 e0 d0 st %g1, [ %l3 + 0xd0 ] <== NOT EXECUTED 2013d9c: c4 04 e0 d0 ld [ %l3 + 0xd0 ], %g2 <== NOT EXECUTED 2013da0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2013da4: 02 80 00 11 be 2013de8 <_POSIX_Message_queue_Create_support+0x254> <== NOT EXECUTED 2013da8: 01 00 00 00 nop <== NOT EXECUTED name = _Workspace_Allocate(n); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); 2013dac: 40 00 0a c4 call 20168bc <__errno> <== NOT EXECUTED 2013db0: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2013db4: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 2013db8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2013dbc: 81 c7 e0 08 ret <== NOT EXECUTED 2013dc0: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2013dc4: 7f ff f1 0d call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2013dc8: 01 00 00 00 nop <== NOT EXECUTED 2013dcc: 30 bf ff ca b,a 2013cf4 <_POSIX_Message_queue_Create_support+0x160> <== NOT EXECUTED 2013dd0: 7f ff f1 0a call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2013dd4: 01 00 00 00 nop <== NOT EXECUTED 2013dd8: 30 bf ff d4 b,a 2013d28 <_POSIX_Message_queue_Create_support+0x194> <== NOT EXECUTED 2013ddc: 7f ff f1 07 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2013de0: 01 00 00 00 nop <== NOT EXECUTED 2013de4: 30 bf ff e3 b,a 2013d70 <_POSIX_Message_queue_Create_support+0x1dc> <== NOT EXECUTED 2013de8: 7f ff f1 04 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2013dec: 01 00 00 00 nop <== NOT EXECUTED 2013df0: 30 bf ff ef b,a 2013dac <_POSIX_Message_queue_Create_support+0x218> <== NOT EXECUTED 02009f6c <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 2009f6c: 9d e3 bf 98 save %sp, -104, %sp if ( !the_mq->linked && !the_mq->open_count ) { 2009f70: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 2009f74: 80 a0 60 00 cmp %g1, 0 2009f78: 12 80 00 1f bne 2009ff4 <_POSIX_Message_queue_Delete+0x88> 2009f7c: b2 10 00 18 mov %i0, %i1 2009f80: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 2009f84: 80 a0 60 00 cmp %g1, 0 2009f88: 12 80 00 1b bne 2009ff4 <_POSIX_Message_queue_Delete+0x88> 2009f8c: 01 00 00 00 nop /* the name memory may have been freed by unlink. */ if ( the_mq->Object.name ) 2009f90: d2 06 20 0c ld [ %i0 + 0xc ], %o1 2009f94: 80 a2 60 00 cmp %o1, 0 2009f98: 02 80 00 04 be 2009fa8 <_POSIX_Message_queue_Delete+0x3c> 2009f9c: 11 00 80 93 sethi %hi(0x2024c00), %o0 RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009fa0: 40 00 11 20 call 200e420 <_Heap_Free> <== NOT EXECUTED 2009fa4: 90 12 21 1c or %o0, 0x11c, %o0 ! 2024d1c <_Workspace_Area> <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009fa8: 03 00 80 94 sethi %hi(0x2025000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2009fac: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009fb0: b0 10 60 e8 or %g1, 0xe8, %i0 2009fb4: c4 16 20 10 lduh [ %i0 + 0x10 ], %g2 2009fb8: 03 00 00 3f sethi %hi(0xfc00), %g1 2009fbc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009fc0: 82 08 c0 01 and %g3, %g1, %g1 2009fc4: 80 a0 40 02 cmp %g1, %g2 2009fc8: 18 80 00 05 bgu 2009fdc <_POSIX_Message_queue_Delete+0x70> 2009fcc: 90 06 60 20 add %i1, 0x20, %o0 information->local_table[ index ] = the_object; 2009fd0: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2009fd4: 83 28 60 02 sll %g1, 2, %g1 2009fd8: 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( 2009fdc: 92 10 20 00 clr %o1 2009fe0: 94 10 20 05 mov 5, %o2 2009fe4: 40 00 0e db call 200db50 <_CORE_message_queue_Close> 2009fe8: 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 ); 2009fec: 40 00 13 48 call 200ed0c <_Objects_Free> 2009ff0: 81 e8 00 00 restore 2009ff4: 81 c7 e0 08 ret 2009ff8: 81 e8 00 00 restore 0200a58c <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 200a58c: 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 *) 200a590: 11 00 80 94 sethi %hi(0x2025000), %o0 200a594: 94 07 bf f4 add %fp, -12, %o2 200a598: 90 12 22 a0 or %o0, 0x2a0, %o0 200a59c: 40 00 12 1f call 200ee18 <_Objects_Get> 200a5a0: 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 ) { 200a5a4: c2 07 bf f4 ld [ %fp + -12 ], %g1 size_t msg_len, unsigned int *msg_prio, boolean wait, Watchdog_Interval timeout ) { 200a5a8: 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 ) { 200a5ac: 80 a0 60 01 cmp %g1, 1 200a5b0: 02 80 00 43 be 200a6bc <_POSIX_Message_queue_Receive_support+0x130> 200a5b4: 9a 10 00 1d mov %i5, %o5 200a5b8: 80 a0 60 01 cmp %g1, 1 200a5bc: 1a 80 00 29 bcc 200a660 <_POSIX_Message_queue_Receive_support+0xd4> 200a5c0: 80 a0 60 02 cmp %g1, 2 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 ) { 200a5c4: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 200a5c8: 82 08 a0 03 and %g2, 3, %g1 200a5cc: 80 a0 60 01 cmp %g1, 1 200a5d0: 02 80 00 2a be 200a678 <_POSIX_Message_queue_Receive_support+0xec> 200a5d4: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 200a5d8: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 200a5dc: c2 02 20 6c ld [ %o0 + 0x6c ], %g1 200a5e0: 80 a0 40 1a cmp %g1, %i2 200a5e4: 18 80 00 44 bgu 200a6f4 <_POSIX_Message_queue_Receive_support+0x168> 200a5e8: 80 a7 20 00 cmp %i4, 0 length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 200a5ec: 12 80 00 3a bne 200a6d4 <_POSIX_Message_queue_Receive_support+0x148> 200a5f0: 98 10 20 00 clr %o4 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 200a5f4: 82 10 3f ff mov -1, %g1 do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 200a5f8: 90 02 20 20 add %o0, 0x20, %o0 200a5fc: 92 10 00 18 mov %i0, %o1 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 200a600: c2 27 bf f0 st %g1, [ %fp + -16 ] do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 200a604: 40 00 0d 79 call 200dbe8 <_CORE_message_queue_Seize> 200a608: 96 07 bf f0 add %fp, -16, %o3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a60c: 05 00 80 93 sethi %hi(0x2024c00), %g2 200a610: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a614: 82 00 7f ff add %g1, -1, %g1 200a618: c2 20 a0 d0 st %g1, [ %g2 + 0xd0 ] 200a61c: c6 00 a0 d0 ld [ %g2 + 0xd0 ], %g3 200a620: 80 a0 e0 00 cmp %g3, 0 200a624: 02 80 00 30 be 200a6e4 <_POSIX_Message_queue_Receive_support+0x158> 200a628: 01 00 00 00 nop do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 200a62c: 3b 00 80 93 sethi %hi(0x2024c00), %i5 <== NOT EXECUTED 200a630: c4 07 61 b0 ld [ %i5 + 0x1b0 ], %g2 ! 2024db0 <_Thread_Executing> <== NOT EXECUTED 200a634: c2 00 a0 24 ld [ %g2 + 0x24 ], %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 200a638: c8 00 a0 34 ld [ %g2 + 0x34 ], %g4 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 200a63c: 87 38 60 1f sra %g1, 0x1f, %g3 200a640: 82 18 c0 01 xor %g3, %g1, %g1 200a644: 82 20 40 03 sub %g1, %g3, %g1 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 200a648: 80 a1 20 00 cmp %g4, 0 200a64c: 12 80 00 38 bne 200a72c <_POSIX_Message_queue_Receive_support+0x1a0> 200a650: c2 26 c0 00 st %g1, [ %i3 ] return length_out; 200a654: d0 07 bf f0 ld [ %fp + -16 ], %o0 _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 200a658: 81 c7 e0 08 ret 200a65c: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; size_t length_out; boolean do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a660: 02 80 00 10 be 200a6a0 <_POSIX_Message_queue_Receive_support+0x114> 200a664: 01 00 00 00 nop _POSIX_Message_queue_Translate_core_message_queue_return_code( _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); 200a668: 40 00 06 8e call 200c0a0 <== NOT EXECUTED 200a66c: 01 00 00 00 nop <== NOT EXECUTED } 200a670: 81 c7 e0 08 ret 200a674: 91 e8 00 08 restore %g0, %o0, %o0 200a678: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a67c: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a680: 84 00 bf ff add %g2, -1, %g2 200a684: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a688: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a68c: 80 a0 e0 00 cmp %g3, 0 200a690: 12 80 00 04 bne 200a6a0 <_POSIX_Message_queue_Receive_support+0x114> 200a694: 01 00 00 00 nop _Thread_Dispatch(); 200a698: 40 00 16 d8 call 20101f8 <_Thread_Dispatch> 200a69c: 01 00 00 00 nop 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 ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); 200a6a0: 40 00 30 87 call 20168bc <__errno> 200a6a4: 01 00 00 00 nop 200a6a8: 82 10 20 09 mov 9, %g1 ! 9 200a6ac: c2 22 00 00 st %g1, [ %o0 ] 200a6b0: 90 10 3f ff mov -1, %o0 _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 200a6b4: 81 c7 e0 08 ret 200a6b8: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200a6bc: 40 00 16 cf call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a6c0: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a6c4: 40 00 06 81 call 200c0c8 <== NOT EXECUTED 200a6c8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Executing->Wait.return_code ) ); } return POSIX_BOTTOM_REACHED(); } 200a6cc: 81 c7 e0 08 ret <== NOT EXECUTED 200a6d0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 200a6d4: 83 30 a0 0e srl %g2, 0xe, %g1 200a6d8: 82 18 60 01 xor %g1, 1, %g1 200a6dc: 10 bf ff c6 b 200a5f4 <_POSIX_Message_queue_Receive_support+0x68> 200a6e0: 98 08 60 01 and %g1, 1, %o4 200a6e4: 40 00 16 c5 call 20101f8 <_Thread_Dispatch> 200a6e8: 3b 00 80 93 sethi %hi(0x2024c00), %i5 do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 200a6ec: 10 bf ff d2 b 200a634 <_POSIX_Message_queue_Receive_support+0xa8> 200a6f0: c4 07 61 b0 ld [ %i5 + 0x1b0 ], %g2 ! 2024db0 <_Thread_Executing> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a6f4: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a6f8: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a6fc: 84 00 bf ff add %g2, -1, %g2 200a700: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a704: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a708: 80 a0 e0 00 cmp %g3, 0 200a70c: 02 80 00 11 be 200a750 <_POSIX_Message_queue_Receive_support+0x1c4> 200a710: 01 00 00 00 nop the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EMSGSIZE ); 200a714: 40 00 30 6a call 20168bc <__errno> 200a718: 01 00 00 00 nop 200a71c: 82 10 20 7a mov 0x7a, %g1 ! 7a 200a720: c2 22 00 00 st %g1, [ %o0 ] 200a724: 10 bf ff d3 b 200a670 <_POSIX_Message_queue_Receive_support+0xe4> 200a728: 90 10 3f ff mov -1, %o0 _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) return length_out; rtems_set_errno_and_return_minus_one( 200a72c: 40 00 30 64 call 20168bc <__errno> 200a730: 01 00 00 00 nop 200a734: c2 07 61 b0 ld [ %i5 + 0x1b0 ], %g1 200a738: a0 10 00 08 mov %o0, %l0 200a73c: 40 00 00 e5 call 200aad0 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 200a740: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 200a744: d0 24 00 00 st %o0, [ %l0 ] 200a748: 10 bf ff ca b 200a670 <_POSIX_Message_queue_Receive_support+0xe4> 200a74c: 90 10 3f ff mov -1, %o0 _Thread_Dispatch(); 200a750: 40 00 16 aa call 20101f8 <_Thread_Dispatch> 200a754: 01 00 00 00 nop 200a758: 30 bf ff ef b,a 200a714 <_POSIX_Message_queue_Receive_support+0x188> 0200a774 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, boolean wait, Watchdog_Interval timeout ) { 200a774: 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 ) 200a778: 80 a6 e0 20 cmp %i3, 0x20 200a77c: 18 80 00 5b bgu 200a8e8 <_POSIX_Message_queue_Send_support+0x174> 200a780: 92 10 00 18 mov %i0, %o1 200a784: 11 00 80 94 sethi %hi(0x2025000), %o0 200a788: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 20252a0 <_POSIX_Message_queue_Information_fds> 200a78c: 40 00 11 a3 call 200ee18 <_Objects_Get> 200a790: 94 07 bf f4 add %fp, -12, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a794: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a798: 80 a0 60 01 cmp %g1, 1 200a79c: 02 80 00 42 be 200a8a4 <_POSIX_Message_queue_Send_support+0x130> 200a7a0: 01 00 00 00 nop 200a7a4: 2a 80 00 09 bcs,a 200a7c8 <_POSIX_Message_queue_Send_support+0x54> 200a7a8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a7ac: 80 a0 60 02 cmp %g1, 2 200a7b0: 02 80 00 36 be 200a888 <_POSIX_Message_queue_Send_support+0x114> 200a7b4: 01 00 00 00 nop _POSIX_Message_queue_Translate_core_message_queue_return_code( msg_status ) ); } return POSIX_BOTTOM_REACHED(); 200a7b8: 40 00 06 3a call 200c0a0 <== NOT EXECUTED 200a7bc: 01 00 00 00 nop <== NOT EXECUTED } 200a7c0: 81 c7 e0 08 ret 200a7c4: 91 e8 00 08 restore %g0, %o0, %o0 _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 ) { 200a7c8: 80 88 60 03 btst 3, %g1 200a7cc: 02 80 00 25 be 200a860 <_POSIX_Message_queue_Send_support+0xec> 200a7d0: 80 a7 20 00 cmp %i4, 0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 200a7d4: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 200a7d8: 12 80 00 39 bne 200a8bc <_POSIX_Message_queue_Send_support+0x148> 200a7dc: 84 10 20 00 clr %g2 do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 200a7e0: fa 23 a0 60 st %i5, [ %sp + 0x60 ] 200a7e4: c4 23 a0 5c st %g2, [ %sp + 0x5c ] 200a7e8: 92 10 00 19 mov %i1, %o1 200a7ec: 94 10 00 1a mov %i2, %o2 200a7f0: 96 10 00 18 mov %i0, %o3 200a7f4: 9a 20 00 1b neg %i3, %o5 200a7f8: 98 10 20 00 clr %o4 200a7fc: 40 00 0d 42 call 200dd04 <_CORE_message_queue_Submit> 200a800: 90 02 20 20 add %o0, 0x20, %o0 200a804: ba 10 00 08 mov %o0, %i5 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a808: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a80c: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a810: 84 00 bf ff add %g2, -1, %g2 200a814: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a818: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a81c: 80 a0 e0 00 cmp %g3, 0 200a820: 02 80 00 2b be 200a8cc <_POSIX_Message_queue_Send_support+0x158> 200a824: 01 00 00 00 nop * 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 ) 200a828: 80 a7 60 07 cmp %i5, 7 <== NOT EXECUTED 200a82c: 02 80 00 2c be 200a8dc <_POSIX_Message_queue_Send_support+0x168> 200a830: 03 00 80 93 sethi %hi(0x2024c00), %g1 msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 200a834: 80 a7 60 00 cmp %i5, 0 200a838: 02 bf ff e2 be 200a7c0 <_POSIX_Message_queue_Send_support+0x4c> 200a83c: 90 10 20 00 clr %o0 return msg_status; rtems_set_errno_and_return_minus_one( 200a840: 40 00 30 1f call 20168bc <__errno> 200a844: 01 00 00 00 nop 200a848: a0 10 00 08 mov %o0, %l0 200a84c: 40 00 00 a1 call 200aad0 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 200a850: 90 10 00 1d mov %i5, %o0 200a854: d0 24 00 00 st %o0, [ %l0 ] 200a858: 10 bf ff da b 200a7c0 <_POSIX_Message_queue_Send_support+0x4c> 200a85c: 90 10 3f ff mov -1, %o0 200a860: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a864: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a868: 84 00 bf ff add %g2, -1, %g2 200a86c: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a870: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a874: 80 a0 e0 00 cmp %g3, 0 200a878: 12 80 00 04 bne 200a888 <_POSIX_Message_queue_Send_support+0x114> 200a87c: 01 00 00 00 nop _Thread_Dispatch(); 200a880: 40 00 16 5e call 20101f8 <_Thread_Dispatch> 200a884: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); 200a888: 40 00 30 0d call 20168bc <__errno> 200a88c: 01 00 00 00 nop 200a890: 82 10 20 09 mov 9, %g1 ! 9 200a894: c2 22 00 00 st %g1, [ %o0 ] 200a898: 90 10 3f ff mov -1, %o0 msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 200a89c: 81 c7 e0 08 ret 200a8a0: 91 e8 00 08 restore %g0, %o0, %o0 switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200a8a4: 40 00 16 55 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a8a8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a8ac: 40 00 06 07 call 200c0c8 <== NOT EXECUTED 200a8b0: 01 00 00 00 nop <== NOT EXECUTED msg_status ) ); } return POSIX_BOTTOM_REACHED(); } 200a8b4: 81 c7 e0 08 ret <== NOT EXECUTED 200a8b8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 200a8bc: 83 30 60 0e srl %g1, 0xe, %g1 200a8c0: 82 18 60 01 xor %g1, 1, %g1 200a8c4: 10 bf ff c7 b 200a7e0 <_POSIX_Message_queue_Send_support+0x6c> 200a8c8: 84 08 60 01 and %g1, 1, %g2 200a8cc: 40 00 16 4b call 20101f8 <_Thread_Dispatch> 200a8d0: 01 00 00 00 nop * 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 ) 200a8d4: 10 bf ff d6 b 200a82c <_POSIX_Message_queue_Send_support+0xb8> 200a8d8: 80 a7 60 07 cmp %i5, 7 msg_status = _Thread_Executing->Wait.return_code; 200a8dc: c4 00 61 b0 ld [ %g1 + 0x1b0 ], %g2 200a8e0: 10 bf ff d5 b 200a834 <_POSIX_Message_queue_Send_support+0xc0> 200a8e4: fa 00 a0 34 ld [ %g2 + 0x34 ], %i5 * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) rtems_set_errno_and_return_minus_one( EINVAL ); 200a8e8: 40 00 2f f5 call 20168bc <__errno> 200a8ec: 01 00 00 00 nop 200a8f0: 82 10 20 16 mov 0x16, %g1 ! 16 200a8f4: c2 22 00 00 st %g1, [ %o0 ] 200a8f8: 10 bf ff b2 b 200a7c0 <_POSIX_Message_queue_Send_support+0x4c> 200a8fc: 90 10 3f ff mov -1, %o0 0200aad0 <_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 ) { 200aad0: 9d e3 bf 98 save %sp, -104, %sp switch ( the_message_queue_status ) { 200aad4: 80 a6 20 03 cmp %i0, 3 200aad8: 02 80 00 21 be 200ab5c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x8c> 200aadc: 94 10 00 18 mov %i0, %o2 200aae0: 80 a6 20 03 cmp %i0, 3 200aae4: 08 80 00 12 bleu 200ab2c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x5c> 200aae8: 80 a6 20 01 cmp %i0, 1 200aaec: 80 a6 20 05 cmp %i0, 5 200aaf0: 02 80 00 19 be 200ab54 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x84> 200aaf4: 01 00 00 00 nop 200aaf8: 2a 80 00 13 bcs,a 200ab44 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x74> 200aafc: b0 10 20 0b mov 0xb, %i0 ! b 200ab00: 80 a6 20 06 cmp %i0, 6 200ab04: 02 80 00 1a be 200ab6c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x9c> 200ab08: 03 00 44 44 sethi %hi(0x1111000), %g1 200ab0c: 82 10 61 11 or %g1, 0x111, %g1 ! 1111111 <== NOT EXECUTED 200ab10: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 200ab14: 02 80 00 14 be 200ab64 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x94> <== NOT EXECUTED 200ab18: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED * RTEMS POSIX API implementation does not support multiprocessing. */ case THREAD_STATUS_PROXY_BLOCKING: return ENOSYS; } _Internal_error_Occurred( 200ab1c: 40 00 0f 41 call 200e820 <_Internal_error_Occurred> <== NOT EXECUTED 200ab20: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 200ab24: 40 00 05 5f call 200c0a0 <== NOT EXECUTED 200ab28: 81 e8 00 00 restore <== NOT EXECUTED int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 200ab2c: 02 80 00 06 be 200ab44 <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x74> 200ab30: b0 10 20 7a mov 0x7a, %i0 200ab34: 80 a2 a0 01 cmp %o2, 1 200ab38: 08 80 00 05 bleu 200ab4c <_POSIX_Message_queue_Translate_core_message_queue_return_code+0x7c> 200ab3c: 01 00 00 00 nop _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, the_message_queue_status ); return POSIX_BOTTOM_REACHED(); 200ab40: b0 10 20 0b mov 0xb, %i0 ! b } 200ab44: 81 c7 e0 08 ret 200ab48: 81 e8 00 00 restore int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 200ab4c: 81 c7 e0 08 ret <== NOT EXECUTED 200ab50: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Out of message buffers to queue pending message */ case CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED: return ENOMEM; 200ab54: 81 c7 e0 08 ret 200ab58: 91 e8 20 09 restore %g0, 9, %o0 /* * Bad message size */ case CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE: return EMSGSIZE; 200ab5c: 81 c7 e0 08 ret <== NOT EXECUTED 200ab60: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED int _POSIX_Message_queue_Translate_core_message_queue_return_code( uint32_t the_message_queue_status ) { switch ( the_message_queue_status ) { 200ab64: 81 c7 e0 08 ret <== NOT EXECUTED 200ab68: 91 e8 20 58 restore %g0, 0x58, %o0 <== NOT EXECUTED 200ab6c: 81 c7 e0 08 ret 200ab70: 91 e8 20 74 restore %g0, 0x74, %o0 020104a8 <_POSIX_Mutex_From_core_mutex_status>: */ int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { 20104a8: 9d e3 bf 98 save %sp, -104, %sp switch ( status ) { 20104ac: 80 a6 20 06 cmp %i0, 6 20104b0: 08 80 00 0b bleu 20104dc <_POSIX_Mutex_From_core_mutex_status+0x34> 20104b4: 83 2e 20 02 sll %i0, 2, %g1 case CORE_MUTEX_STATUS_CEILING_VIOLATED: return EINVAL; default: break; } assert( 0 ); 20104b8: 92 10 20 32 mov 0x32, %o1 <== NOT EXECUTED 20104bc: 11 00 80 66 sethi %hi(0x2019800), %o0 <== NOT EXECUTED 20104c0: 15 00 80 5f sethi %hi(0x2017c00), %o2 <== NOT EXECUTED 20104c4: 90 12 22 18 or %o0, 0x218, %o0 <== NOT EXECUTED 20104c8: 94 12 a3 e0 or %o2, 0x3e0, %o2 <== NOT EXECUTED 20104cc: 7f ff ce e7 call 2004068 <__assert> <== NOT EXECUTED 20104d0: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 20104d4: 81 c7 e0 08 ret <== NOT EXECUTED 20104d8: 81 e8 00 00 restore <== NOT EXECUTED int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { switch ( status ) { 20104dc: 05 00 80 41 sethi %hi(0x2010400), %g2 20104e0: 84 10 a0 8c or %g2, 0x8c, %g2 ! 201048c <_POSIX_Message_queue_Manager_initialization+0x58> 20104e4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20104e8: 81 c0 c0 00 jmp %g3 20104ec: 01 00 00 00 nop 20104f0: 81 c7 e0 08 ret 20104f4: 91 e8 20 74 restore %g0, 0x74, %o0 20104f8: 81 c7 e0 08 ret 20104fc: 91 e8 20 00 restore %g0, 0, %o0 case CORE_MUTEX_STATUS_SUCCESSFUL: return 0; 2010500: 81 c7 e0 08 ret 2010504: 91 e8 20 10 restore %g0, 0x10, %o0 case CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT: return EBUSY; 2010508: 81 c7 e0 08 ret 201050c: 91 e8 20 2d restore %g0, 0x2d, %o0 case CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED: return EDEADLK; 2010510: 81 c7 e0 08 ret 2010514: 91 e8 20 01 restore %g0, 1, %o0 int _POSIX_Mutex_From_core_mutex_status( CORE_mutex_Status status ) { switch ( status ) { 2010518: 81 c7 e0 08 ret 201051c: 91 e8 20 16 restore %g0, 0x16, %o0 02007a30 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, boolean blocking, Watchdog_Interval timeout ) { 2007a30: 9d e3 bf 90 save %sp, -112, %sp ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007a34: 80 a6 20 00 cmp %i0, 0 2007a38: 32 80 00 05 bne,a 2007a4c <_POSIX_Mutex_Lock_support+0x1c> 2007a3c: d2 06 00 00 ld [ %i0 ], %o1 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2007a40: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 2007a44: 81 c7 e0 08 ret 2007a48: 91 e8 00 08 restore %g0, %o0, %o0 2007a4c: 80 a2 7f ff cmp %o1, -1 2007a50: 02 80 00 94 be 2007ca0 <_POSIX_Mutex_Lock_support+0x270> 2007a54: 90 10 00 18 mov %i0, %o0 return (POSIX_Mutex_Control *) 2007a58: 11 00 80 6e sethi %hi(0x201b800), %o0 2007a5c: 94 07 bf f4 add %fp, -12, %o2 2007a60: 90 12 21 54 or %o0, 0x154, %o0 2007a64: 40 00 0e d7 call 200b5c0 <_Objects_Get_isr_disable> 2007a68: 96 07 bf f0 add %fp, -16, %o3 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 2007a6c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007a70: 80 a0 60 00 cmp %g1, 0 2007a74: 12 80 00 21 bne 2007af8 <_POSIX_Mutex_Lock_support+0xc8> 2007a78: a0 10 00 08 mov %o0, %l0 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 2007a7c: 31 00 80 6d sethi %hi(0x201b400), %i0 2007a80: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 ! 201b4f0 <_Thread_Dispatch_disable_level> 2007a84: 80 a0 60 00 cmp %g1, 0 2007a88: 12 80 00 22 bne 2007b10 <_POSIX_Mutex_Lock_support+0xe0> 2007a8c: 80 a6 60 00 cmp %i1, 0 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2007a90: 23 00 80 6d sethi %hi(0x201b400), %l1 2007a94: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2 ! 201b5d0 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2007a98: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2007a9c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2007aa0: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 2007aa4: 80 a0 60 00 cmp %g1, 0 2007aa8: 22 80 00 26 be,a 2007b40 <_POSIX_Mutex_Lock_support+0x110> 2007aac: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2007ab0: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2007ab4: 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; 2007ab8: c6 04 20 5c ld [ %l0 + 0x5c ], %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; 2007abc: 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; 2007ac0: c2 24 20 74 st %g1, [ %l0 + 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; 2007ac4: c4 24 20 70 st %g2, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2007ac8: 80 a0 e0 02 cmp %g3, 2 2007acc: 02 80 00 2b be 2007b78 <_POSIX_Mutex_Lock_support+0x148> 2007ad0: c8 24 20 68 st %g4, [ %l0 + 0x68 ] 2007ad4: 80 a0 e0 03 cmp %g3, 3 2007ad8: 22 80 00 2a be,a 2007b80 <_POSIX_Mutex_Lock_support+0x150> 2007adc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2007ae0: 7f ff f0 fa call 2003ec8 2007ae4: 01 00 00 00 nop the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 2007ae8: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 2007aec: 40 00 22 6f call 20104a8 <_POSIX_Mutex_From_core_mutex_status> 2007af0: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 2007af4: 30 bf ff d4 b,a 2007a44 <_POSIX_Mutex_Lock_support+0x14> register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 2007af8: 80 a0 60 02 cmp %g1, 2 2007afc: 28 bf ff d2 bleu,a 2007a44 <_POSIX_Mutex_Lock_support+0x14> 2007b00: 90 10 20 16 mov 0x16, %o0 ); return _POSIX_Mutex_From_core_mutex_status( (CORE_mutex_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2007b04: 40 00 04 15 call 2008b58 <== NOT EXECUTED 2007b08: 01 00 00 00 nop <== NOT EXECUTED 2007b0c: 30 bf ff ce b,a 2007a44 <_POSIX_Mutex_Lock_support+0x14> <== NOT EXECUTED ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 2007b10: 02 bf ff e1 be 2007a94 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 2007b14: 23 00 80 6d sethi %hi(0x201b400), %l1 <== NOT EXECUTED 2007b18: 03 00 80 6d sethi %hi(0x201b400), %g1 <== NOT EXECUTED 2007b1c: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 ! 201b6d0 <_System_state_Current> <== NOT EXECUTED 2007b20: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2007b24: 08 bf ff dc bleu 2007a94 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 2007b28: 90 10 20 00 clr %o0 <== NOT EXECUTED 2007b2c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007b30: 40 00 0d 44 call 200b040 <_Internal_error_Occurred> <== NOT EXECUTED 2007b34: 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; 2007b38: 10 bf ff d7 b 2007a94 <_POSIX_Mutex_Lock_support+0x64> <== NOT EXECUTED 2007b3c: 23 00 80 6d sethi %hi(0x201b400), %l1 <== 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 ) ) { 2007b40: 80 a0 40 02 cmp %g1, %g2 2007b44: 12 80 00 2d bne 2007bf8 <_POSIX_Mutex_Lock_support+0x1c8> 2007b48: 80 a6 60 00 cmp %i1, 0 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007b4c: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2007b50: 80 a0 60 00 cmp %g1, 0 2007b54: 12 80 00 41 bne 2007c58 <_POSIX_Mutex_Lock_support+0x228> 2007b58: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2007b5c: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 <== NOT EXECUTED 2007b60: 82 00 60 01 inc %g1 <== NOT EXECUTED 2007b64: c2 24 20 68 st %g1, [ %l0 + 0x68 ] <== NOT EXECUTED _ISR_Enable( level ); 2007b68: 7f ff f0 d8 call 2003ec8 <== NOT EXECUTED 2007b6c: 01 00 00 00 nop <== NOT EXECUTED the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 2007b70: 10 bf ff df b 2007aec <_POSIX_Mutex_Lock_support+0xbc> <== NOT EXECUTED 2007b74: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 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++; 2007b78: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007b7c: 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++; 2007b80: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2007b84: 12 bf ff d7 bne 2007ae0 <_POSIX_Mutex_Lock_support+0xb0> 2007b88: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2007b8c: c6 04 20 60 ld [ %l0 + 0x60 ], %g3 current = executing->current_priority; 2007b90: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 if ( current == ceiling ) { 2007b94: 80 a0 40 03 cmp %g1, %g3 2007b98: 02 80 00 49 be 2007cbc <_POSIX_Mutex_Lock_support+0x28c> 2007b9c: 80 a0 c0 01 cmp %g3, %g1 _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2007ba0: 1a 80 00 36 bcc 2007c78 <_POSIX_Mutex_Lock_support+0x248> 2007ba4: 82 10 20 06 mov 6, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007ba8: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 2007bac: 82 00 60 01 inc %g1 2007bb0: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] _Thread_Disable_dispatch(); _ISR_Enable( level ); 2007bb4: 7f ff f0 c5 call 2003ec8 2007bb8: 01 00 00 00 nop _Thread_Change_priority( 2007bbc: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 2007bc0: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 2007bc4: 40 00 12 65 call 200c558 <_Thread_Change_priority> 2007bc8: 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 ) 2007bcc: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 2007bd0: 82 00 7f ff add %g1, -1, %g1 2007bd4: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] 2007bd8: c4 06 20 f0 ld [ %i0 + 0xf0 ], %g2 2007bdc: 80 a0 a0 00 cmp %g2, 0 2007be0: 32 bf ff c3 bne,a 2007aec <_POSIX_Mutex_Lock_support+0xbc> 2007be4: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 2007be8: 40 00 13 8c call 200ca18 <_Thread_Dispatch> 2007bec: 01 00 00 00 nop 2007bf0: 10 bf ff bf b 2007aec <_POSIX_Mutex_Lock_support+0xbc> 2007bf4: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_mutex_Seize( 2007bf8: 32 80 00 08 bne,a 2007c18 <_POSIX_Mutex_Lock_support+0x1e8> 2007bfc: c4 04 20 08 ld [ %l0 + 8 ], %g2 2007c00: 7f ff f0 b2 call 2003ec8 2007c04: d0 07 bf f0 ld [ %fp + -16 ], %o0 2007c08: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2 2007c0c: 82 10 20 01 mov 1, %g1 2007c10: 10 bf ff b6 b 2007ae8 <_POSIX_Mutex_Lock_support+0xb8> 2007c14: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] 2007c18: c6 04 61 d0 ld [ %l1 + 0x1d0 ], %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007c1c: c2 06 20 f0 ld [ %i0 + 0xf0 ], %g1 2007c20: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] 2007c24: 82 00 60 01 inc %g1 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2007c28: 84 10 20 01 mov 1, %g2 2007c2c: c2 26 20 f0 st %g1, [ %i0 + 0xf0 ] 2007c30: c4 24 20 44 st %g2, [ %l0 + 0x44 ] 2007c34: a0 04 20 14 add %l0, 0x14, %l0 2007c38: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 2007c3c: 7f ff f0 a3 call 2003ec8 2007c40: d0 07 bf f0 ld [ %fp + -16 ], %o0 2007c44: 90 10 00 10 mov %l0, %o0 2007c48: 40 00 0a ad call 200a6fc <_CORE_mutex_Seize_interrupt_blocking> 2007c4c: 92 10 00 1a mov %i2, %o1 the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_From_core_mutex_status( 2007c50: 10 bf ff a7 b 2007aec <_POSIX_Mutex_Lock_support+0xbc> 2007c54: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2007c58: 12 bf ff e8 bne 2007bf8 <_POSIX_Mutex_Lock_support+0x1c8> 2007c5c: 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; 2007c60: 82 10 20 02 mov 2, %g1 2007c64: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] _ISR_Enable( level ); 2007c68: 7f ff f0 98 call 2003ec8 2007c6c: 01 00 00 00 nop 2007c70: 10 bf ff 9f b 2007aec <_POSIX_Mutex_Lock_support+0xbc> 2007c74: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2007c78: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] the_mutex->lock = CORE_MUTEX_UNLOCKED; 2007c7c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] the_mutex->nest_count = 0; /* undo locking above */ 2007c80: c0 24 20 68 clr [ %l0 + 0x68 ] executing->resource_count--; /* undo locking above */ 2007c84: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 2007c88: 82 00 7f ff add %g1, -1, %g1 2007c8c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2007c90: 7f ff f0 8e call 2003ec8 2007c94: 01 00 00 00 nop 2007c98: 10 bf ff 95 b 2007aec <_POSIX_Mutex_Lock_support+0xbc> 2007c9c: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007ca0: 7f ff fe f6 call 2007878 <== NOT EXECUTED 2007ca4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007ca8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007cac: 12 bf ff 66 bne 2007a44 <_POSIX_Mutex_Lock_support+0x14> <== NOT EXECUTED 2007cb0: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2007cb4: 10 bf ff 69 b 2007a58 <_POSIX_Mutex_Lock_support+0x28> <== NOT EXECUTED 2007cb8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2007cbc: 7f ff f0 83 call 2003ec8 <== NOT EXECUTED 2007cc0: 01 00 00 00 nop <== NOT EXECUTED 2007cc4: 10 bf ff 8a b 2007aec <_POSIX_Mutex_Lock_support+0xbc> <== NOT EXECUTED 2007cc8: c2 04 61 d0 ld [ %l1 + 0x1d0 ], %g1 <== NOT EXECUTED 020067d0 <_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 ) 20067d0: 80 a2 20 03 cmp %o0, 3 20067d4: 18 80 00 06 bgu 20067ec <_POSIX_RWLock_Translate_core_RWLock_return_code+0x1c> 20067d8: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); } 20067dc: 03 00 80 69 sethi %hi(0x201a400), %g1 20067e0: 82 10 61 a4 or %g1, 0x1a4, %g1 ! 201a5a4 <_POSIX_RWLock_Return_codes> 20067e4: 81 c3 e0 08 retl 20067e8: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_RWLock_Status the_rwlock_status ) { if ( the_rwlock_status <= CORE_RWLOCK_STATUS_LAST ) return _POSIX_RWLock_Return_codes[the_rwlock_status]; return POSIX_BOTTOM_REACHED(); 20067ec: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20067f0: 40 00 02 95 call 2007244 <== NOT EXECUTED 20067f4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20067f8: 01 00 00 00 nop 0200f63c <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 200f63c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f640: 21 00 80 7c sethi %hi(0x201f000), %l0 200f644: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 ! 201f090 <_Thread_Dispatch_disable_level> 200f648: 82 00 60 01 inc %g1 200f64c: c2 24 20 90 st %g1, [ %l0 + 0x90 ] char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 200f650: 80 a6 60 00 cmp %i1, 0 200f654: 12 80 00 3b bne 200f740 <_POSIX_Semaphore_Create_support+0x104> 200f658: 80 a6 20 00 cmp %i0, 0 _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); } if ( name ) { 200f65c: 02 80 00 07 be 200f678 <_POSIX_Semaphore_Create_support+0x3c> 200f660: 23 00 80 7d sethi %hi(0x201f400), %l1 if( strlen(name) > PATH_MAX ) { 200f664: 40 00 0f da call 20135cc 200f668: 90 10 00 18 mov %i0, %o0 200f66c: 80 a2 20 ff cmp %o0, 0xff 200f670: 18 80 00 41 bgu 200f774 <_POSIX_Semaphore_Create_support+0x138> 200f674: 23 00 80 7d sethi %hi(0x201f400), %l1 * _POSIX_Semaphore_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void ) { return (POSIX_Semaphore_Control *) 200f678: 7f ff e9 13 call 2009ac4 <_Objects_Allocate> 200f67c: 90 14 60 10 or %l1, 0x10, %o0 ! 201f410 <_POSIX_Semaphore_Information> } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 200f680: b2 92 20 00 orcc %o0, 0, %i1 200f684: 02 80 00 4f be 200f7c0 <_POSIX_Semaphore_Create_support+0x184> 200f688: 80 a6 20 00 cmp %i0, 0 } #endif the_semaphore->process_shared = pshared; if ( name ) { 200f68c: 02 80 00 29 be 200f730 <_POSIX_Semaphore_Create_support+0xf4> 200f690: c0 26 60 10 clr [ %i1 + 0x10 ] the_semaphore->named = TRUE; 200f694: 82 10 20 01 mov 1, %g1 the_semaphore->open_count = 1; the_semaphore->linked = TRUE; 200f698: c2 26 60 18 st %g1, [ %i1 + 0x18 ] #endif the_semaphore->process_shared = pshared; if ( name ) { the_semaphore->named = TRUE; 200f69c: c2 26 60 14 st %g1, [ %i1 + 0x14 ] the_semaphore->open_count = 1; 200f6a0: c2 26 60 1c st %g1, [ %i1 + 0x1c ] /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f6a4: 82 10 3f ff mov -1, %g1 _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f6a8: 90 06 60 20 add %i1, 0x20, %o0 /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 200f6ac: c2 26 60 60 st %g1, [ %i1 + 0x60 ] * 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; 200f6b0: c0 26 60 64 clr [ %i1 + 0x64 ] * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 200f6b4: 94 10 00 1a mov %i2, %o2 200f6b8: 7f ff e7 33 call 2009384 <_CORE_semaphore_Initialize> 200f6bc: 92 06 60 60 add %i1, 0x60, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f6c0: 90 14 60 10 or %l1, 0x10, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200f6c4: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f6c8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200f6cc: 03 00 00 3f sethi %hi(0xfc00), %g1 200f6d0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f6d4: 82 08 80 01 and %g2, %g1, %g1 200f6d8: 80 a0 40 03 cmp %g1, %g3 200f6dc: 38 80 00 06 bgu,a 200f6f4 <_POSIX_Semaphore_Create_support+0xb8> 200f6e0: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f6e4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200f6e8: 83 28 60 02 sll %g1, 2, %g1 200f6ec: f2 20 80 01 st %i1, [ %g2 + %g1 ] * Make the semaphore available for use. */ _Objects_Open(&_POSIX_Semaphore_Information, &the_semaphore->Object, name_p); *the_sem = the_semaphore; 200f6f0: f2 26 c0 00 st %i1, [ %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; 200f6f4: f0 26 60 0c st %i0, [ %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 ) 200f6f8: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 200f6fc: b0 10 20 00 clr %i0 200f700: 82 00 7f ff add %g1, -1, %g1 200f704: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 200f708: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200f70c: 80 a0 a0 00 cmp %g2, 0 200f710: 02 80 00 04 be 200f720 <_POSIX_Semaphore_Create_support+0xe4> 200f714: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return 0; } 200f718: 81 c7 e0 08 ret 200f71c: 81 e8 00 00 restore _Thread_Dispatch(); 200f720: 7f ff ef 32 call 200b3e8 <_Thread_Dispatch> 200f724: 01 00 00 00 nop 200f728: 81 c7 e0 08 ret 200f72c: 81 e8 00 00 restore if ( name ) { the_semaphore->named = TRUE; the_semaphore->open_count = 1; the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 200f730: c0 26 60 14 clr [ %i1 + 0x14 ] the_semaphore->open_count = 0; 200f734: c0 26 60 1c clr [ %i1 + 0x1c ] the_semaphore->linked = FALSE; 200f738: 10 bf ff db b 200f6a4 <_POSIX_Semaphore_Create_support+0x68> 200f73c: c0 26 60 18 clr [ %i1 + 0x18 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f740: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 200f744: 82 00 7f ff add %g1, -1, %g1 200f748: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 200f74c: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200f750: 80 a0 a0 00 cmp %g2, 0 200f754: 02 80 00 15 be 200f7a8 <_POSIX_Semaphore_Create_support+0x16c> 200f758: 01 00 00 00 nop _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); 200f75c: 40 00 09 24 call 2011bec <__errno> 200f760: b0 10 3f ff mov -1, %i0 ! ffffffff 200f764: 82 10 20 58 mov 0x58, %g1 200f768: c2 22 00 00 st %g1, [ %o0 ] 200f76c: 81 c7 e0 08 ret 200f770: 81 e8 00 00 restore 200f774: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 <== NOT EXECUTED 200f778: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200f77c: c2 24 20 90 st %g1, [ %l0 + 0x90 ] <== NOT EXECUTED 200f780: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 <== NOT EXECUTED 200f784: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200f788: 02 80 00 0b be 200f7b4 <_POSIX_Semaphore_Create_support+0x178> <== NOT EXECUTED 200f78c: 01 00 00 00 nop <== NOT EXECUTED } if ( name ) { if( strlen(name) > PATH_MAX ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 200f790: 40 00 09 17 call 2011bec <__errno> <== NOT EXECUTED 200f794: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200f798: 82 10 20 5b mov 0x5b, %g1 <== NOT EXECUTED 200f79c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200f7a0: 81 c7 e0 08 ret <== NOT EXECUTED 200f7a4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200f7a8: 7f ff ef 10 call 200b3e8 <_Thread_Dispatch> 200f7ac: 01 00 00 00 nop 200f7b0: 30 bf ff eb b,a 200f75c <_POSIX_Semaphore_Create_support+0x120> 200f7b4: 7f ff ef 0d call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 200f7b8: 01 00 00 00 nop <== NOT EXECUTED 200f7bc: 30 bf ff f5 b,a 200f790 <_POSIX_Semaphore_Create_support+0x154> <== 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 ) 200f7c0: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 200f7c4: 82 00 7f ff add %g1, -1, %g1 200f7c8: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 200f7cc: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200f7d0: 80 a0 a0 00 cmp %g2, 0 200f7d4: 02 80 00 08 be 200f7f4 <_POSIX_Semaphore_Create_support+0x1b8> 200f7d8: 01 00 00 00 nop the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); 200f7dc: 40 00 09 04 call 2011bec <__errno> 200f7e0: b0 10 3f ff mov -1, %i0 ! ffffffff 200f7e4: 82 10 20 1c mov 0x1c, %g1 200f7e8: c2 22 00 00 st %g1, [ %o0 ] 200f7ec: 81 c7 e0 08 ret 200f7f0: 81 e8 00 00 restore _Thread_Dispatch(); 200f7f4: 7f ff ee fd call 200b3e8 <_Thread_Dispatch> 200f7f8: 01 00 00 00 nop 200f7fc: 30 bf ff f8 b,a 200f7dc <_POSIX_Semaphore_Create_support+0x1a0> 0200f8f0 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200f8f0: 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 *) 200f8f4: d2 06 00 00 ld [ %i0 ], %o1 200f8f8: 94 07 bf f4 add %fp, -12, %o2 200f8fc: 11 00 80 7d sethi %hi(0x201f400), %o0 200f900: 7f ff e9 c2 call 200a008 <_Objects_Get> 200f904: 90 12 20 10 or %o0, 0x10, %o0 ! 201f410 <_POSIX_Semaphore_Information> POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200f908: c2 07 bf f4 ld [ %fp + -12 ], %g1 int _POSIX_Semaphore_Wait_support( sem_t *sem, boolean blocking, Watchdog_Interval timeout ) { 200f90c: 94 10 00 19 mov %i1, %o2 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 200f910: 80 a0 60 01 cmp %g1, 1 200f914: 02 80 00 24 be 200f9a4 <_POSIX_Semaphore_Wait_support+0xb4> 200f918: 96 10 00 1a mov %i2, %o3 200f91c: 80 a0 60 01 cmp %g1, 1 200f920: 2a 80 00 07 bcs,a 200f93c <_POSIX_Semaphore_Wait_support+0x4c> 200f924: d2 02 20 08 ld [ %o0 + 8 ], %o1 200f928: 80 a0 60 02 cmp %g1, 2 200f92c: 02 80 00 20 be 200f9ac <_POSIX_Semaphore_Wait_support+0xbc> 200f930: 01 00 00 00 nop */ break; } } return 0; } 200f934: 81 c7 e0 08 ret 200f938: 91 e8 20 00 restore %g0, 0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _CORE_semaphore_Seize( 200f93c: 40 00 01 9b call 200ffa8 <_CORE_semaphore_Seize> 200f940: 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 ) 200f944: 03 00 80 7c sethi %hi(0x201f000), %g1 200f948: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201f090 <_Thread_Dispatch_disable_level> 200f94c: 84 00 bf ff add %g2, -1, %g2 200f950: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 200f954: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 200f958: 80 a0 e0 00 cmp %g3, 0 200f95c: 02 80 00 1a be 200f9c4 <_POSIX_Semaphore_Wait_support+0xd4> 200f960: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 200f964: 03 00 80 7c sethi %hi(0x201f000), %g1 <== NOT EXECUTED 200f968: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201f170 <_Thread_Executing> 200f96c: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 200f970: 80 a0 60 02 cmp %g1, 2 200f974: 02 80 00 06 be 200f98c <_POSIX_Semaphore_Wait_support+0x9c> 200f978: 80 a0 60 03 cmp %g1, 3 200f97c: 02 80 00 16 be 200f9d4 <_POSIX_Semaphore_Wait_support+0xe4> 200f980: 80 a0 60 01 cmp %g1, 1 200f984: 12 bf ff ec bne 200f934 <_POSIX_Semaphore_Wait_support+0x44> 200f988: 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 ); 200f98c: 40 00 08 98 call 2011bec <__errno> 200f990: b0 10 3f ff mov -1, %i0 ! ffffffff 200f994: 82 10 20 0b mov 0xb, %g1 200f998: c2 22 00 00 st %g1, [ %o0 ] 200f99c: 81 c7 e0 08 ret 200f9a0: 81 e8 00 00 restore the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200f9a4: 7f ff ee 91 call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 200f9a8: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 200f9ac: 40 00 08 90 call 2011bec <__errno> 200f9b0: b0 10 3f ff mov -1, %i0 ! ffffffff 200f9b4: 82 10 20 16 mov 0x16, %g1 200f9b8: c2 22 00 00 st %g1, [ %o0 ] 200f9bc: 81 c7 e0 08 ret 200f9c0: 81 e8 00 00 restore _Thread_Dispatch(); 200f9c4: 7f ff ee 89 call 200b3e8 <_Thread_Dispatch> 200f9c8: 01 00 00 00 nop the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); switch ( _Thread_Executing->Wait.return_code ) { 200f9cc: 10 bf ff e7 b 200f968 <_POSIX_Semaphore_Wait_support+0x78> 200f9d0: 03 00 80 7c sethi %hi(0x201f000), %g1 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 ); case CORE_SEMAPHORE_TIMEOUT: rtems_set_errno_and_return_minus_one( ETIMEDOUT ); 200f9d4: 40 00 08 86 call 2011bec <__errno> 200f9d8: b0 10 3f ff mov -1, %i0 200f9dc: 82 10 20 74 mov 0x74, %g1 200f9e0: c2 22 00 00 st %g1, [ %o0 ] 200f9e4: 81 c7 e0 08 ret 200f9e8: 81 e8 00 00 restore 02005bd4 <_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 ) 2005bd4: 80 a2 20 06 cmp %o0, 6 2005bd8: 18 80 00 06 bgu 2005bf0 <_POSIX_Spinlock_Translate_core_spinlock_return_code+0x1c> 2005bdc: 85 2a 20 02 sll %o0, 2, %g2 return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); } 2005be0: 03 00 80 4e sethi %hi(0x2013800), %g1 2005be4: 82 10 60 44 or %g1, 0x44, %g1 ! 2013844 <_POSIX_Spinlock_Return_codes> 2005be8: 81 c3 e0 08 retl 2005bec: d0 00 40 02 ld [ %g1 + %g2 ], %o0 CORE_spinlock_Status the_spinlock_status ) { if ( the_spinlock_status <= CORE_SPINLOCK_STATUS_LAST ) return _POSIX_Spinlock_Return_codes[the_spinlock_status]; return POSIX_BOTTOM_REACHED(); 2005bf0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005bf4: 40 00 00 66 call 2005d8c <== NOT EXECUTED 2005bf8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2005bfc: 01 00 00 00 nop 02006a14 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 2006a14: 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; 2006a18: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006a1c: e4 00 60 3c ld [ %g1 + 0x3c ], %l2 ! 201dc3c <_POSIX_Threads_User_initialization_threads> maximum = _POSIX_Threads_Number_of_initialization_threads; 2006a20: 03 00 80 77 sethi %hi(0x201dc00), %g1 if ( !user_threads || maximum == 0 ) 2006a24: 80 a4 a0 00 cmp %l2, 0 2006a28: 02 80 00 54 be 2006b78 <_POSIX_Threads_Initialize_user_threads_body+0x164> 2006a2c: ec 00 61 0c ld [ %g1 + 0x10c ], %l6 2006a30: 80 a5 a0 00 cmp %l6, 0 2006a34: 02 80 00 51 be 2006b78 <_POSIX_Threads_Initialize_user_threads_body+0x164> 2006a38: 03 00 80 6d sethi %hi(0x201b400), %g1 * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { status = pthread_attr_init( &attr ); assert( !status ); 2006a3c: 05 00 80 6a sethi %hi(0x201a800), %g2 2006a40: aa 10 63 98 or %g1, 0x398, %l5 2006a44: a8 10 a3 08 or %g2, 0x308, %l4 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 2006a48: a6 10 20 00 clr %l3 2006a4c: a2 10 20 00 clr %l1 2006a50: a0 07 bf bc add %fp, -68, %l0 2006a54: 10 80 00 1a b 2006abc <_POSIX_Threads_Initialize_user_threads_body+0xa8> 2006a58: ae 07 bf f4 add %fp, -12, %l7 status = pthread_attr_init( &attr ); assert( !status ); status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 2006a5c: 40 00 21 58 call 200efbc 2006a60: 90 10 00 10 mov %l0, %o0 assert( !status ); 2006a64: 80 a2 20 00 cmp %o0, 0 2006a68: 12 80 00 26 bne 2006b00 <_POSIX_Threads_Initialize_user_threads_body+0xec> 2006a6c: 94 10 00 14 mov %l4, %o2 status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 2006a70: 82 04 80 11 add %l2, %l1, %g1 2006a74: d2 00 60 04 ld [ %g1 + 4 ], %o1 2006a78: 40 00 21 61 call 200effc 2006a7c: 90 10 00 10 mov %l0, %o0 assert( !status ); 2006a80: 80 a2 20 00 cmp %o0, 0 2006a84: 12 80 00 2a bne 2006b2c <_POSIX_Threads_Initialize_user_threads_body+0x118> 2006a88: 90 10 00 15 mov %l5, %o0 status = pthread_create( 2006a8c: d4 04 40 12 ld [ %l1 + %l2 ], %o2 2006a90: 92 10 00 10 mov %l0, %o1 2006a94: 96 10 20 00 clr %o3 2006a98: 90 10 00 17 mov %l7, %o0 2006a9c: 7f ff fe dd call 2006610 2006aa0: a2 04 60 08 add %l1, 8, %l1 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 2006aa4: 80 a2 20 00 cmp %o0, 0 2006aa8: 12 80 00 2e bne 2006b60 <_POSIX_Threads_Initialize_user_threads_body+0x14c> 2006aac: 90 10 00 15 mov %l5, %o0 * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 2006ab0: 80 a4 c0 16 cmp %l3, %l6 2006ab4: 02 80 00 31 be 2006b78 <_POSIX_Threads_Initialize_user_threads_body+0x164> 2006ab8: 01 00 00 00 nop status = pthread_attr_init( &attr ); 2006abc: 90 10 00 10 mov %l0, %o0 2006ac0: 40 00 21 34 call 200ef90 2006ac4: a6 04 e0 01 inc %l3 assert( !status ); 2006ac8: 80 a2 20 00 cmp %o0, 0 2006acc: 02 bf ff e4 be 2006a5c <_POSIX_Threads_Initialize_user_threads_body+0x48> 2006ad0: 92 10 20 02 mov 2, %o1 2006ad4: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 2006ad8: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2006adc: 7f ff f0 ff call 2002ed8 <__assert> <== NOT EXECUTED 2006ae0: 92 10 20 47 mov 0x47, %o1 <== NOT EXECUTED status = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 2006ae4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2006ae8: 40 00 21 35 call 200efbc <== NOT EXECUTED 2006aec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED assert( !status ); 2006af0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006af4: 02 bf ff e0 be 2006a74 <_POSIX_Threads_Initialize_user_threads_body+0x60> <== NOT EXECUTED 2006af8: 82 04 80 11 add %l2, %l1, %g1 <== NOT EXECUTED 2006afc: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 2006b00: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2006b04: 7f ff f0 f5 call 2002ed8 <__assert> <== NOT EXECUTED 2006b08: 92 10 20 4a mov 0x4a, %o1 <== NOT EXECUTED status = pthread_attr_setstacksize( &attr, user_threads[ index ].stack_size); 2006b0c: 82 04 80 11 add %l2, %l1, %g1 <== NOT EXECUTED 2006b10: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED 2006b14: 40 00 21 3a call 200effc <== NOT EXECUTED 2006b18: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED assert( !status ); 2006b1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006b20: 22 bf ff dc be,a 2006a90 <_POSIX_Threads_Initialize_user_threads_body+0x7c> <== NOT EXECUTED 2006b24: d4 04 40 12 ld [ %l1 + %l2 ], %o2 <== NOT EXECUTED 2006b28: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2006b2c: 92 10 20 4d mov 0x4d, %o1 <== NOT EXECUTED 2006b30: 7f ff f0 ea call 2002ed8 <__assert> <== NOT EXECUTED 2006b34: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED status = pthread_create( 2006b38: d4 04 40 12 ld [ %l1 + %l2 ], %o2 <== NOT EXECUTED 2006b3c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2006b40: 96 10 20 00 clr %o3 <== NOT EXECUTED 2006b44: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED 2006b48: 7f ff fe b2 call 2006610 <== NOT EXECUTED 2006b4c: a2 04 60 08 add %l1, 8, %l1 <== NOT EXECUTED &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); assert( !status ); 2006b50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006b54: 02 bf ff d8 be 2006ab4 <_POSIX_Threads_Initialize_user_threads_body+0xa0> <== NOT EXECUTED 2006b58: 80 a4 c0 16 cmp %l3, %l6 <== NOT EXECUTED 2006b5c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2006b60: 92 10 20 55 mov 0x55, %o1 <== NOT EXECUTED 2006b64: 7f ff f0 dd call 2002ed8 <__assert> <== NOT EXECUTED 2006b68: 94 10 00 14 mov %l4, %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++ ) { 2006b6c: 80 a4 c0 16 cmp %l3, %l6 <== NOT EXECUTED 2006b70: 12 bf ff d4 bne 2006ac0 <_POSIX_Threads_Initialize_user_threads_body+0xac> <== NOT EXECUTED 2006b74: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2006b78: 81 c7 e0 08 ret 2006b7c: 81 e8 00 00 restore 0200cf6c <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 200cf6c: 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 ]; 200cf70: f0 06 61 74 ld [ %i1 + 0x174 ], %i0 ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 200cf74: 40 00 04 11 call 200dfb8 <_Timespec_To_ticks> 200cf78: 90 06 20 90 add %i0, 0x90, %o0 if ( !ticks ) 200cf7c: 80 a2 20 00 cmp %o0, 0 200cf80: 22 80 00 02 be,a 200cf88 <_POSIX_Threads_Sporadic_budget_TSR+0x1c> 200cf84: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200cf88: 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 || 200cf8c: c6 06 60 1c ld [ %i1 + 0x1c ], %g3 200cf90: 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; 200cf94: d0 26 60 84 st %o0, [ %i1 + 0x84 ] 200cf98: 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 || 200cf9c: 80 a0 e0 00 cmp %g3, 0 200cfa0: 02 80 00 10 be 200cfe0 <_POSIX_Threads_Sporadic_budget_TSR+0x74> 200cfa4: d2 26 60 18 st %o1, [ %i1 + 0x18 ] 200cfa8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 200cfac: 80 a2 40 01 cmp %o1, %g1 200cfb0: 0a 80 00 0d bcs 200cfe4 <_POSIX_Threads_Sporadic_budget_TSR+0x78> 200cfb4: 90 10 00 19 mov %i1, %o0 the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 200cfb8: 40 00 04 00 call 200dfb8 <_Timespec_To_ticks> <== NOT EXECUTED 200cfbc: 90 06 20 88 add %i0, 0x88, %o0 <== NOT EXECUTED if ( !ticks ) 200cfc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200cfc4: 22 80 00 10 be,a 200d004 <_POSIX_Threads_Sporadic_budget_TSR+0x98> <== NOT EXECUTED 200cfc8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200cfcc: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200cfd0: b2 06 20 9c add %i0, 0x9c, %i1 200cfd4: 31 00 80 66 sethi %hi(0x2019800), %i0 200cfd8: 7f ff f6 06 call 200a7f0 <_Watchdog_Insert> 200cfdc: 91 ee 21 40 restore %i0, 0x140, %o0 new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200cfe0: 90 10 00 19 mov %i1, %o0 200cfe4: 7f ff ef 7e call 2008ddc <_Thread_Change_priority> 200cfe8: 94 10 20 01 mov 1, %o2 ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 200cfec: 40 00 03 f3 call 200dfb8 <_Timespec_To_ticks> 200cff0: 90 06 20 88 add %i0, 0x88, %o0 if ( !ticks ) 200cff4: 80 a2 20 00 cmp %o0, 0 200cff8: 32 bf ff f6 bne,a 200cfd0 <_POSIX_Threads_Sporadic_budget_TSR+0x64> 200cffc: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] 200d000: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200d004: b2 06 20 9c add %i0, 0x9c, %i1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200d008: d0 26 20 a8 st %o0, [ %i0 + 0xa8 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200d00c: 31 00 80 66 sethi %hi(0x2019800), %i0 <== NOT EXECUTED 200d010: 7f ff f5 f8 call 200a7f0 <_Watchdog_Insert> <== NOT EXECUTED 200d014: 91 ee 21 40 restore %i0, 0x140, %o0 <== NOT EXECUTED 200d018: 01 00 00 00 nop 0200cf1c <_POSIX_Threads_Sporadic_budget_callout>: ) { POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200cf1c: c4 02 21 74 ld [ %o0 + 0x174 ], %g2 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 || 200cf20: c8 02 20 1c ld [ %o0 + 0x1c ], %g4 RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (255 - priority); 200cf24: c6 00 a0 84 ld [ %g2 + 0x84 ], %g3 * 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 */ 200cf28: 82 10 3f ff mov -1, %g1 200cf2c: 84 10 20 ff mov 0xff, %g2 200cf30: c2 22 20 84 st %g1, [ %o0 + 0x84 ] 200cf34: 92 20 80 03 sub %g2, %g3, %o1 new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200cf38: 80 a1 20 00 cmp %g4, 0 200cf3c: 02 80 00 06 be 200cf54 <_POSIX_Threads_Sporadic_budget_callout+0x38> 200cf40: d2 22 20 18 st %o1, [ %o0 + 0x18 ] 200cf44: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED 200cf48: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED 200cf4c: 1a 80 00 06 bcc 200cf64 <_POSIX_Threads_Sporadic_budget_callout+0x48> <== NOT EXECUTED 200cf50: 01 00 00 00 nop <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 200cf54: 94 10 20 01 mov 1, %o2 ! 1 200cf58: 82 13 c0 00 mov %o7, %g1 200cf5c: 7f ff ef a0 call 2008ddc <_Thread_Change_priority> 200cf60: 9e 10 40 00 mov %g1, %o7 200cf64: 81 c3 e0 08 retl <== NOT EXECUTED 200cf68: 01 00 00 00 nop 02005478 <_POSIX_Threads_cancel_run>: */ void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 2005478: 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 ]; 200547c: e2 06 21 74 ld [ %i0 + 0x174 ], %l1 handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 2005480: 82 10 20 01 mov 1, %g1 while ( !_Chain_Is_empty( handler_stack ) ) { 2005484: c4 04 60 d8 ld [ %l1 + 0xd8 ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2005488: b2 04 60 dc add %l1, 0xdc, %i1 200548c: 80 a0 80 19 cmp %g2, %i1 2005490: 02 80 00 17 be 20054ec <_POSIX_Threads_cancel_run+0x74> 2005494: c2 24 60 cc st %g1, [ %l1 + 0xcc ] 2005498: 03 00 80 60 sethi %hi(0x2018000), %g1 <== NOT EXECUTED 200549c: a4 10 60 9c or %g1, 0x9c, %l2 ! 201809c <_Workspace_Area> <== NOT EXECUTED _ISR_Disable( level ); 20054a0: 7f ff f2 95 call 2001ef4 <== NOT EXECUTED 20054a4: 01 00 00 00 nop <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 20054a8: e0 06 60 04 ld [ %i1 + 4 ], %l0 <== NOT EXECUTED ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 20054ac: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED previous = the_node->previous; 20054b0: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 20054b4: 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; 20054b8: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 20054bc: 7f ff f2 92 call 2001f04 <== NOT EXECUTED 20054c0: 01 00 00 00 nop <== NOT EXECUTED (*handler->routine)( handler->arg ); 20054c4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 20054c8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20054cc: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 20054d0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20054d4: 40 00 0a e7 call 2008070 <_Heap_Free> <== NOT EXECUTED 20054d8: 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 ) ) { 20054dc: c2 04 60 d8 ld [ %l1 + 0xd8 ], %g1 <== NOT EXECUTED 20054e0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 20054e4: 12 bf ff ef bne 20054a0 <_POSIX_Threads_cancel_run+0x28> <== NOT EXECUTED 20054e8: 01 00 00 00 nop <== NOT EXECUTED } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; _Thread_Close( 20054ec: c6 06 20 08 ld [ %i0 + 8 ], %g3 20054f0: 03 00 80 5f sethi %hi(0x2017c00), %g1 20054f4: 85 30 e0 16 srl %g3, 0x16, %g2 20054f8: 82 10 63 b0 or %g1, 0x3b0, %g1 20054fc: 84 08 a0 1c and %g2, 0x1c, %g2 2005500: c8 00 40 02 ld [ %g1 + %g2 ], %g4 2005504: 87 30 e0 1b srl %g3, 0x1b, %g3 2005508: 87 28 e0 02 sll %g3, 2, %g3 200550c: d0 01 00 03 ld [ %g4 + %g3 ], %o0 2005510: 92 10 00 18 mov %i0, %o1 _Workspace_Free( handler ); } /* Now we can delete the thread */ the_thread->Wait.return_argument = PTHREAD_CANCELED; 2005514: 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 ); 2005518: b2 10 00 18 mov %i0, %i1 200551c: c2 26 20 28 st %g1, [ %i0 + 0x28 ] _Thread_Close( 2005520: 40 00 11 c0 call 2009c20 <_Thread_Close> 2005524: 31 00 80 60 sethi %hi(0x2018000), %i0 2005528: 40 00 0d 0d call 200895c <_Objects_Free> 200552c: 91 ee 23 38 restore %i0, 0x338, %o0 2005530: 01 00 00 00 nop 0200b6f0 <_POSIX_Timer_TSR>: * Description: This is the operation that is ran when a timer expires * ***************************************************************************/ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 200b6f0: 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; 200b6f4: c2 06 60 68 ld [ %i1 + 0x68 ], %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b6f8: 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; 200b6fc: 82 00 60 01 inc %g1 /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 200b700: 80 a0 a0 00 cmp %g2, 0 200b704: 12 80 00 0e bne 200b73c <_POSIX_Timer_TSR+0x4c> 200b708: c2 26 60 68 st %g1, [ %i1 + 0x68 ] 200b70c: c2 06 60 58 ld [ %i1 + 0x58 ], %g1 <== NOT EXECUTED 200b710: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b714: 32 80 00 0b bne,a 200b740 <_POSIX_Timer_TSR+0x50> <== NOT EXECUTED 200b718: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 200b71c: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED 200b720: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] <== NOT EXECUTED /* * 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 ) ) { 200b724: d0 06 60 38 ld [ %i1 + 0x38 ], %o0 200b728: 40 00 22 f8 call 2014308 200b72c: d2 06 60 44 ld [ %i1 + 0x44 ], %o1 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 200b730: c0 26 60 68 clr [ %i1 + 0x68 ] 200b734: 81 c7 e0 08 ret 200b738: 81 e8 00 00 restore ( 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( 200b73c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1 200b740: d4 06 60 08 ld [ %i1 + 8 ], %o2 200b744: 90 06 60 10 add %i1, 0x10, %o0 200b748: 17 00 80 2d sethi %hi(0x200b400), %o3 200b74c: 98 10 00 19 mov %i1, %o4 200b750: 7f ff ff cd call 200b684 <_Watchdog_Insert_ticks_helper> 200b754: 96 12 e2 f0 or %o3, 0x2f0, %o3 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 200b758: 80 a2 20 00 cmp %o0, 0 200b75c: 02 bf ff f6 be 200b734 <_POSIX_Timer_TSR+0x44> 200b760: 01 00 00 00 nop return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 200b764: 40 00 0a 9a call 200e1cc <_TOD_Get> 200b768: 90 06 60 6c add %i1, 0x6c, %o0 /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 200b76c: 82 10 20 03 mov 3, %g1 200b770: 10 bf ff ed b 200b724 <_POSIX_Timer_TSR+0x34> 200b774: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ] 0200ccc0 <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 200ccc0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED exit( 1 ); 200ccc4: 40 00 09 02 call 200f0cc <== NOT EXECUTED 200ccc8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 200cccc: 01 00 00 00 nop 0200e6dc <_POSIX_signals_Check_signal>: boolean _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, boolean is_global ) { 200e6dc: 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, 200e6e0: 98 10 20 01 mov 1, %o4 200e6e4: 96 10 00 1a mov %i2, %o3 200e6e8: a6 07 bf ec add %fp, -20, %l3 200e6ec: 90 10 00 18 mov %i0, %o0 200e6f0: 92 10 00 19 mov %i1, %o1 200e6f4: 40 00 00 2f call 200e7b0 <_POSIX_signals_Clear_signals> 200e6f8: 94 10 00 13 mov %l3, %o2 200e6fc: 80 a2 20 00 cmp %o0, 0 200e700: 02 80 00 23 be 200e78c <_POSIX_signals_Check_signal+0xb0> 200e704: 03 00 80 67 sethi %hi(0x2019c00), %g1 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 200e708: a4 10 62 d4 or %g1, 0x2d4, %l2 ! 2019ed4 <_POSIX_signals_Vectors> 200e70c: 83 2e 60 04 sll %i1, 4, %g1 200e710: 85 2e 60 02 sll %i1, 2, %g2 200e714: a0 20 40 02 sub %g1, %g2, %l0 200e718: b4 04 00 12 add %l0, %l2, %i2 200e71c: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200e720: 80 a0 60 00 cmp %g1, 0 200e724: 02 80 00 1c be 200e794 <_POSIX_signals_Check_signal+0xb8> 200e728: 11 00 80 5f sethi %hi(0x2017c00), %o0 /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 200e72c: 80 a0 60 01 cmp %g1, 1 200e730: 02 80 00 17 be 200e78c <_POSIX_signals_Check_signal+0xb0> 200e734: 01 00 00 00 nop /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 200e738: e2 06 20 c4 ld [ %i0 + 0xc4 ], %l1 api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200e73c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200e740: c4 04 80 10 ld [ %l2 + %l0 ], %g2 /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 200e744: 82 10 40 11 or %g1, %l1, %g1 /* Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 200e748: 80 a0 a0 02 cmp %g2, 2 200e74c: 02 80 00 08 be 200e76c <_POSIX_signals_Check_signal+0x90> 200e750: c2 26 20 c4 st %g1, [ %i0 + 0xc4 ] &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 200e754: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200e758: 9f c0 40 00 call %g1 200e75c: 90 10 00 19 mov %i1, %o0 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200e760: e2 26 20 c4 st %l1, [ %i0 + 0xc4 ] 200e764: 81 c7 e0 08 ret 200e768: 91 e8 20 01 restore %g0, 1, %o0 case SA_SIGINFO: /* * * assert( is_global ); */ (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 200e76c: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200e770: 90 10 00 19 mov %i1, %o0 200e774: 92 10 00 13 mov %l3, %o1 200e778: 9f c0 40 00 call %g1 200e77c: 94 10 20 00 clr %o2 /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 200e780: e2 26 20 c4 st %l1, [ %i0 + 0xc4 ] 200e784: 81 c7 e0 08 ret 200e788: 91 e8 20 01 restore %g0, 1, %o0 return TRUE; } 200e78c: 81 c7 e0 08 ret 200e790: 91 e8 20 00 restore %g0, 0, %o0 /* * Since we made a union of these, only one test is necessary but this is * safer. */ assert( _POSIX_signals_Vectors[ signo ].sa_handler || 200e794: 92 10 20 33 mov 0x33, %o1 <== NOT EXECUTED 200e798: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED 200e79c: 15 00 80 5f sethi %hi(0x2017c00), %o2 <== NOT EXECUTED 200e7a0: 7f ff ce 03 call 2001fac <__assert> <== NOT EXECUTED 200e7a4: 94 12 a1 50 or %o2, 0x150, %o2 ! 2017d50 <_POSIX_Threads_Default_attributes+0x180> <== NOT EXECUTED 200e7a8: 10 bf ff e1 b 200e72c <_POSIX_signals_Check_signal+0x50> <== NOT EXECUTED 200e7ac: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 0200e7b0 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, boolean is_global, boolean check_blocked ) { 200e7b0: 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 ); 200e7b4: 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 ) 200e7b8: 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 ); 200e7bc: 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 ) 200e7c0: b8 10 3f ff mov -1, %i4 200e7c4: 02 80 00 04 be 200e7d4 <_POSIX_signals_Clear_signals+0x24> 200e7c8: a1 28 40 02 sll %g1, %g2, %l0 signals_blocked = ~api->signals_blocked; 200e7cc: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1 200e7d0: 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 ); 200e7d4: 7f ff cd 8a call 2001dfc 200e7d8: 01 00 00 00 nop 200e7dc: a2 10 00 08 mov %o0, %l1 if ( is_global ) { 200e7e0: 80 a6 e0 00 cmp %i3, 0 200e7e4: 22 80 00 16 be,a 200e83c <_POSIX_signals_Clear_signals+0x8c> 200e7e8: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 200e7ec: 05 00 80 68 sethi %hi(0x201a000), %g2 200e7f0: c2 00 a0 a0 ld [ %g2 + 0xa0 ], %g1 ! 201a0a0 <_POSIX_signals_Pending> 200e7f4: 82 0c 00 01 and %l0, %g1, %g1 200e7f8: 80 88 40 1c btst %g1, %i4 200e7fc: 02 80 00 1a be 200e864 <_POSIX_signals_Clear_signals+0xb4> 200e800: 85 2e 60 02 sll %i1, 2, %g2 if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 200e804: 87 2e 60 04 sll %i1, 4, %g3 200e808: 03 00 80 67 sethi %hi(0x2019c00), %g1 200e80c: 86 20 c0 02 sub %g3, %g2, %g3 200e810: 82 10 62 d4 or %g1, 0x2d4, %g1 200e814: c4 00 40 03 ld [ %g1 + %g3 ], %g2 200e818: 80 a0 a0 02 cmp %g2, 2 200e81c: 02 80 00 17 be 200e878 <_POSIX_signals_Clear_signals+0xc8> 200e820: 90 10 00 10 mov %l0, %o0 &psiginfo->Node ); } else do_callout = FALSE; } else _POSIX_signals_Clear_process_signals( mask ); 200e824: 40 00 02 0f call 200f060 <_POSIX_signals_Clear_process_signals> 200e828: b0 10 20 01 mov 1, %i0 if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = TRUE; } } _ISR_Enable( level ); 200e82c: 7f ff cd 78 call 2001e0c 200e830: 90 10 00 11 mov %l1, %o0 return do_callout; } 200e834: 81 c7 e0 08 ret 200e838: 81 e8 00 00 restore } else _POSIX_signals_Clear_process_signals( mask ); do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 200e83c: 82 0c 00 08 and %l0, %o0, %g1 200e840: 80 88 40 1c btst %g1, %i4 200e844: 02 80 00 08 be 200e864 <_POSIX_signals_Clear_signals+0xb4> 200e848: 82 2a 00 10 andn %o0, %l0, %g1 api->signals_pending &= ~mask; 200e84c: c2 26 20 c8 st %g1, [ %i0 + 0xc8 ] 200e850: b0 10 20 01 mov 1, %i0 do_callout = TRUE; } } _ISR_Enable( level ); 200e854: 7f ff cd 6e call 2001e0c 200e858: 90 10 00 11 mov %l1, %o0 return do_callout; } 200e85c: 81 c7 e0 08 ret 200e860: 81 e8 00 00 restore _POSIX_signals_Clear_process_signals( mask ); do_callout = TRUE; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 200e864: b0 10 20 00 clr %i0 do_callout = TRUE; } } _ISR_Enable( level ); 200e868: 7f ff cd 69 call 2001e0c 200e86c: 90 10 00 11 mov %l1, %o0 return do_callout; } 200e870: 81 c7 e0 08 ret 200e874: 81 e8 00 00 restore _ISR_Disable( level ); if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 200e878: 03 00 80 68 sethi %hi(0x201a000), %g1 200e87c: 82 10 60 a4 or %g1, 0xa4, %g1 ! 201a0a4 <_POSIX_signals_Siginfo> */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200e880: f8 00 c0 01 ld [ %g3 + %g1 ], %i4 200e884: 88 00 c0 01 add %g3, %g1, %g4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200e888: 9a 01 20 04 add %g4, 4, %o5 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 200e88c: 80 a7 00 0d cmp %i4, %o5 200e890: 32 80 00 1b bne,a 200e8fc <_POSIX_signals_Clear_signals+0x14c> 200e894: c4 07 00 00 ld [ %i4 ], %g2 200e898: b8 10 20 00 clr %i4 <== NOT EXECUTED 200e89c: b6 10 20 00 clr %i3 <== NOT EXECUTED _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) _POSIX_signals_Clear_process_signals( mask ); 200e8a0: 40 00 01 f0 call 200f060 <_POSIX_signals_Clear_process_signals> 200e8a4: 90 10 00 10 mov %l0, %o0 if ( psiginfo ) { 200e8a8: 80 a7 20 00 cmp %i4, 0 200e8ac: 02 bf ff ea be 200e854 <_POSIX_signals_Clear_signals+0xa4> 200e8b0: b0 10 20 01 mov 1, %i0 *info = psiginfo->Info; 200e8b4: c2 06 e0 08 ld [ %i3 + 8 ], %g1 200e8b8: c2 26 80 00 st %g1, [ %i2 ] 200e8bc: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200e8c0: 03 00 80 68 sethi %hi(0x201a000), %g1 200e8c4: c4 26 a0 04 st %g2, [ %i2 + 4 ] 200e8c8: 82 10 60 58 or %g1, 0x58, %g1 200e8cc: c6 06 e0 10 ld [ %i3 + 0x10 ], %g3 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200e8d0: c2 26 c0 00 st %g1, [ %i3 ] old_last_node = the_chain->last; 200e8d4: 82 00 7f fc add %g1, -4, %g1 200e8d8: c4 00 60 08 ld [ %g1 + 8 ], %g2 the_chain->last = the_node; 200e8dc: f6 20 60 08 st %i3, [ %g1 + 8 ] 200e8e0: c6 26 a0 08 st %g3, [ %i2 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200e8e4: c4 26 e0 04 st %g2, [ %i3 + 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; 200e8e8: f6 20 80 00 st %i3, [ %g2 ] if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; do_callout = TRUE; } } _ISR_Enable( level ); 200e8ec: 7f ff cd 48 call 2001e0c 200e8f0: 90 10 00 11 mov %l1, %o0 return do_callout; } 200e8f4: 81 c7 e0 08 ret 200e8f8: 81 e8 00 00 restore Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; the_chain->first = new_first; 200e8fc: c4 20 c0 01 st %g2, [ %g3 + %g1 ] new_first->previous = _Chain_Head(the_chain); 200e900: c8 20 a0 04 st %g4, [ %g2 + 4 ] if ( is_global ) { if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 200e904: c2 00 c0 01 ld [ %g3 + %g1 ], %g1 200e908: 80 a3 40 01 cmp %o5, %g1 200e90c: 12 bf ff e7 bne 200e8a8 <_POSIX_signals_Clear_signals+0xf8> 200e910: b6 10 00 1c mov %i4, %i3 200e914: 30 bf ff e3 b,a 200e8a0 <_POSIX_signals_Clear_signals+0xf0> 02006908 <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 2006908: 86 10 00 08 mov %o0, %g3 200690c: 90 10 20 1b mov 0x1b, %o0 int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 2006910: 84 02 3f ff add %o0, -1, %g2 2006914: 82 10 20 01 mov 1, %g1 2006918: 83 28 40 02 sll %g1, %g2, %g1 200691c: 80 88 40 03 btst %g1, %g3 2006920: 12 80 00 11 bne 2006964 <_POSIX_signals_Get_highest+0x5c> 2006924: 01 00 00 00 nop sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 2006928: 90 02 20 01 inc %o0 200692c: 80 a2 20 20 cmp %o0, 0x20 2006930: 12 bf ff f9 bne 2006914 <_POSIX_signals_Get_highest+0xc> 2006934: 84 02 3f ff add %o0, -1, %g2 2006938: 10 80 00 05 b 200694c <_POSIX_signals_Get_highest+0x44> 200693c: 90 10 20 01 mov 1, %o0 return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 2006940: 80 a2 20 1b cmp %o0, 0x1b 2006944: 02 80 00 0a be 200696c <_POSIX_signals_Get_highest+0x64> 2006948: 01 00 00 00 nop if ( set & signo_to_mask( signo ) ) 200694c: 84 02 3f ff add %o0, -1, %g2 2006950: 82 10 20 01 mov 1, %g1 2006954: 83 28 40 02 sll %g1, %g2, %g1 2006958: 80 88 40 03 btst %g1, %g3 200695c: 22 bf ff f9 be,a 2006940 <_POSIX_signals_Get_highest+0x38> 2006960: 90 02 20 01 inc %o0 return signo; } return 0; } 2006964: 81 c3 e0 08 retl 2006968: 01 00 00 00 nop 200696c: 81 c3 e0 08 retl <== NOT EXECUTED 2006970: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED 0200cbec <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 200cbec: 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 ]; 200cbf0: e0 06 21 74 ld [ %i0 + 0x174 ], %l0 200cbf4: 23 00 80 68 sethi %hi(0x201a000), %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 ); 200cbf8: 7f ff d4 81 call 2001dfc 200cbfc: 01 00 00 00 nop 200cc00: b0 10 00 08 mov %o0, %i0 if ( !(~api->signals_blocked & 200cc04: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 200cc08: c4 04 20 c8 ld [ %l0 + 0xc8 ], %g2 200cc0c: c6 04 20 c4 ld [ %l0 + 0xc4 ], %g3 200cc10: 82 10 40 02 or %g1, %g2, %g1 200cc14: 80 a8 40 03 andncc %g1, %g3, %g0 200cc18: 02 80 00 27 be 200ccb4 <_POSIX_signals_Post_switch_extension+0xc8> 200cc1c: 01 00 00 00 nop (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); return; } _ISR_Enable( level ); 200cc20: 7f ff d4 7b call 2001e0c 200cc24: b0 10 20 1b mov 0x1b, %i0 ! 1b for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, FALSE ) ) 200cc28: 92 10 00 18 mov %i0, %o1 200cc2c: 94 10 20 00 clr %o2 200cc30: 40 00 06 ab call 200e6dc <_POSIX_signals_Check_signal> 200cc34: 90 10 00 10 mov %l0, %o0 200cc38: 80 a2 20 00 cmp %o0, 0 200cc3c: 12 bf ff ef bne 200cbf8 <_POSIX_signals_Post_switch_extension+0xc> 200cc40: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200cc44: 90 10 00 10 mov %l0, %o0 200cc48: 94 10 20 01 mov 1, %o2 200cc4c: 40 00 06 a4 call 200e6dc <_POSIX_signals_Check_signal> 200cc50: b0 06 20 01 inc %i0 200cc54: 80 a2 20 00 cmp %o0, 0 200cc58: 12 bf ff e8 bne 200cbf8 <_POSIX_signals_Post_switch_extension+0xc> 200cc5c: 80 a6 20 20 cmp %i0, 0x20 _ISR_Enable( level ); return; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 200cc60: 12 bf ff f3 bne 200cc2c <_POSIX_signals_Post_switch_extension+0x40> 200cc64: 92 10 00 18 mov %i0, %o1 200cc68: 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 ) ) 200cc6c: 92 10 00 18 mov %i0, %o1 200cc70: 94 10 20 00 clr %o2 200cc74: 40 00 06 9a call 200e6dc <_POSIX_signals_Check_signal> 200cc78: 90 10 00 10 mov %l0, %o0 200cc7c: 80 a2 20 00 cmp %o0, 0 200cc80: 12 bf ff de bne 200cbf8 <_POSIX_signals_Post_switch_extension+0xc> 200cc84: 92 10 00 18 mov %i0, %o1 goto restart; if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) 200cc88: 90 10 00 10 mov %l0, %o0 200cc8c: 94 10 20 01 mov 1, %o2 200cc90: 40 00 06 93 call 200e6dc <_POSIX_signals_Check_signal> 200cc94: b0 06 20 01 inc %i0 200cc98: 80 a2 20 00 cmp %o0, 0 200cc9c: 12 bf ff d7 bne 200cbf8 <_POSIX_signals_Post_switch_extension+0xc> 200cca0: 80 a6 20 1b cmp %i0, 0x1b } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 200cca4: 12 bf ff f3 bne 200cc70 <_POSIX_signals_Post_switch_extension+0x84> 200cca8: 92 10 00 18 mov %i0, %o1 if ( _POSIX_signals_Check_signal( api, signo, TRUE ) ) goto restart; } } 200ccac: 81 c7 e0 08 ret <== NOT EXECUTED 200ccb0: 81 e8 00 00 restore <== NOT EXECUTED restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 200ccb4: 7f ff d4 56 call 2001e0c 200ccb8: 81 e8 00 00 restore 200ccbc: 01 00 00 00 nop 02024ee4 <_POSIX_signals_Unblock_thread>: boolean _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 2024ee4: 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 ) ) { 2024ee8: c8 06 20 10 ld [ %i0 + 0x10 ], %g4 2024eec: 07 04 00 20 sethi %hi(0x10008000), %g3 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 2024ef0: 84 06 7f ff add %i1, -1, %g2 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 2024ef4: 82 09 00 03 and %g4, %g3, %g1 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 2024ef8: 9a 10 20 01 mov 1, %o5 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 2024efc: 80 a0 40 03 cmp %g1, %g3 sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; mask = signo_to_mask( signo ); 2024f00: 85 2b 40 02 sll %o5, %g2, %g2 /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 2024f04: 02 80 00 1d be 2024f78 <_POSIX_signals_Unblock_thread+0x94> 2024f08: c6 06 21 74 ld [ %i0 + 0x174 ], %g3 */ return FALSE; } if ( ~api->signals_blocked & mask ) { 2024f0c: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 2024f10: 80 a8 80 01 andncc %g2, %g1, %g0 2024f14: 02 80 00 21 be 2024f98 <_POSIX_signals_Unblock_thread+0xb4> 2024f18: 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 ) { 2024f1c: 80 89 00 01 btst %g4, %g1 2024f20: 02 80 00 1e be 2024f98 <_POSIX_signals_Unblock_thread+0xb4> 2024f24: da 26 20 78 st %o5, [ %i0 + 0x78 ] the_thread->Wait.return_code = EINTR; 2024f28: 84 10 20 04 mov 4, %g2 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 2024f2c: 03 00 00 ef sethi %hi(0x3bc00), %g1 2024f30: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2024f34: 80 89 00 01 btst %g4, %g1 2024f38: 12 80 00 29 bne 2024fdc <_POSIX_signals_Unblock_thread+0xf8> 2024f3c: c4 26 20 34 st %g2, [ %i0 + 0x34 ] _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state)){ 2024f40: 80 89 20 08 btst 8, %g4 2024f44: 02 80 00 15 be 2024f98 <_POSIX_signals_Unblock_thread+0xb4> 2024f48: 01 00 00 00 nop if ( _Watchdog_Is_active( &the_thread->Timer ) ) 2024f4c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2024f50: 80 a0 60 02 cmp %g1, 2 2024f54: 02 80 00 2b be 2025000 <_POSIX_signals_Unblock_thread+0x11c> 2024f58: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2024f5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2024f60: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2024f64: b0 10 20 00 clr %i0 2024f68: 7f ff ac a1 call 20101ec <_Thread_Clear_state> 2024f6c: 92 12 63 f8 or %o1, 0x3f8, %o1 2024f70: 81 c7 e0 08 ret 2024f74: 81 e8 00 00 restore * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 2024f78: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2024f7c: 80 88 80 01 btst %g2, %g1 2024f80: 12 80 00 08 bne 2024fa0 <_POSIX_signals_Unblock_thread+0xbc> 2024f84: 82 10 20 04 mov 4, %g1 2024f88: c2 00 e0 c4 ld [ %g3 + 0xc4 ], %g1 2024f8c: 80 a8 80 01 andncc %g2, %g1, %g0 2024f90: 12 80 00 04 bne 2024fa0 <_POSIX_signals_Unblock_thread+0xbc> 2024f94: 82 10 20 04 mov 4, %g1 } } } return FALSE; } 2024f98: 81 c7 e0 08 ret 2024f9c: 91 e8 20 00 restore %g0, 0, %o0 */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { the_thread->Wait.return_code = EINTR; 2024fa0: c2 26 20 34 st %g1, [ %i0 + 0x34 ] the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { 2024fa4: 80 a6 a0 00 cmp %i2, 0 2024fa8: 02 80 00 12 be 2024ff0 <_POSIX_signals_Unblock_thread+0x10c> 2024fac: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 2024fb0: c2 06 80 00 ld [ %i2 ], %g1 2024fb4: c2 20 c0 00 st %g1, [ %g3 ] 2024fb8: c4 06 a0 04 ld [ %i2 + 4 ], %g2 2024fbc: c4 20 e0 04 st %g2, [ %g3 + 4 ] 2024fc0: c2 06 a0 08 ld [ %i2 + 8 ], %g1 2024fc4: c2 20 e0 08 st %g1, [ %g3 + 8 ] } _Thread_queue_Extract_with_proxy( the_thread ); 2024fc8: 90 10 00 18 mov %i0, %o0 2024fcc: 7f ff af d8 call 2010f2c <_Thread_queue_Extract_with_proxy> 2024fd0: b0 10 20 01 mov 1, %i0 2024fd4: 81 c7 e0 08 ret 2024fd8: 81 e8 00 00 restore the_thread->do_post_task_switch_extension = TRUE; if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { the_thread->Wait.return_code = EINTR; if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); 2024fdc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2024fe0: 7f ff af d3 call 2010f2c <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 2024fe4: b0 10 20 00 clr %i0 <== NOT EXECUTED 2024fe8: 81 c7 e0 08 ret <== NOT EXECUTED 2024fec: 81 e8 00 00 restore <== NOT EXECUTED the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 2024ff0: f2 20 c0 00 st %i1, [ %g3 ] the_info->si_code = SI_USER; 2024ff4: da 20 e0 04 st %o5, [ %g3 + 4 ] the_info->si_value.sival_int = 0; 2024ff8: 10 bf ff f4 b 2024fc8 <_POSIX_signals_Unblock_thread+0xe4> 2024ffc: c0 20 e0 08 clr [ %g3 + 8 ] the_thread->Wait.return_code = EINTR; if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else if ( _States_Is_delaying(the_thread->current_state)){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 2025000: 7f ff b3 2f call 2011cbc <_Watchdog_Remove> 2025004: 90 06 20 48 add %i0, 0x48, %o0 2025008: 10 bf ff d6 b 2024f60 <_POSIX_signals_Unblock_thread+0x7c> 202500c: 90 10 00 18 mov %i0, %o0 020081a8 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 20081a8: 9d e3 bf 98 save %sp, -104, %sp void *p; _RTEMS_Lock_allocator(); 20081ac: 7f ff e7 14 call 2001dfc 20081b0: 01 00 00 00 nop 20081b4: a4 10 00 08 mov %o0, %l2 20081b8: 23 00 80 66 sethi %hi(0x2019800), %l1 20081bc: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 20081c0: 80 a0 60 00 cmp %g1, 0 20081c4: 02 80 00 0b be 20081f0 <_Protected_heap_Allocate+0x48> 20081c8: 27 00 80 66 sethi %hi(0x2019800), %l3 20081cc: 03 00 80 66 sethi %hi(0x2019800), %g1 20081d0: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> 20081d4: 80 a0 a0 01 cmp %g2, 1 20081d8: 08 80 00 06 bleu 20081f0 <_Protected_heap_Allocate+0x48> 20081dc: 90 10 20 00 clr %o0 20081e0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20081e4: 7f ff fd 7c call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 20081e8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20081ec: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20081f0: 09 00 80 66 sethi %hi(0x2019800), %g4 20081f4: e0 04 e1 18 ld [ %l3 + 0x118 ], %l0 20081f8: c4 01 21 20 ld [ %g4 + 0x120 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20081fc: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008200: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2008204: 80 a0 60 00 cmp %g1, 0 2008208: 22 80 00 27 be,a 20082a4 <_Protected_heap_Allocate+0xfc> 200820c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2008210: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008214: 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; 2008218: 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; 200821c: 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; 2008220: 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; 2008224: 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 ) || 2008228: 80 a0 e0 02 cmp %g3, 2 200822c: 12 80 00 2d bne 20082e0 <_Protected_heap_Allocate+0x138> 2008230: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008234: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008238: 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++; 200823c: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008240: 02 80 00 46 be 2008358 <_Protected_heap_Allocate+0x1b0> 2008244: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2008248: 7f ff e6 f1 call 2001e0c 200824c: 90 10 00 12 mov %l2, %o0 p = _Heap_Allocate( the_heap, size ); 2008250: 90 10 00 18 mov %i0, %o0 2008254: 7f ff fc 2e call 200730c <_Heap_Allocate> 2008258: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200825c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2008260: b0 10 00 08 mov %o0, %i0 2008264: 82 00 60 01 inc %g1 2008268: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _RTEMS_Unlock_allocator(); 200826c: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 2008270: 94 10 20 00 clr %o2 2008274: d2 02 20 08 ld [ %o0 + 8 ], %o1 2008278: 7f ff fb 54 call 2006fc8 <_CORE_mutex_Surrender> 200827c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008280: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2008284: 82 00 7f ff add %g1, -1, %g1 2008288: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 200828c: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 2008290: 80 a0 a0 00 cmp %g2, 0 2008294: 02 80 00 2d be 2008348 <_Protected_heap_Allocate+0x1a0> 2008298: 01 00 00 00 nop return p; } 200829c: 81 c7 e0 08 ret 20082a0: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20082a4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20082a8: 12 80 00 16 bne 2008300 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 20082ac: c6 04 e1 18 ld [ %l3 + 0x118 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20082b0: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 20082b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20082b8: 22 80 00 43 be,a 20083c4 <_Protected_heap_Allocate+0x21c> <== NOT EXECUTED 20082bc: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20082c0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20082c4: 12 80 00 0f bne 2008300 <_Protected_heap_Allocate+0x158> <== NOT EXECUTED 20082c8: 82 10 20 02 mov 2, %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; 20082cc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20082d0: 7f ff e6 cf call 2001e0c <== NOT EXECUTED 20082d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { void *p; _RTEMS_Lock_allocator(); p = _Heap_Allocate( the_heap, size ); 20082d8: 10 bf ff df b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 20082dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20082e0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20082e4: 12 bf ff d9 bne 2008248 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED 20082e8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20082ec: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20082f0: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20082f4: 02 80 00 19 be 2008358 <_Protected_heap_Allocate+0x1b0> <== NOT EXECUTED 20082f8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 20082fc: 30 bf ff d3 b,a 2008248 <_Protected_heap_Allocate+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008300: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED size_t size ) { void *p; _RTEMS_Lock_allocator(); 2008304: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008308: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 <== NOT EXECUTED 200830c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008310: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008314: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008318: 84 00 e0 10 add %g3, 0x10, %g2 <== 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; 200831c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008320: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008324: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008328: 7f ff e6 b9 call 2001e0c <== NOT EXECUTED 200832c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008330: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 2008334: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008338: 7f ff fb 00 call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200833c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 2008340: 10 bf ff c5 b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008344: 90 10 00 18 mov %i0, %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 ) _Thread_Dispatch(); 2008348: 40 00 03 d5 call 200929c <_Thread_Dispatch> 200834c: 01 00 00 00 nop 2008350: 81 c7 e0 08 ret 2008354: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008358: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200835c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008360: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008364: 02 80 00 28 be 2008404 <_Protected_heap_Allocate+0x25c> <== NOT EXECUTED 2008368: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200836c: 1a 80 00 1c bcc 20083dc <_Protected_heap_Allocate+0x234> <== NOT EXECUTED 2008370: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008374: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008378: 82 00 60 01 inc %g1 <== NOT EXECUTED 200837c: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008380: 7f ff e6 a3 call 2001e0c <== NOT EXECUTED 2008384: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008388: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200838c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008390: 40 00 02 93 call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2008394: 94 10 20 00 clr %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 ) 2008398: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 200839c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20083a0: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 20083a4: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 20083a8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20083ac: 32 bf ff aa bne,a 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 20083b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20083b4: 40 00 03 ba call 200929c <_Thread_Dispatch> <== NOT EXECUTED 20083b8: 01 00 00 00 nop <== NOT EXECUTED 20083bc: 10 bf ff a6 b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 20083c0: 90 10 00 18 mov %i0, %o0 <== 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++; 20083c4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20083c8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20083cc: 7f ff e6 90 call 2001e0c <== NOT EXECUTED 20083d0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20083d4: 10 bf ff a0 b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 20083d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20083dc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20083e0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20083e4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20083e8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20083ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20083f0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20083f4: 7f ff e6 86 call 2001e0c <== NOT EXECUTED 20083f8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20083fc: 10 bf ff 96 b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008400: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008404: 7f ff e6 82 call 2001e0c <== NOT EXECUTED 2008408: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200840c: 10 bf ff 92 b 2008254 <_Protected_heap_Allocate+0xac> <== NOT EXECUTED 2008410: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008414 <_Protected_heap_Extend>: boolean _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 2008414: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2008418: 7f ff e6 79 call 2001dfc <== NOT EXECUTED 200841c: 01 00 00 00 nop <== NOT EXECUTED 2008420: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008424: 23 00 80 66 sethi %hi(0x2019800), %l1 <== NOT EXECUTED 2008428: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200842c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008430: 02 80 00 0b be 200845c <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2008434: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED 2008438: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200843c: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> <== NOT EXECUTED 2008440: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008444: 08 80 00 06 bleu 200845c <_Protected_heap_Extend+0x48> <== NOT EXECUTED 2008448: 90 10 20 00 clr %o0 <== NOT EXECUTED 200844c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008450: 7f ff fc e1 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2008454: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008458: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200845c: 09 00 80 66 sethi %hi(0x2019800), %g4 <== NOT EXECUTED 2008460: e0 04 e1 18 ld [ %l3 + 0x118 ], %l0 <== NOT EXECUTED 2008464: c4 01 21 20 ld [ %g4 + 0x120 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008468: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200846c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008470: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008474: 22 80 00 2d be,a 2008528 <_Protected_heap_Extend+0x114> <== NOT EXECUTED 2008478: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200847c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008480: 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; 2008484: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 2008488: 88 10 20 01 mov 1, %g4 <== 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; 200848c: 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; 2008490: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008494: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008498: 12 80 00 33 bne 2008564 <_Protected_heap_Extend+0x150> <== NOT EXECUTED 200849c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20084a0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20084a4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 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++; 20084a8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20084ac: 02 80 00 48 be 20085cc <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 20084b0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20084b4: 7f ff e6 56 call 2001e0c <== NOT EXECUTED 20084b8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 20084bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20084c0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 20084c4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 20084c8: 40 00 14 82 call 200d6d0 <_Heap_Extend> <== NOT EXECUTED 20084cc: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20084d0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 20084d4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 20084d8: 82 00 60 01 inc %g1 <== NOT EXECUTED 20084dc: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 20084e0: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 20084e4: 94 10 20 00 clr %o2 <== NOT EXECUTED 20084e8: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20084ec: 7f ff fa b7 call 2006fc8 <_CORE_mutex_Surrender> <== NOT EXECUTED 20084f0: 90 02 20 10 add %o0, 0x10, %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 ) 20084f4: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 20084f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20084fc: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008500: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2008504: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008508: 12 80 00 05 bne 200851c <_Protected_heap_Extend+0x108> <== NOT EXECUTED 200850c: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 2008510: 40 00 03 63 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008514: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 2008518: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 200851c: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2008520: 81 c7 e0 08 ret <== NOT EXECUTED 2008524: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008528: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200852c: 12 80 00 16 bne 2008584 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 2008530: c6 04 e1 18 ld [ %l3 + 0x118 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008534: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008538: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200853c: 22 80 00 3f be,a 2008638 <_Protected_heap_Extend+0x224> <== NOT EXECUTED 2008540: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008544: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008548: 12 80 00 0f bne 2008584 <_Protected_heap_Extend+0x170> <== NOT EXECUTED 200854c: 82 10 20 02 mov 2, %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; 2008550: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2008554: 7f ff e6 2e call 2001e0c <== NOT EXECUTED 2008558: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 200855c: 10 bf ff d9 b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008560: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008564: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008568: 12 bf ff d3 bne 20084b4 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED 200856c: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008570: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008574: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008578: 02 80 00 15 be 20085cc <_Protected_heap_Extend+0x1b8> <== NOT EXECUTED 200857c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008580: 30 bf ff cd b,a 20084b4 <_Protected_heap_Extend+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008584: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED ) { Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 2008588: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 200858c: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 <== NOT EXECUTED 2008590: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008594: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008598: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 200859c: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20085a0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20085a4: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 20085a8: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 20085ac: 7f ff e6 18 call 2001e0c <== NOT EXECUTED 20085b0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20085b4: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 20085b8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20085bc: 7f ff fa 5f call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20085c0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 20085c4: 10 bf ff bf b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 20085c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20085cc: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 20085d0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20085d4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20085d8: 02 80 00 28 be 2008678 <_Protected_heap_Extend+0x264> <== NOT EXECUTED 20085dc: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 20085e0: 1a 80 00 1c bcc 2008650 <_Protected_heap_Extend+0x23c> <== NOT EXECUTED 20085e4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 20085e8: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 20085ec: 82 00 60 01 inc %g1 <== NOT EXECUTED 20085f0: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20085f4: 7f ff e6 06 call 2001e0c <== NOT EXECUTED 20085f8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 20085fc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008600: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008604: 40 00 01 f6 call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2008608: 94 10 20 00 clr %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 ) 200860c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008610: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008614: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008618: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 200861c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008620: 32 bf ff a8 bne,a 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008624: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008628: 40 00 03 1d call 200929c <_Thread_Dispatch> <== NOT EXECUTED 200862c: 01 00 00 00 nop <== NOT EXECUTED 2008630: 10 bf ff a4 b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008634: 90 10 00 18 mov %i0, %o0 <== 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++; 2008638: 82 00 60 01 inc %g1 <== NOT EXECUTED 200863c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008640: 7f ff e5 f3 call 2001e0c <== NOT EXECUTED 2008644: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008648: 10 bf ff 9e b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 200864c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008650: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008654: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008658: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200865c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008660: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008664: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008668: 7f ff e5 e9 call 2001e0c <== NOT EXECUTED 200866c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008670: 10 bf ff 94 b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008674: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008678: 7f ff e5 e5 call 2001e0c <== NOT EXECUTED 200867c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008680: 10 bf ff 90 b 20084c0 <_Protected_heap_Extend+0xac> <== NOT EXECUTED 2008684: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008688 <_Protected_heap_Free>: boolean _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 2008688: 9d e3 bf 98 save %sp, -104, %sp boolean status; _RTEMS_Lock_allocator(); 200868c: 7f ff e5 dc call 2001dfc 2008690: 01 00 00 00 nop 2008694: a4 10 00 08 mov %o0, %l2 2008698: 23 00 80 66 sethi %hi(0x2019800), %l1 200869c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 20086a0: 80 a0 60 00 cmp %g1, 0 20086a4: 02 80 00 0b be 20086d0 <_Protected_heap_Free+0x48> 20086a8: 27 00 80 66 sethi %hi(0x2019800), %l3 20086ac: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 20086b0: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> <== NOT EXECUTED 20086b4: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20086b8: 08 80 00 06 bleu 20086d0 <_Protected_heap_Free+0x48> <== NOT EXECUTED 20086bc: 90 10 20 00 clr %o0 <== NOT EXECUTED 20086c0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20086c4: 7f ff fc 44 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 20086c8: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20086cc: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20086d0: 09 00 80 66 sethi %hi(0x2019800), %g4 20086d4: e0 04 e1 18 ld [ %l3 + 0x118 ], %l0 20086d8: c4 01 21 20 ld [ %g4 + 0x120 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20086dc: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20086e0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20086e4: 80 a0 60 00 cmp %g1, 0 20086e8: 22 80 00 27 be,a 2008784 <_Protected_heap_Free+0xfc> 20086ec: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20086f0: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20086f4: 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; 20086f8: 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; 20086fc: 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; 2008700: 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; 2008704: 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 ) || 2008708: 80 a0 e0 02 cmp %g3, 2 200870c: 12 80 00 2d bne 20087c0 <_Protected_heap_Free+0x138> 2008710: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008714: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008718: 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++; 200871c: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008720: 02 80 00 46 be 2008838 <_Protected_heap_Free+0x1b0> 2008724: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 2008728: 7f ff e5 b9 call 2001e0c 200872c: 90 10 00 12 mov %l2, %o0 status = _Heap_Free( the_heap, start_address ); 2008730: 90 10 00 18 mov %i0, %o0 2008734: 7f ff fb 28 call 20073d4 <_Heap_Free> 2008738: 92 10 00 19 mov %i1, %o1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200873c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2008740: b0 10 00 08 mov %o0, %i0 2008744: 82 00 60 01 inc %g1 2008748: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _RTEMS_Unlock_allocator(); 200874c: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 2008750: 94 10 20 00 clr %o2 2008754: d2 02 20 08 ld [ %o0 + 8 ], %o1 2008758: 7f ff fa 1c call 2006fc8 <_CORE_mutex_Surrender> 200875c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008760: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2008764: 82 00 7f ff add %g1, -1, %g1 2008768: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 200876c: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 2008770: 80 a0 a0 00 cmp %g2, 0 2008774: 02 80 00 2d be 2008828 <_Protected_heap_Free+0x1a0> 2008778: 01 00 00 00 nop return status; } 200877c: 81 c7 e0 08 ret <== NOT EXECUTED 2008780: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008784: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008788: 12 80 00 16 bne 20087e0 <_Protected_heap_Free+0x158> <== NOT EXECUTED 200878c: c6 04 e1 18 ld [ %l3 + 0x118 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008790: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008794: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008798: 22 80 00 43 be,a 20088a4 <_Protected_heap_Free+0x21c> <== NOT EXECUTED 200879c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 20087a0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20087a4: 12 80 00 0f bne 20087e0 <_Protected_heap_Free+0x158> <== NOT EXECUTED 20087a8: 82 10 20 02 mov 2, %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; 20087ac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20087b0: 7f ff e5 97 call 2001e0c <== NOT EXECUTED 20087b4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Free( the_heap, start_address ); 20087b8: 10 bf ff df b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20087bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20087c0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20087c4: 12 bf ff d9 bne 2008728 <_Protected_heap_Free+0xa0> <== NOT EXECUTED 20087c8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20087cc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20087d0: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20087d4: 02 80 00 19 be 2008838 <_Protected_heap_Free+0x1b0> <== NOT EXECUTED 20087d8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 20087dc: 30 bf ff d3 b,a 2008728 <_Protected_heap_Free+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20087e0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED void *start_address ) { boolean status; _RTEMS_Lock_allocator(); 20087e4: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 20087e8: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 <== NOT EXECUTED 20087ec: 82 00 60 01 inc %g1 <== NOT EXECUTED 20087f0: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 20087f4: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 20087f8: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20087fc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008800: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008804: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008808: 7f ff e5 81 call 2001e0c <== NOT EXECUTED 200880c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008810: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 2008814: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008818: 7f ff f9 c8 call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200881c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 2008820: 10 bf ff c5 b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 2008824: 90 10 00 18 mov %i0, %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 ) _Thread_Dispatch(); 2008828: 40 00 02 9d call 200929c <_Thread_Dispatch> 200882c: 01 00 00 00 nop 2008830: 81 c7 e0 08 ret 2008834: 81 e8 00 00 restore */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008838: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200883c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008840: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008844: 02 80 00 28 be 20088e4 <_Protected_heap_Free+0x25c> <== NOT EXECUTED 2008848: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200884c: 1a 80 00 1c bcc 20088bc <_Protected_heap_Free+0x234> <== NOT EXECUTED 2008850: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008854: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008858: 82 00 60 01 inc %g1 <== NOT EXECUTED 200885c: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008860: 7f ff e5 6b call 2001e0c <== NOT EXECUTED 2008864: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008868: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200886c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008870: 40 00 01 5b call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2008874: 94 10 20 00 clr %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 ) 2008878: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 200887c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008880: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008884: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2008888: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200888c: 32 bf ff aa bne,a 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 2008890: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008894: 40 00 02 82 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008898: 01 00 00 00 nop <== NOT EXECUTED 200889c: 10 bf ff a6 b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20088a0: 90 10 00 18 mov %i0, %o0 <== 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++; 20088a4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20088a8: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20088ac: 7f ff e5 58 call 2001e0c <== NOT EXECUTED 20088b0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20088b4: 10 bf ff a0 b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20088b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20088bc: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20088c0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20088c4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20088c8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20088cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20088d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 20088d4: 7f ff e5 4e call 2001e0c <== NOT EXECUTED 20088d8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20088dc: 10 bf ff 96 b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20088e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 20088e4: 7f ff e5 4a call 2001e0c <== NOT EXECUTED 20088e8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20088ec: 10 bf ff 92 b 2008734 <_Protected_heap_Free+0xac> <== NOT EXECUTED 20088f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 020088f4 <_Protected_heap_Get_block_size>: boolean _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 20088f4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED boolean status; _RTEMS_Lock_allocator(); 20088f8: 7f ff e5 41 call 2001dfc <== NOT EXECUTED 20088fc: 01 00 00 00 nop <== NOT EXECUTED 2008900: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008904: 23 00 80 66 sethi %hi(0x2019800), %l1 <== NOT EXECUTED 2008908: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200890c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008910: 02 80 00 0b be 200893c <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 2008914: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED 2008918: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200891c: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> <== NOT EXECUTED 2008920: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008924: 08 80 00 06 bleu 200893c <_Protected_heap_Get_block_size+0x48> <== NOT EXECUTED 2008928: 90 10 20 00 clr %o0 <== NOT EXECUTED 200892c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008930: 7f ff fb a9 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2008934: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008938: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200893c: 09 00 80 66 sethi %hi(0x2019800), %g4 <== NOT EXECUTED 2008940: e0 04 e1 18 ld [ %l3 + 0x118 ], %l0 <== NOT EXECUTED 2008944: c4 01 21 20 ld [ %g4 + 0x120 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008948: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200894c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008950: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008954: 22 80 00 28 be,a 20089f4 <_Protected_heap_Get_block_size+0x100> <== NOT EXECUTED 2008958: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200895c: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008960: 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; 2008964: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 2008968: 88 10 20 01 mov 1, %g4 <== 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; 200896c: 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; 2008970: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008974: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008978: 12 80 00 2e bne 2008a30 <_Protected_heap_Get_block_size+0x13c> <== NOT EXECUTED 200897c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008980: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008984: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 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++; 2008988: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200898c: 02 80 00 47 be 2008aa8 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 2008990: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008994: 7f ff e5 1e call 2001e0c <== NOT EXECUTED 2008998: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 200899c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20089a0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 20089a4: 40 00 14 0c call 200d9d4 <_Heap_Size_of_user_area> <== NOT EXECUTED 20089a8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20089ac: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 20089b0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 20089b4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20089b8: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 20089bc: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 20089c0: 94 10 20 00 clr %o2 <== NOT EXECUTED 20089c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20089c8: 7f ff f9 80 call 2006fc8 <_CORE_mutex_Surrender> <== NOT EXECUTED 20089cc: 90 02 20 10 add %o0, 0x10, %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 ) 20089d0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 20089d4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20089d8: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 20089dc: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 20089e0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20089e4: 02 80 00 2d be 2008a98 <_Protected_heap_Get_block_size+0x1a4> <== NOT EXECUTED 20089e8: 01 00 00 00 nop <== NOT EXECUTED return status; } 20089ec: 81 c7 e0 08 ret <== NOT EXECUTED 20089f0: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20089f4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20089f8: 12 80 00 16 bne 2008a50 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 20089fc: c6 04 e1 18 ld [ %l3 + 0x118 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008a00: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008a04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008a08: 22 80 00 43 be,a 2008b14 <_Protected_heap_Get_block_size+0x220> <== NOT EXECUTED 2008a0c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008a10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008a14: 12 80 00 0f bne 2008a50 <_Protected_heap_Get_block_size+0x15c> <== NOT EXECUTED 2008a18: 82 10 20 02 mov 2, %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; 2008a1c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2008a20: 7f ff e4 fb call 2001e0c <== NOT EXECUTED 2008a24: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED ) { boolean status; _RTEMS_Lock_allocator(); status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008a28: 10 bf ff de b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008a30: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008a34: 12 bf ff d8 bne 2008994 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED 2008a38: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008a3c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008a40: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008a44: 02 80 00 19 be 2008aa8 <_Protected_heap_Get_block_size+0x1b4> <== NOT EXECUTED 2008a48: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008a4c: 30 bf ff d2 b,a 2008994 <_Protected_heap_Get_block_size+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008a50: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED size_t *size ) { boolean status; _RTEMS_Lock_allocator(); 2008a54: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008a58: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 <== NOT EXECUTED 2008a5c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008a60: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008a64: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008a68: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2008a6c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008a70: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008a74: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008a78: 7f ff e4 e5 call 2001e0c <== NOT EXECUTED 2008a7c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008a80: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 2008a84: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008a88: 7f ff f9 2c call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008a8c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 2008a90: 10 bf ff c4 b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008a94: 90 10 00 18 mov %i0, %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 ) _Thread_Dispatch(); 2008a98: 40 00 02 01 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008a9c: 01 00 00 00 nop <== NOT EXECUTED 2008aa0: 81 c7 e0 08 ret <== NOT EXECUTED 2008aa4: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008aa8: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2008aac: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008ab0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008ab4: 02 80 00 28 be 2008b54 <_Protected_heap_Get_block_size+0x260> <== NOT EXECUTED 2008ab8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2008abc: 1a 80 00 1c bcc 2008b2c <_Protected_heap_Get_block_size+0x238> <== NOT EXECUTED 2008ac0: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008ac4: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008ac8: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008acc: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008ad0: 7f ff e4 cf call 2001e0c <== NOT EXECUTED 2008ad4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008ad8: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008adc: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008ae0: 40 00 00 bf call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2008ae4: 94 10 20 00 clr %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 ) 2008ae8: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008aec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008af0: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008af4: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2008af8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008afc: 32 bf ff a9 bne,a 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008b00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008b04: 40 00 01 e6 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008b08: 01 00 00 00 nop <== NOT EXECUTED 2008b0c: 10 bf ff a5 b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008b10: 90 10 00 18 mov %i0, %o0 <== 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++; 2008b14: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008b18: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008b1c: 7f ff e4 bc call 2001e0c <== NOT EXECUTED 2008b20: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008b24: 10 bf ff 9f b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008b28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008b2c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008b30: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008b34: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008b38: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008b3c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008b40: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008b44: 7f ff e4 b2 call 2001e0c <== NOT EXECUTED 2008b48: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008b4c: 10 bf ff 95 b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008b50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008b54: 7f ff e4 ae call 2001e0c <== NOT EXECUTED 2008b58: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008b5c: 10 bf ff 91 b 20089a0 <_Protected_heap_Get_block_size+0xac> <== NOT EXECUTED 2008b60: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 0200b384 <_Protected_heap_Get_free_information>: void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 200b384: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _RTEMS_Lock_allocator(); 200b388: 7f ff de 61 call 2002d0c <== NOT EXECUTED 200b38c: 01 00 00 00 nop <== NOT EXECUTED 200b390: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 200b394: 23 00 80 f5 sethi %hi(0x203d400), %l1 <== NOT EXECUTED 200b398: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 ! 203d600 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200b39c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b3a0: 02 80 00 0b be 200b3cc <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200b3a4: 27 00 80 f5 sethi %hi(0x203d400), %l3 <== NOT EXECUTED 200b3a8: 03 00 80 f5 sethi %hi(0x203d400), %g1 <== NOT EXECUTED 200b3ac: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 203d7e0 <_System_state_Current> <== NOT EXECUTED 200b3b0: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 200b3b4: 08 80 00 06 bleu 200b3cc <_Protected_heap_Get_free_information+0x48> <== NOT EXECUTED 200b3b8: 90 10 20 00 clr %o0 <== NOT EXECUTED 200b3bc: 92 10 20 00 clr %o1 <== NOT EXECUTED 200b3c0: 7f ff fb 49 call 200a0e4 <_Internal_error_Occurred> <== NOT EXECUTED 200b3c4: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 200b3c8: 27 00 80 f5 sethi %hi(0x203d400), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 200b3cc: 09 00 80 f5 sethi %hi(0x203d400), %g4 <== NOT EXECUTED 200b3d0: e0 04 e2 d8 ld [ %l3 + 0x2d8 ], %l0 <== NOT EXECUTED 200b3d4: c4 01 22 e0 ld [ %g4 + 0x2e0 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 200b3d8: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 200b3dc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 200b3e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b3e4: 22 80 00 26 be,a 200b47c <_Protected_heap_Get_free_information+0xf8> <== NOT EXECUTED 200b3e8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 200b3ec: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 200b3f0: 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; 200b3f4: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 200b3f8: 88 10 20 01 mov 1, %g4 <== 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; 200b3fc: 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; 200b400: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200b404: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 200b408: 12 80 00 2c bne 200b4b8 <_Protected_heap_Get_free_information+0x134> <== NOT EXECUTED 200b40c: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200b410: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b414: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 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++; 200b418: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b41c: 02 80 00 43 be 200b528 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 200b420: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200b424: 7f ff de 3e call 2002d1c <== NOT EXECUTED 200b428: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200b42c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200b430: 40 00 3c 8b call 201a65c <_Heap_Get_free_information> <== NOT EXECUTED 200b434: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b438: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 <== NOT EXECUTED 200b43c: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b440: c2 24 62 00 st %g1, [ %l1 + 0x200 ] <== NOT EXECUTED _RTEMS_Unlock_allocator(); 200b444: d0 04 e2 d8 ld [ %l3 + 0x2d8 ], %o0 <== NOT EXECUTED 200b448: 94 10 20 00 clr %o2 <== NOT EXECUTED 200b44c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 200b450: 7f ff f9 22 call 20098d8 <_CORE_mutex_Surrender> <== NOT EXECUTED 200b454: 90 02 20 10 add %o0, 0x10, %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 ) 200b458: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 <== NOT EXECUTED 200b45c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b460: c2 24 62 00 st %g1, [ %l1 + 0x200 ] <== NOT EXECUTED 200b464: c4 04 62 00 ld [ %l1 + 0x200 ], %g2 <== NOT EXECUTED 200b468: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b46c: 02 80 00 2d be 200b520 <_Protected_heap_Get_free_information+0x19c> <== NOT EXECUTED 200b470: 01 00 00 00 nop <== NOT EXECUTED 200b474: 81 c7 e0 08 ret <== NOT EXECUTED 200b478: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 200b47c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200b480: 12 80 00 16 bne 200b4d8 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 200b484: c6 04 e2 d8 ld [ %l3 + 0x2d8 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 200b488: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 200b48c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b490: 22 80 00 41 be,a 200b594 <_Protected_heap_Get_free_information+0x210> <== NOT EXECUTED 200b494: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 200b498: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200b49c: 12 80 00 0f bne 200b4d8 <_Protected_heap_Get_free_information+0x154> <== NOT EXECUTED 200b4a0: 82 10 20 02 mov 2, %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; 200b4a4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 200b4a8: 7f ff de 1d call 2002d1c <== NOT EXECUTED 200b4ac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); _Heap_Get_free_information( the_heap, info ); 200b4b0: 10 bf ff e0 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b4b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 200b4b8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 200b4bc: 12 bf ff da bne 200b424 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED 200b4c0: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 200b4c4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200b4c8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 200b4cc: 02 80 00 17 be 200b528 <_Protected_heap_Get_free_information+0x1a4> <== NOT EXECUTED 200b4d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 200b4d4: 30 bf ff d4 b,a 200b424 <_Protected_heap_Get_free_information+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b4d8: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 <== NOT EXECUTED void _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { _RTEMS_Lock_allocator(); 200b4dc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 200b4e0: c8 01 22 e0 ld [ %g4 + 0x2e0 ], %g4 <== NOT EXECUTED 200b4e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b4e8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 200b4ec: c2 24 62 00 st %g1, [ %l1 + 0x200 ] <== NOT EXECUTED 200b4f0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 200b4f4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 200b4f8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 200b4fc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 200b500: 7f ff de 07 call 2002d1c <== NOT EXECUTED 200b504: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b508: d0 04 e2 d8 ld [ %l3 + 0x2d8 ], %o0 <== NOT EXECUTED 200b50c: 92 10 20 00 clr %o1 <== NOT EXECUTED 200b510: 7f ff f8 ce call 2009848 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 200b514: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 200b518: 10 bf ff c6 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b51c: 90 10 00 18 mov %i0, %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 ) _Thread_Dispatch(); 200b520: 40 00 01 ff call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 200b524: 81 e8 00 00 restore <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 200b528: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 200b52c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 200b530: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200b534: 02 80 00 28 be 200b5d4 <_Protected_heap_Get_free_information+0x250> <== NOT EXECUTED 200b538: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 200b53c: 1a 80 00 1c bcc 200b5ac <_Protected_heap_Get_free_information+0x228> <== NOT EXECUTED 200b540: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b544: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 <== NOT EXECUTED 200b548: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b54c: c2 24 62 00 st %g1, [ %l1 + 0x200 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 200b550: 7f ff dd f3 call 2002d1c <== NOT EXECUTED 200b554: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 200b558: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 200b55c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 200b560: 40 00 00 bf call 200b85c <_Thread_Change_priority> <== NOT EXECUTED 200b564: 94 10 20 00 clr %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 ) 200b568: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 <== NOT EXECUTED 200b56c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b570: c2 24 62 00 st %g1, [ %l1 + 0x200 ] <== NOT EXECUTED 200b574: c4 04 62 00 ld [ %l1 + 0x200 ], %g2 <== NOT EXECUTED 200b578: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b57c: 32 bf ff ad bne,a 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b580: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200b584: 40 00 01 e6 call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 200b588: 01 00 00 00 nop <== NOT EXECUTED 200b58c: 10 bf ff a9 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b590: 90 10 00 18 mov %i0, %o0 <== 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++; 200b594: 82 00 60 01 inc %g1 <== NOT EXECUTED 200b598: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 200b59c: 7f ff dd e0 call 2002d1c <== NOT EXECUTED 200b5a0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b5a4: 10 bf ff a3 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b5a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 200b5ac: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 200b5b0: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200b5b4: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 200b5b8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 200b5bc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b5c0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200b5c4: 7f ff dd d6 call 2002d1c <== NOT EXECUTED 200b5c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b5cc: 10 bf ff 99 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b5d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 200b5d4: 7f ff dd d2 call 2002d1c <== NOT EXECUTED 200b5d8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 200b5dc: 10 bf ff 95 b 200b430 <_Protected_heap_Get_free_information+0xac> <== NOT EXECUTED 200b5e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 02008b64 <_Protected_heap_Resize_block>: boolean _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 2008b64: 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(); 2008b68: 7f ff e4 a5 call 2001dfc <== NOT EXECUTED 2008b6c: 01 00 00 00 nop <== NOT EXECUTED 2008b70: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2008b74: 23 00 80 66 sethi %hi(0x2019800), %l1 <== NOT EXECUTED 2008b78: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008b7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008b80: 02 80 00 0b be 2008bac <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 2008b84: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED 2008b88: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 2008b8c: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> <== NOT EXECUTED 2008b90: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2008b94: 08 80 00 06 bleu 2008bac <_Protected_heap_Resize_block+0x48> <== NOT EXECUTED 2008b98: 90 10 20 00 clr %o0 <== NOT EXECUTED 2008b9c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008ba0: 7f ff fb 0d call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2008ba4: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2008ba8: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2008bac: 09 00 80 66 sethi %hi(0x2019800), %g4 <== NOT EXECUTED 2008bb0: e0 04 e1 18 ld [ %l3 + 0x118 ], %l0 <== NOT EXECUTED 2008bb4: c4 01 21 20 ld [ %g4 + 0x120 ], %g2 <== NOT EXECUTED executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2008bb8: c0 20 a0 34 clr [ %g2 + 0x34 ] <== NOT EXECUTED if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2008bbc: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2008bc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008bc4: 22 80 00 2e be,a 2008c7c <_Protected_heap_Resize_block+0x118> <== NOT EXECUTED 2008bc8: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2008bcc: c0 24 20 60 clr [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2008bd0: 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; 2008bd4: c6 04 20 58 ld [ %l0 + 0x58 ], %g3 <== NOT EXECUTED 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; 2008bd8: 88 10 20 01 mov 1, %g4 <== 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; 2008bdc: 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; 2008be0: c4 24 20 6c st %g2, [ %l0 + 0x6c ] <== NOT EXECUTED the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008be4: 80 a0 e0 02 cmp %g3, 2 <== NOT EXECUTED 2008be8: 12 80 00 34 bne 2008cb8 <_Protected_heap_Resize_block+0x154> <== NOT EXECUTED 2008bec: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008bf0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008bf4: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 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++; 2008bf8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008bfc: 02 80 00 49 be 2008d20 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 2008c00: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008c04: 7f ff e4 82 call 2001e0c <== NOT EXECUTED 2008c08: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 2008c0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008c10: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008c14: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008c18: 96 07 bf f4 add %fp, -12, %o3 <== NOT EXECUTED 2008c1c: 40 00 12 e0 call 200d79c <_Heap_Resize_block> <== NOT EXECUTED 2008c20: 98 07 bf f0 add %fp, -16, %o4 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008c24: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008c28: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2008c2c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008c30: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 2008c34: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 2008c38: 94 10 20 00 clr %o2 <== NOT EXECUTED 2008c3c: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2008c40: 7f ff f8 e2 call 2006fc8 <_CORE_mutex_Surrender> <== NOT EXECUTED 2008c44: 90 02 20 10 add %o0, 0x10, %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 ) 2008c48: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008c4c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008c50: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008c54: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2008c58: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008c5c: 12 80 00 05 bne 2008c70 <_Protected_heap_Resize_block+0x10c> <== NOT EXECUTED 2008c60: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED _Thread_Dispatch(); 2008c64: 40 00 01 8e call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008c68: 01 00 00 00 nop <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 2008c6c: 80 a0 00 10 cmp %g0, %l0 <== NOT EXECUTED 2008c70: b0 60 3f ff subx %g0, -1, %i0 <== NOT EXECUTED 2008c74: 81 c7 e0 08 ret <== NOT EXECUTED 2008c78: 81 e8 00 00 restore <== NOT EXECUTED /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2008c7c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2008c80: 12 80 00 16 bne 2008cd8 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 2008c84: c6 04 e1 18 ld [ %l3 + 0x118 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2008c88: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2008c8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008c90: 22 80 00 3f be,a 2008d8c <_Protected_heap_Resize_block+0x228> <== NOT EXECUTED 2008c94: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2008c98: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008c9c: 12 80 00 0f bne 2008cd8 <_Protected_heap_Resize_block+0x174> <== NOT EXECUTED 2008ca0: 82 10 20 02 mov 2, %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; 2008ca4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2008ca8: 7f ff e4 59 call 2001e0c <== NOT EXECUTED 2008cac: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); status = _Heap_Resize_block( 2008cb0: 10 bf ff d8 b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008cb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2008cb8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2008cbc: 12 bf ff d2 bne 2008c04 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED 2008cc0: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2008cc4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008cc8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2008ccc: 02 80 00 15 be 2008d20 <_Protected_heap_Resize_block+0x1bc> <== NOT EXECUTED 2008cd0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2008cd4: 30 bf ff cc b,a 2008c04 <_Protected_heap_Resize_block+0xa0> <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008cd8: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED { Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 2008cdc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2008ce0: c8 01 21 20 ld [ %g4 + 0x120 ], %g4 <== NOT EXECUTED 2008ce4: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008ce8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2008cec: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008cf0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2008cf4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2008cf8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2008cfc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2008d00: 7f ff e4 43 call 2001e0c <== NOT EXECUTED 2008d04: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008d08: d0 04 e1 18 ld [ %l3 + 0x118 ], %o0 <== NOT EXECUTED 2008d0c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2008d10: 7f ff f8 8a call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2008d14: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED status = _Heap_Resize_block( 2008d18: 10 bf ff be b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008d1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2008d20: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2008d24: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2008d28: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2008d2c: 02 80 00 28 be 2008dcc <_Protected_heap_Resize_block+0x268> <== NOT EXECUTED 2008d30: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2008d34: 1a 80 00 1c bcc 2008da4 <_Protected_heap_Resize_block+0x240> <== NOT EXECUTED 2008d38: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED 2008d3c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008d40: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008d44: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2008d48: 7f ff e4 31 call 2001e0c <== NOT EXECUTED 2008d4c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2008d50: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2008d54: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2008d58: 40 00 00 21 call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2008d5c: 94 10 20 00 clr %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 ) 2008d60: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2008d64: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008d68: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2008d6c: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2008d70: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2008d74: 32 bf ff a7 bne,a 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008d78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008d7c: 40 00 01 48 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2008d80: 01 00 00 00 nop <== NOT EXECUTED 2008d84: 10 bf ff a3 b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008d88: 90 10 00 18 mov %i0, %o0 <== 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++; 2008d8c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008d90: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2008d94: 7f ff e4 1e call 2001e0c <== NOT EXECUTED 2008d98: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008d9c: 10 bf ff 9d b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008da0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2008da4: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2008da8: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2008dac: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2008db0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2008db4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2008db8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2008dbc: 7f ff e4 14 call 2001e0c <== NOT EXECUTED 2008dc0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008dc4: 10 bf ff 93 b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008dc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2008dcc: 7f ff e4 10 call 2001e0c <== NOT EXECUTED 2008dd0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2008dd4: 10 bf ff 8f b 2008c10 <_Protected_heap_Resize_block+0xac> <== NOT EXECUTED 2008dd8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 0200d480 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 200d480: 9d e3 bf 98 save %sp, -104, %sp /* * Free per task variable memory */ tvp = deleted->task_variables; 200d484: e0 06 61 80 ld [ %i1 + 0x180 ], %l0 deleted->task_variables = NULL; 200d488: c0 26 61 80 clr [ %i1 + 0x180 ] while (tvp) { 200d48c: 80 a4 20 00 cmp %l0, 0 200d490: 02 80 00 25 be 200d524 <_RTEMS_tasks_Delete_extension+0xa4> 200d494: 29 00 80 66 sethi %hi(0x2019800), %l4 200d498: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED 200d49c: 10 80 00 12 b 200d4e4 <_RTEMS_tasks_Delete_extension+0x64> <== NOT EXECUTED 200d4a0: a4 15 20 8c or %l4, 0x8c, %l2 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { if (tvp->dtor) 200d4a4: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED 200d4a8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200d4ac: 22 80 00 06 be,a 200d4c4 <_RTEMS_tasks_Delete_extension+0x44> <== NOT EXECUTED 200d4b0: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED (*tvp->dtor)(*tvp->ptr); 200d4b4: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 200d4b8: 9f c0 80 00 call %g2 <== NOT EXECUTED 200d4bc: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 200d4c0: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200d4c4: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200d4c8: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 200d4cc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200d4d0: 7f ff e7 c1 call 20073d4 <_Heap_Free> <== NOT EXECUTED 200d4d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200d4d8: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 200d4dc: 22 80 00 13 be,a 200d528 <_RTEMS_tasks_Delete_extension+0xa8> <== NOT EXECUTED 200d4e0: d2 06 61 70 ld [ %i1 + 0x170 ], %o1 <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(deleted)) { 200d4e4: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED 200d4e8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200d4ec: 02 bf ff ee be 200d4a4 <_RTEMS_tasks_Delete_extension+0x24> <== NOT EXECUTED 200d4f0: e2 04 00 00 ld [ %l0 ], %l1 <== NOT EXECUTED if (tvp->dtor) (*tvp->dtor)(*tvp->ptr); *tvp->ptr = tvp->gval; } else { if (tvp->dtor) 200d4f4: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 200d4f8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200d4fc: 02 bf ff f5 be 200d4d0 <_RTEMS_tasks_Delete_extension+0x50> <== NOT EXECUTED 200d500: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 200d504: 9f c0 40 00 call %g1 <== NOT EXECUTED 200d508: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 200d50c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200d510: 7f ff e7 b1 call 20073d4 <_Heap_Free> <== NOT EXECUTED 200d514: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 200d518: a0 94 60 00 orcc %l1, 0, %l0 <== NOT EXECUTED 200d51c: 12 bf ff f3 bne 200d4e8 <_RTEMS_tasks_Delete_extension+0x68> <== NOT EXECUTED 200d520: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED 200d524: d2 06 61 70 ld [ %i1 + 0x170 ], %o1 200d528: 7f ff e7 ab call 20073d4 <_Heap_Free> 200d52c: 90 15 20 8c or %l4, 0x8c, %o0 /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 200d530: c0 26 61 70 clr [ %i1 + 0x170 ] } 200d534: 81 c7 e0 08 ret 200d538: 81 e8 00 00 restore 02006590 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 2006590: 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; 2006594: 03 00 80 66 sethi %hi(0x2019800), %g1 2006598: c4 00 61 04 ld [ %g1 + 0x104 ], %g2 ! 2019904 <_Configuration_Table> 200659c: c6 00 a0 2c ld [ %g2 + 0x2c ], %g3 /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 20065a0: d0 00 e0 28 ld [ %g3 + 0x28 ], %o0 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) 20065a4: 80 a2 20 00 cmp %o0, 0 20065a8: 02 80 00 2f be 2006664 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 20065ac: e4 00 e0 24 ld [ %g3 + 0x24 ], %l2 20065b0: 80 a4 a0 00 cmp %l2, 0 20065b4: 02 80 00 2c be 2006664 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 20065b8: a0 10 00 08 mov %o0, %l0 return; for ( index=0 ; index < maximum ; index++ ) { 20065bc: a2 10 20 00 clr %l1 20065c0: 10 80 00 0c b 20065f0 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> 20065c4: a6 07 bf f4 add %fp, -12, %l3 ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 20065c8: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 20065cc: d0 07 bf f4 ld [ %fp + -12 ], %o0 20065d0: 40 00 00 27 call 200666c 20065d4: a2 04 60 01 inc %l1 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 20065d8: 80 a2 20 00 cmp %o0, 0 20065dc: 12 80 00 1c bne 200664c <_RTEMS_tasks_Initialize_user_tasks_body+0xbc> 20065e0: 94 10 00 08 mov %o0, %o2 maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 20065e4: 80 a4 40 12 cmp %l1, %l2 20065e8: 02 80 00 1f be 2006664 <_RTEMS_tasks_Initialize_user_tasks_body+0xd4> 20065ec: a0 04 20 1c add %l0, 0x1c, %l0 return_value = rtems_task_create( 20065f0: d6 04 20 14 ld [ %l0 + 0x14 ], %o3 20065f4: d8 04 20 0c ld [ %l0 + 0xc ], %o4 20065f8: d2 04 20 08 ld [ %l0 + 8 ], %o1 20065fc: d4 04 20 04 ld [ %l0 + 4 ], %o2 2006600: d0 04 00 00 ld [ %l0 ], %o0 2006604: 7f ff ff 1b call 2006270 2006608: 9a 10 00 13 mov %l3, %o5 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 200660c: 80 a2 20 00 cmp %o0, 0 2006610: 22 bf ff ee be,a 20065c8 <_RTEMS_tasks_Initialize_user_tasks_body+0x38> 2006614: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 2006618: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200661c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006620: 40 00 04 6d call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2006624: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED return_value = rtems_task_start( 2006628: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 200662c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2 <== NOT EXECUTED 2006630: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 2006634: 40 00 00 0e call 200666c <== NOT EXECUTED 2006638: a2 04 60 01 inc %l1 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 200663c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006640: 02 bf ff ea be 20065e8 <_RTEMS_tasks_Initialize_user_tasks_body+0x58> <== NOT EXECUTED 2006644: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 2006648: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 200664c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006650: 40 00 04 61 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2006654: 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++ ) { 2006658: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 200665c: 12 bf ff e5 bne 20065f0 <_RTEMS_tasks_Initialize_user_tasks_body+0x60> <== NOT EXECUTED 2006660: a0 04 20 1c add %l0, 0x1c, %l0 <== NOT EXECUTED 2006664: 81 c7 e0 08 ret 2006668: 81 e8 00 00 restore 02007254 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 2007254: 9d e3 bf 90 save %sp, -112, %sp 2007258: 11 00 80 79 sethi %hi(0x201e400), %o0 200725c: 92 10 00 18 mov %i0, %o1 2007260: 90 12 22 34 or %o0, 0x234, %o0 2007264: 40 00 09 cc call 2009994 <_Objects_Get> 2007268: 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 ) { 200726c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007270: 80 a0 60 00 cmp %g1, 0 2007274: 12 80 00 11 bne 20072b8 <_Rate_monotonic_Timeout+0x64> 2007278: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: /* impossible */ case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; 200727c: d0 02 20 50 ld [ %o0 + 0x50 ], %o0 if ( _States_Is_waiting_for_period( the_thread->current_state ) && 2007280: 03 00 00 10 sethi %hi(0x4000), %g1 2007284: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2007288: 80 88 80 01 btst %g2, %g1 200728c: 32 80 00 0d bne,a 20072c0 <_Rate_monotonic_Timeout+0x6c> 2007290: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 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 ) { 2007294: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 2007298: 80 a0 60 01 cmp %g1, 1 200729c: 02 80 00 17 be 20072f8 <_Rate_monotonic_Timeout+0xa4> 20072a0: 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 ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 20072a4: 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; 20072a8: 05 00 80 79 sethi %hi(0x201e400), %g2 20072ac: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 ! 201e7d0 <_Thread_Dispatch_disable_level> 20072b0: 82 00 7f ff add %g1, -1, %g1 20072b4: c2 20 a3 d0 st %g1, [ %g2 + 0x3d0 ] 20072b8: 81 c7 e0 08 ret 20072bc: 81 e8 00 00 restore case OBJECTS_ERROR: break; case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 20072c0: c2 06 20 08 ld [ %i0 + 8 ], %g1 20072c4: 80 a0 80 01 cmp %g2, %g1 20072c8: 32 bf ff f4 bne,a 2007298 <_Rate_monotonic_Timeout+0x44> 20072cc: 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 ); 20072d0: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20072d4: 40 00 0e 23 call 200ab60 <_Thread_Clear_state> 20072d8: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072dc: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072e0: 92 06 20 10 add %i0, 0x10, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072e4: c2 26 20 1c st %g1, [ %i0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20072e8: 11 00 80 7a sethi %hi(0x201e800), %o0 20072ec: 40 00 14 92 call 200c534 <_Watchdog_Insert> 20072f0: 90 12 20 d0 or %o0, 0xd0, %o0 ! 201e8d0 <_Watchdog_Ticks_chain> 20072f4: 30 bf ff ed b,a 20072a8 <_Rate_monotonic_Timeout+0x54> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20072f8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 <== 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; 20072fc: 84 10 20 03 mov 3, %g2 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2007300: 92 06 20 10 add %i0, 0x10, %o1 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2007304: c2 26 20 1c st %g1, [ %i0 + 0x1c ] <== NOT EXECUTED 2007308: c4 26 20 38 st %g2, [ %i0 + 0x38 ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200730c: 11 00 80 7a sethi %hi(0x201e800), %o0 <== NOT EXECUTED 2007310: 40 00 14 89 call 200c534 <_Watchdog_Insert> <== NOT EXECUTED 2007314: 90 12 20 d0 or %o0, 0xd0, %o0 ! 201e8d0 <_Watchdog_Ticks_chain> <== NOT EXECUTED 2007318: 30 bf ff e4 b,a 20072a8 <_Rate_monotonic_Timeout+0x54> <== NOT EXECUTED 0201b050 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 201b050: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201b054: 27 00 80 ce sethi %hi(0x2033800), %l3 201b058: c2 04 e1 60 ld [ %l3 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 201b05c: 82 00 60 01 inc %g1 201b060: c2 24 e1 60 st %g1, [ %l3 + 0x160 ] 201b064: c2 04 e1 60 ld [ %l3 + 0x160 ], %g1 201b068: 82 00 60 01 inc %g1 201b06c: c2 24 e1 60 st %g1, [ %l3 + 0x160 ] * NOTE: Be sure to disable dispatching before unlocking the mutex * since we do not want to open a window where a context * switch could occur. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 201b070: 03 00 80 ce sethi %hi(0x2033800), %g1 201b074: d0 00 62 38 ld [ %g1 + 0x238 ], %o0 ! 2033a38 <_RTEMS_Allocator_Mutex> 201b078: 94 10 20 00 clr %o2 201b07c: d2 02 20 08 ld [ %o0 + 8 ], %o1 201b080: 7f ff e5 5a call 20145e8 <_CORE_mutex_Surrender> 201b084: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201b088: c2 04 e1 60 ld [ %l3 + 0x160 ], %g1 201b08c: a2 06 20 10 add %i0, 0x10, %l1 201b090: 82 00 7f ff add %g1, -1, %g1 201b094: c2 24 e1 60 st %g1, [ %l3 + 0x160 ] 201b098: c4 04 e1 60 ld [ %l3 + 0x160 ], %g2 201b09c: 80 a0 a0 00 cmp %g2, 0 201b0a0: 02 80 00 21 be 201b124 <_Region_Process_queue+0xd4> 201b0a4: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 201b0a8: 10 80 00 10 b 201b0e8 <_Region_Process_queue+0x98> 201b0ac: a4 06 20 68 add %i0, 0x68, %l2 the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 201b0b0: 7f ff e6 62 call 2014a38 <_Heap_Allocate> 201b0b4: d2 04 20 24 ld [ %l0 + 0x24 ], %o1 201b0b8: 80 a2 20 00 cmp %o0, 0 201b0bc: 02 80 00 11 be 201b100 <_Region_Process_queue+0xb0> 201b0c0: 01 00 00 00 nop break; *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; 201b0c4: c2 06 20 64 ld [ %i0 + 0x64 ], %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 201b0c8: c4 04 20 28 ld [ %l0 + 0x28 ], %g2 the_region->number_of_used_blocks += 1; 201b0cc: 82 00 60 01 inc %g1 ); if ( the_segment == NULL ) break; *(void **)the_thread->Wait.return_argument = the_segment; 201b0d0: d0 20 80 00 st %o0, [ %g2 ] the_region->number_of_used_blocks += 1; 201b0d4: c2 26 20 64 st %g1, [ %i0 + 0x64 ] _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 201b0d8: 90 10 00 11 mov %l1, %o0 201b0dc: 40 00 02 81 call 201bae0 <_Thread_queue_Extract> 201b0e0: 92 10 00 10 mov %l0, %o1 the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 201b0e4: c0 24 20 34 clr [ %l0 + 0x34 ] /* * NOTE: The following loop is O(n) where n is the number of * threads whose memory request is satisfied. */ for ( ; ; ) { the_thread = _Thread_queue_First( &the_region->Wait_queue ); 201b0e8: 40 00 02 c8 call 201bc08 <_Thread_queue_First> 201b0ec: 90 10 00 11 mov %l1, %o0 201b0f0: a0 10 00 08 mov %o0, %l0 if ( the_thread == NULL ) 201b0f4: 80 a4 20 00 cmp %l0, 0 201b0f8: 12 bf ff ee bne 201b0b0 <_Region_Process_queue+0x60> 201b0fc: 90 10 00 12 mov %l2, %o0 201b100: c2 04 e1 60 ld [ %l3 + 0x160 ], %g1 201b104: 82 00 7f ff add %g1, -1, %g1 201b108: c2 24 e1 60 st %g1, [ %l3 + 0x160 ] 201b10c: c4 04 e1 60 ld [ %l3 + 0x160 ], %g2 201b110: 80 a0 a0 00 cmp %g2, 0 201b114: 02 80 00 07 be 201b130 <_Region_Process_queue+0xe0> 201b118: 01 00 00 00 nop 201b11c: 81 c7 e0 08 ret <== NOT EXECUTED 201b120: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 201b124: 7f ff ee 70 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 201b128: a4 06 20 68 add %i0, 0x68, %l2 <== NOT EXECUTED 201b12c: 30 bf ff ef b,a 201b0e8 <_Region_Process_queue+0x98> <== NOT EXECUTED 201b130: 7f ff ee 6d call 2016ae4 <_Thread_Dispatch> 201b134: 81 e8 00 00 restore 201b138: 01 00 00 00 nop 02008bdc <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 2008bdc: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008be0: 23 00 80 99 sethi %hi(0x2026400), %l1 2008be4: c2 04 61 50 ld [ %l1 + 0x150 ], %g1 ! 2026550 <_Thread_Dispatch_disable_level> 2008be8: 82 00 60 01 inc %g1 2008bec: c2 24 61 50 st %g1, [ %l1 + 0x150 ] _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 2008bf0: 21 00 80 99 sethi %hi(0x2026400), %l0 2008bf4: c2 06 00 00 ld [ %i0 ], %g1 2008bf8: d4 04 22 0c ld [ %l0 + 0x20c ], %o2 2008bfc: 80 a0 40 0a cmp %g1, %o2 2008c00: 36 80 00 18 bge,a 2008c60 <_TOD_Set+0x84> 2008c04: 94 20 40 0a sub %g1, %o2, %o2 Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 2008c08: 11 00 80 99 sethi %hi(0x2026400), %o0 2008c0c: 94 22 80 01 sub %o2, %g1, %o2 2008c10: 90 12 22 44 or %o0, 0x244, %o0 2008c14: 40 00 0f 24 call 200c8a4 <_Watchdog_Adjust> 2008c18: 92 10 20 01 mov 1, %o1 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008c1c: c4 06 00 00 ld [ %i0 ], %g2 2008c20: 86 14 22 0c or %l0, 0x20c, %g3 2008c24: c4 24 22 0c st %g2, [ %l0 + 0x20c ] 2008c28: c2 06 20 04 ld [ %i0 + 4 ], %g1 _TOD_Is_set = TRUE; 2008c2c: 84 10 20 01 mov 1, %g2 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008c30: c2 20 e0 04 st %g1, [ %g3 + 4 ] _TOD_Is_set = TRUE; 2008c34: 03 00 80 99 sethi %hi(0x2026400), %g1 2008c38: c4 20 61 8c st %g2, [ %g1 + 0x18c ] ! 202658c <_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 ) 2008c3c: c2 04 61 50 ld [ %l1 + 0x150 ], %g1 2008c40: 82 00 7f ff add %g1, -1, %g1 2008c44: c2 24 61 50 st %g1, [ %l1 + 0x150 ] 2008c48: c4 04 61 50 ld [ %l1 + 0x150 ], %g2 2008c4c: 80 a0 a0 00 cmp %g2, 0 2008c50: 02 80 00 0a be 2008c78 <_TOD_Set+0x9c> 2008c54: 01 00 00 00 nop 2008c58: 81 c7 e0 08 ret 2008c5c: 81 e8 00 00 restore 2008c60: 11 00 80 99 sethi %hi(0x2026400), %o0 2008c64: 92 10 20 00 clr %o1 2008c68: 40 00 0f 0f call 200c8a4 <_Watchdog_Adjust> 2008c6c: 90 12 22 44 or %o0, 0x244, %o0 else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 2008c70: 10 bf ff ec b 2008c20 <_TOD_Set+0x44> 2008c74: c4 06 00 00 ld [ %i0 ], %g2 _Thread_Dispatch(); 2008c78: 40 00 08 48 call 200ad98 <_Thread_Dispatch> <== NOT EXECUTED 2008c7c: 81 e8 00 00 restore <== NOT EXECUTED 2008c80: 01 00 00 00 nop 0200914c <_Thread_Create_idle>: */ const char *_Thread_Idle_name = "IDLE"; void _Thread_Create_idle( void ) { 200914c: 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 ); 2009150: 39 00 80 66 sethi %hi(0x2019800), %i4 2009154: 7f ff f9 cd call 2007888 <_Objects_Allocate> 2009158: 90 17 21 d0 or %i4, 0x1d0, %o0 ! 20199d0 <_Thread_Internal_information> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 200915c: 03 00 80 66 sethi %hi(0x2019800), %g1 2009160: 96 10 60 54 or %g1, 0x54, %o3 ! 2019854 <_CPU_Table> 2009164: c4 02 e0 0c ld [ %o3 + 0xc ], %g2 * 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(); 2009168: 37 00 80 66 sethi %hi(0x2019800), %i3 200916c: d0 26 e2 28 st %o0, [ %i3 + 0x228 ] ! 2019a28 <_Thread_Idle> idle = (void *) _CPU_Thread_Idle_body; #else idle = (void *) _Thread_Idle_body; #endif if ( _CPU_Table.idle_task ) 2009170: 03 00 80 25 sethi %hi(0x2009400), %g1 2009174: 92 10 00 08 mov %o0, %o1 2009178: 80 a0 a0 00 cmp %g2, 0 200917c: 02 80 00 03 be 2009188 <_Thread_Create_idle+0x3c> 2009180: b4 10 60 2c or %g1, 0x2c, %i2 idle = _CPU_Table.idle_task; 2009184: b4 10 00 02 mov %g2, %i2 <== NOT EXECUTED idle_task_stack_size = _CPU_Table.idle_task_stack_size; 2009188: d6 02 e0 14 ld [ %o3 + 0x14 ], %o3 if ( idle_task_stack_size < STACK_MINIMUM_SIZE ) 200918c: 80 a2 ef ff cmp %o3, 0xfff 2009190: 28 80 00 02 bleu,a 2009198 <_Thread_Create_idle+0x4c> 2009194: 17 00 00 04 sethi %hi(0x1000), %o3 idle_task_stack_size = STACK_MINIMUM_SIZE; _Thread_Initialize( 2009198: 03 00 80 62 sethi %hi(0x2018800), %g1 200919c: c4 00 62 40 ld [ %g1 + 0x240 ], %g2 ! 2018a40 <_Thread_Idle_name> 20091a0: 82 10 20 01 mov 1, %g1 20091a4: c4 23 a0 6c st %g2, [ %sp + 0x6c ] 20091a8: 90 17 21 d0 or %i4, 0x1d0, %o0 20091ac: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 20091b0: c0 23 a0 60 clr [ %sp + 0x60 ] 20091b4: c0 23 a0 64 clr [ %sp + 0x64 ] 20091b8: c0 23 a0 68 clr [ %sp + 0x68 ] 20091bc: 94 10 20 00 clr %o2 20091c0: 98 10 20 00 clr %o4 20091c4: 40 00 00 9b call 2009430 <_Thread_Initialize> 20091c8: 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 = 20091cc: c6 06 e2 28 ld [ %i3 + 0x228 ], %g3 20091d0: 03 00 80 66 sethi %hi(0x2019800), %g1 20091d4: 05 00 80 66 sethi %hi(0x2019800), %g2 _Thread_Executing = _Thread_Idle; _Thread_Start( 20091d8: b0 10 00 03 mov %g3, %i0 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 20091dc: c6 20 61 20 st %g3, [ %g1 + 0x120 ] 20091e0: c6 20 a0 f8 st %g3, [ %g2 + 0xf8 ] _Thread_Executing = _Thread_Idle; _Thread_Start( 20091e4: b2 10 20 00 clr %i1 20091e8: b6 10 20 00 clr %i3 20091ec: 40 00 04 35 call 200a2c0 <_Thread_Start> 20091f0: 99 e8 20 00 restore %g0, 0, %o4 20091f4: 01 00 00 00 nop 020091f8 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 20091f8: 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 ) ) { 20091fc: 92 96 20 00 orcc %i0, 0, %o1 2009200: 12 80 00 11 bne 2009244 <_Thread_Delay_ended+0x4c> 2009204: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009208: 31 00 80 66 sethi %hi(0x2019800), %i0 <== NOT EXECUTED 200920c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2009210: 82 00 60 01 inc %g1 <== NOT EXECUTED 2009214: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== 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; 2009218: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200921c: d0 00 61 20 ld [ %g1 + 0x120 ], %o0 ! 2019920 <_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; 2009220: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2009224: 13 04 00 ff sethi %hi(0x1003fc00), %o1 <== NOT EXECUTED 2009228: 7f ff ff 5c call 2008f98 <_Thread_Clear_state> 200922c: 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; 2009230: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2009234: 82 00 7f ff add %g1, -1, %g1 2009238: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 200923c: 81 c7 e0 08 ret 2009240: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009244: 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 ) { 2009248: 80 a0 a0 04 cmp %g2, 4 200924c: 18 bf ff fc bgu 200923c <_Thread_Delay_ended+0x44> 2009250: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2009254: 80 a0 60 01 cmp %g1, 1 2009258: 12 bf ff f9 bne 200923c <_Thread_Delay_ended+0x44> 200925c: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009260: 05 00 80 65 sethi %hi(0x2019400), %g2 2009264: 84 10 a3 a0 or %g2, 0x3a0, %g2 ! 20197a0 <_Objects_Information_table> 2009268: c6 00 80 01 ld [ %g2 + %g1 ], %g3 200926c: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2009270: 80 a2 20 00 cmp %o0, 0 2009274: 02 bf ff f2 be 200923c <_Thread_Delay_ended+0x44> 2009278: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200927c: 7f ff fa d4 call 2007dcc <_Objects_Get> 2009280: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009284: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009288: 80 a0 60 00 cmp %g1, 0 200928c: 12 bf ff ec bne 200923c <_Thread_Delay_ended+0x44> 2009290: 31 00 80 66 sethi %hi(0x2019800), %i0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 2009294: 10 bf ff e5 b 2009228 <_Thread_Delay_ended+0x30> 2009298: 13 04 00 ff sethi %hi(0x1003fc00), %o1 0200ed80 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 200ed80: 9d e3 bf 98 save %sp, -104, %sp #endif #if defined(__USE__MAIN__) extern void _main(void); #endif executing = _Thread_Executing; 200ed84: 03 00 80 66 sethi %hi(0x2019800), %g1 200ed88: f4 00 61 20 ld [ %g1 + 0x120 ], %i2 ! 2019920 <_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(); 200ed8c: 3f 00 80 3b sethi %hi(0x200ec00), %i7 200ed90: be 17 e1 80 or %i7, 0x180, %i7 ! 200ed80 <_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); 200ed94: d0 06 a0 c4 ld [ %i2 + 0xc4 ], %o0 200ed98: 7f ff cc 1d call 2001e0c 200ed9c: 91 2a 20 08 sll %o0, 8, %o0 #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 200eda0: 07 00 80 65 sethi %hi(0x2019400), %g3 doneConstructors = 1; 200eda4: 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; 200eda8: f0 08 e0 a4 ldub [ %g3 + 0xa4 ], %i0 doneConstructors = 1; 200edac: c2 28 e0 a4 stb %g1, [ %g3 + 0xa4 ] #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 ) ) { 200edb0: c4 06 a1 68 ld [ %i2 + 0x168 ], %g2 200edb4: 80 a0 a0 00 cmp %g2, 0 200edb8: 02 80 00 07 be 200edd4 <_Thread_Handler+0x54> 200edbc: 01 00 00 00 nop #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 ); 200edc0: 33 00 80 66 sethi %hi(0x2019800), %i1 200edc4: d0 06 60 f0 ld [ %i1 + 0xf0 ], %o0 ! 20198f0 <_Thread_Allocated_fp> 200edc8: 80 a6 80 08 cmp %i2, %o0 200edcc: 12 80 00 20 bne 200ee4c <_Thread_Handler+0xcc> 200edd0: 80 a2 20 00 cmp %o0, 0 * 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 ); 200edd4: 7f ff ed f9 call 200a5b8 <_User_extensions_Thread_begin> 200edd8: 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 ) 200eddc: 03 00 80 66 sethi %hi(0x2019800), %g1 200ede0: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 200ede4: 84 00 bf ff add %g2, -1, %g2 200ede8: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 200edec: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 200edf0: 80 a0 e0 00 cmp %g3, 0 200edf4: 02 80 00 25 be 200ee88 <_Thread_Handler+0x108> 200edf8: 83 2e 20 18 sll %i0, 0x18, %g1 /* * _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) */ 200edfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ee00: 02 80 00 28 be 200eea0 <_Thread_Handler+0x120> <== NOT EXECUTED 200ee04: 01 00 00 00 nop <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200ee08: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 <== NOT EXECUTED 200ee0c: 80 a0 60 01 cmp %g1, 1 200ee10: 22 80 00 2b be,a 200eebc <_Thread_Handler+0x13c> 200ee14: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200ee18: 80 a0 60 01 cmp %g1, 1 200ee1c: 3a 80 00 31 bcc,a 200eee0 <_Thread_Handler+0x160> 200ee20: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 200ee24: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200ee28: 9f c0 40 00 call %g1 200ee2c: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 200ee30: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 200ee34: 90 10 00 1a mov %i2, %o0 200ee38: 7f ff ee 08 call 200a658 <_User_extensions_Thread_exitted> 200ee3c: b0 10 20 00 clr %i0 _Internal_error_Occurred( 200ee40: b2 10 20 01 mov 1, %i1 200ee44: 7f ff e2 64 call 20077d4 <_Internal_error_Occurred> 200ee48: 95 e8 20 06 restore %g0, 6, %o2 #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 ) ) { if ( _Thread_Allocated_fp != NULL ) 200ee4c: 22 80 00 05 be,a 200ee60 <_Thread_Handler+0xe0> 200ee50: f4 26 60 f0 st %i2, [ %i1 + 0xf0 ] _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 200ee54: 7f ff ef 67 call 200abf0 <_CPU_Context_save_fp> 200ee58: 90 02 21 68 add %o0, 0x168, %o0 _Thread_Allocated_fp = executing; 200ee5c: f4 26 60 f0 st %i2, [ %i1 + 0xf0 ] * 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 ); 200ee60: 7f ff ed d6 call 200a5b8 <_User_extensions_Thread_begin> 200ee64: 90 10 00 1a mov %i2, %o0 200ee68: 03 00 80 66 sethi %hi(0x2019800), %g1 200ee6c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 200ee70: 84 00 bf ff add %g2, -1, %g2 200ee74: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 200ee78: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 200ee7c: 80 a0 e0 00 cmp %g3, 0 200ee80: 12 bf ff df bne 200edfc <_Thread_Handler+0x7c> 200ee84: 83 2e 20 18 sll %i0, 0x18, %g1 _Thread_Dispatch(); 200ee88: 7f ff e9 05 call 200929c <_Thread_Dispatch> 200ee8c: 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) */ 200ee90: 83 2e 20 18 sll %i0, 0x18, %g1 200ee94: 80 a0 60 00 cmp %g1, 0 200ee98: 32 bf ff dd bne,a 200ee0c <_Thread_Handler+0x8c> 200ee9c: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 _init (); 200eea0: 40 00 25 82 call 20184a8 <_init> 200eea4: 01 00 00 00 nop #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200eea8: c2 06 a0 ac ld [ %i2 + 0xac ], %g1 200eeac: 80 a0 60 01 cmp %g1, 1 200eeb0: 12 bf ff db bne 200ee1c <_Thread_Handler+0x9c> 200eeb4: 01 00 00 00 nop (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 200eeb8: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 200eebc: d0 06 a0 b0 ld [ %i2 + 0xb0 ], %o0 200eec0: 9f c0 40 00 call %g1 200eec4: b0 10 20 00 clr %i0 200eec8: d0 26 a0 28 st %o0, [ %i2 + 0x28 ] * was placed in return_argument. This assumed that if it returned * anything (which is not supporting in all APIs), then it would be * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); 200eecc: 90 10 00 1a mov %i2, %o0 200eed0: 7f ff ed e2 call 200a658 <_User_extensions_Thread_exitted> 200eed4: b2 10 20 01 mov 1, %i1 _Internal_error_Occurred( 200eed8: 7f ff e2 3f call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200eedc: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 200eee0: 02 80 00 0f be 200ef1c <_Thread_Handler+0x19c> <== NOT EXECUTED 200eee4: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 200eee8: 12 bf ff d4 bne 200ee38 <_Thread_Handler+0xb8> <== NOT EXECUTED 200eeec: 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 = 200eef0: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200eef4: d2 06 a0 b0 ld [ %i2 + 0xb0 ], %o1 <== NOT EXECUTED 200eef8: d0 06 a0 b4 ld [ %i2 + 0xb4 ], %o0 <== NOT EXECUTED 200eefc: 9f c0 40 00 call %g1 <== NOT EXECUTED 200ef00: b0 10 20 00 clr %i0 <== NOT EXECUTED 200ef04: 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 ); 200ef08: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 200ef0c: 7f ff ed d3 call 200a658 <_User_extensions_Thread_exitted> <== NOT EXECUTED 200ef10: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 200ef14: 7f ff e2 30 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200ef18: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 200ef1c: c2 06 a0 a8 ld [ %i2 + 0xa8 ], %g1 <== NOT EXECUTED 200ef20: d0 1e a0 b0 ldd [ %i2 + 0xb0 ], %o0 <== NOT EXECUTED 200ef24: 9f c0 40 00 call %g1 <== NOT EXECUTED 200ef28: b0 10 20 00 clr %i0 <== NOT EXECUTED 200ef2c: 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 ); 200ef30: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED 200ef34: 7f ff ed c9 call 200a658 <_User_extensions_Thread_exitted> <== NOT EXECUTED 200ef38: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED _Internal_error_Occurred( 200ef3c: 7f ff e2 26 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200ef40: 95 e8 20 06 restore %g0, 6, %o2 <== NOT EXECUTED 200ef44: 01 00 00 00 nop 02009654 <_Thread_Handler_initialization>: void _Thread_Handler_initialization( uint32_t ticks_per_timeslice, uint32_t maximum_extensions, uint32_t maximum_proxies ) { 2009654: 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 ) 2009658: 03 00 80 66 sethi %hi(0x2019800), %g1 200965c: 82 10 60 54 or %g1, 0x54, %g1 ! 2019854 <_CPU_Table> 2009660: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 2009664: c6 00 60 24 ld [ %g1 + 0x24 ], %g3 2009668: 80 a0 00 02 cmp %g0, %g2 200966c: 88 60 3f ff subx %g0, -1, %g4 2009670: 80 a0 00 03 cmp %g0, %g3 2009674: 82 60 3f ff subx %g0, -1, %g1 2009678: 80 a1 00 01 cmp %g4, %g1 200967c: 12 80 00 2e bne 2009734 <_Thread_Handler_initialization+0xe0> 2009680: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 2009684: 03 00 80 66 sethi %hi(0x2019800), %g1 _Thread_Executing = NULL; 2009688: 05 00 80 66 sethi %hi(0x2019800), %g2 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 200968c: c0 20 61 30 clr [ %g1 + 0x130 ] _Thread_Executing = NULL; _Thread_Heir = NULL; 2009690: 03 00 80 66 sethi %hi(0x2019800), %g1 TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; 2009694: c0 20 a1 20 clr [ %g2 + 0x120 ] _Thread_Heir = NULL; 2009698: c0 20 60 f8 clr [ %g1 + 0xf8 ] #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 200969c: 05 00 80 66 sethi %hi(0x2019800), %g2 #endif _Thread_Do_post_task_switch_extension = 0; 20096a0: 03 00 80 66 sethi %hi(0x2019800), %g1 _Context_Switch_necessary = FALSE; _Thread_Executing = NULL; _Thread_Heir = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 20096a4: c0 20 a0 f0 clr [ %g2 + 0xf0 ] #endif _Thread_Do_post_task_switch_extension = 0; 20096a8: c0 20 61 10 clr [ %g1 + 0x110 ] _Thread_Maximum_extensions = maximum_extensions; 20096ac: 05 00 80 66 sethi %hi(0x2019800), %g2 _Thread_Ticks_per_timeslice = ticks_per_timeslice; 20096b0: 03 00 80 65 sethi %hi(0x2019400), %g1 _Thread_Allocated_fp = NULL; #endif _Thread_Do_post_task_switch_extension = 0; _Thread_Maximum_extensions = maximum_extensions; 20096b4: f2 20 a1 0c st %i1, [ %g2 + 0x10c ] _Thread_Ticks_per_timeslice = ticks_per_timeslice; 20096b8: f0 20 63 98 st %i0, [ %g1 + 0x398 ] _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 20096bc: 40 00 05 18 call 200ab1c <_Workspace_Allocate_or_fatal_error> 20096c0: 90 10 2c 00 mov 0xc00, %o0 20096c4: 03 00 80 65 sethi %hi(0x2019400), %g1 20096c8: 84 10 00 08 mov %o0, %g2 20096cc: d0 20 63 94 st %o0, [ %g1 + 0x394 ] 20096d0: 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); 20096d4: 82 00 a0 04 add %g2, 4, %g1 the_chain->permanent_null = NULL; 20096d8: c0 20 a0 04 clr [ %g2 + 4 ] the_chain->last = _Chain_Head(the_chain); 20096dc: 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); 20096e0: c2 20 80 00 st %g1, [ %g2 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20096e4: 84 00 a0 0c add %g2, 0xc, %g2 (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 20096e8: 80 a0 80 03 cmp %g2, %g3 20096ec: 12 bf ff fb bne 20096d8 <_Thread_Handler_initialization+0x84> 20096f0: 82 00 a0 04 add %g2, 4, %g1 /* * Initialize this class of objects. */ _Objects_Initialize_information( 20096f4: 03 00 80 66 sethi %hi(0x2019800), %g1 20096f8: c4 00 61 4c ld [ %g1 + 0x14c ], %g2 ! 201994c <_System_state_Is_multiprocessing> 20096fc: 82 10 20 08 mov 8, %g1 2009700: 80 a0 00 02 cmp %g0, %g2 2009704: 96 10 20 02 mov 2, %o3 2009708: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 200970c: 96 42 ff ff addx %o3, -1, %o3 2009710: 11 00 80 66 sethi %hi(0x2019800), %o0 2009714: 92 10 20 01 mov 1, %o1 2009718: 90 12 21 d0 or %o0, 0x1d0, %o0 200971c: 94 10 20 01 mov 1, %o2 2009720: 98 10 21 88 mov 0x188, %o4 2009724: 7f ff f9 d1 call 2007e68 <_Objects_Initialize_information> 2009728: 9a 10 20 01 mov 1, %o5 FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 200972c: 81 c7 e0 08 ret 2009730: 81 e8 00 00 restore * Do not allow mixture. */ if ( !( ( _CPU_Table.stack_allocate_hook == 0 ) == ( _CPU_Table.stack_free_hook == 0 ) ) ) _Internal_error_Occurred( 2009734: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2009738: 7f ff f8 27 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200973c: 94 10 20 0f mov 0xf, %o2 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 2009740: 10 bf ff d2 b 2009688 <_Thread_Handler_initialization+0x34> <== NOT EXECUTED 2009744: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 02009430 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 2009430: 9d e3 bf 98 save %sp, -104, %sp /* * Initialize the Ada self pointer */ the_thread->rtems_ada_self = NULL; 2009434: c0 26 60 80 clr [ %i1 + 0x80 ] /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 2009438: 80 a6 a0 00 cmp %i2, 0 200943c: 02 80 00 71 be 2009600 <_Thread_Initialize+0x1d0> 2009440: e2 07 a0 60 ld [ %fp + 0x60 ], %l1 stack = the_thread->Start.stack; the_thread->Start.core_allocated_stack = TRUE; } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 2009444: c0 26 60 cc clr [ %i1 + 0xcc ] <== NOT EXECUTED 2009448: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 200944c: f4 26 60 d4 st %i2, [ %i1 + 0xd4 ] the_stack->size = size; 2009450: 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 ) { 2009454: 80 a7 20 00 cmp %i4, 0 2009458: b4 10 20 00 clr %i2 200945c: 12 80 00 49 bne 2009580 <_Thread_Initialize+0x150> 2009460: 82 10 20 00 clr %g1 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2009464: 37 00 80 66 sethi %hi(0x2019800), %i3 2009468: d2 06 e1 0c ld [ %i3 + 0x10c ], %o1 ! 201990c <_Thread_Maximum_extensions> } else fp_area = NULL; the_thread->fp_context = fp_area; the_thread->Start.fp_context = fp_area; 200946c: c2 26 60 d8 st %g1, [ %i1 + 0xd8 ] fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 2009470: c2 26 61 68 st %g1, [ %i1 + 0x168 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2009474: c0 26 60 50 clr [ %i1 + 0x50 ] the_watchdog->routine = routine; 2009478: c0 26 60 64 clr [ %i1 + 0x64 ] the_watchdog->id = id; 200947c: c0 26 60 68 clr [ %i1 + 0x68 ] the_watchdog->user_data = user_data; 2009480: c0 26 60 6c clr [ %i1 + 0x6c ] /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 2009484: 80 a2 60 00 cmp %o1, 0 2009488: 12 80 00 4a bne 20095b0 <_Thread_Initialize+0x180> 200948c: c0 26 61 6c clr [ %i1 + 0x16c ] return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 2009490: c0 26 61 7c clr [ %i1 + 0x17c ] 2009494: b8 10 20 00 clr %i4 /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 2009498: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 the_thread->Start.budget_algorithm = budget_algorithm; 200949c: e2 26 60 bc st %l1, [ %i1 + 0xbc ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 20094a0: c2 26 60 b8 st %g1, [ %i1 + 0xb8 ] the_thread->Start.budget_algorithm = budget_algorithm; the_thread->Start.budget_callout = budget_callout; 20094a4: c2 07 a0 64 ld [ %fp + 0x64 ], %g1 switch ( budget_algorithm ) { 20094a8: 80 a4 60 02 cmp %l1, 2 20094ac: 12 80 00 05 bne 20094c0 <_Thread_Initialize+0x90> 20094b0: 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; 20094b4: 03 00 80 65 sethi %hi(0x2019400), %g1 <== NOT EXECUTED 20094b8: c4 00 63 98 ld [ %g1 + 0x398 ], %g2 ! 2019798 <_Thread_Ticks_per_timeslice> <== NOT EXECUTED 20094bc: c4 26 60 84 st %g2, [ %i1 + 0x84 ] <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 20094c0: c2 07 a0 68 ld [ %fp + 0x68 ], %g1 the_thread->current_state = STATES_DORMANT; the_thread->Wait.queue = NULL; 20094c4: c0 26 60 44 clr [ %i1 + 0x44 ] break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 20094c8: c2 26 60 c4 st %g1, [ %i1 + 0xc4 ] the_thread->current_state = STATES_DORMANT; 20094cc: 82 10 20 01 mov 1, %g1 the_thread->Wait.queue = NULL; the_thread->resource_count = 0; 20094d0: c0 26 60 1c clr [ %i1 + 0x1c ] break; } the_thread->Start.isr_level = isr_level; the_thread->current_state = STATES_DORMANT; 20094d4: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_thread->Wait.queue = NULL; the_thread->resource_count = 0; the_thread->suspend_count = 0; 20094d8: c0 26 60 70 clr [ %i1 + 0x70 ] the_thread->real_priority = priority; 20094dc: fa 26 60 18 st %i5, [ %i1 + 0x18 ] the_thread->Start.initial_priority = priority; 20094e0: fa 26 60 c8 st %i5, [ %i1 + 0xc8 ] _Thread_Set_priority( the_thread, priority ); 20094e4: 92 10 00 1d mov %i5, %o1 20094e8: 40 00 02 8c call 2009f18 <_Thread_Set_priority> 20094ec: 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 ); 20094f0: c4 06 60 08 ld [ %i1 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20094f4: 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; 20094f8: c0 26 60 90 clr [ %i1 + 0x90 ] 20094fc: 03 00 00 3f sethi %hi(0xfc00), %g1 2009500: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009504: 82 08 80 01 and %g2, %g1, %g1 2009508: 80 a0 40 03 cmp %g1, %g3 200950c: 08 80 00 19 bleu 2009570 <_Thread_Initialize+0x140> 2009510: c0 26 60 94 clr [ %i1 + 0x94 ] 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; 2009514: c2 07 a0 6c ld [ %fp + 0x6c ], %g1 /* * Invoke create extensions */ if ( !_User_extensions_Thread_create( the_thread ) ) { 2009518: 90 10 00 19 mov %i1, %o0 200951c: c2 26 60 0c st %g1, [ %i1 + 0xc ] 2009520: 40 00 04 61 call 200a6a4 <_User_extensions_Thread_create> 2009524: b0 10 20 01 mov 1, %i0 2009528: 80 a2 20 00 cmp %o0, 0 200952c: 12 80 00 1f bne 20095a8 <_Thread_Initialize+0x178> 2009530: 80 a7 20 00 cmp %i4, 0 if ( extensions_area ) 2009534: 02 80 00 05 be 2009548 <_Thread_Initialize+0x118> <== NOT EXECUTED 2009538: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 200953c: 11 00 80 66 sethi %hi(0x2019800), %o0 <== NOT EXECUTED 2009540: 7f ff f7 a5 call 20073d4 <_Heap_Free> <== NOT EXECUTED 2009544: 90 12 20 8c or %o0, 0x8c, %o0 ! 201988c <_Workspace_Area> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2009548: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 200954c: 02 80 00 05 be 2009560 <_Thread_Initialize+0x130> <== NOT EXECUTED 2009550: 11 00 80 66 sethi %hi(0x2019800), %o0 <== NOT EXECUTED 2009554: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2009558: 7f ff f7 9f call 20073d4 <_Heap_Free> <== NOT EXECUTED 200955c: 90 12 20 8c or %o0, 0x8c, %o0 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 2009560: 40 00 03 32 call 200a228 <_Thread_Stack_Free> <== NOT EXECUTED 2009564: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2009568: 81 c7 e0 08 ret 200956c: 91 e8 20 00 restore %g0, 0, %o0 uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 2009570: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 2009574: 83 28 60 02 sll %g1, 2, %g1 2009578: 10 bf ff e7 b 2009514 <_Thread_Initialize+0xe4> 200957c: f2 20 80 01 st %i1, [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2009580: 11 00 80 66 sethi %hi(0x2019800), %o0 2009584: 92 10 20 88 mov 0x88, %o1 2009588: 7f ff f7 61 call 200730c <_Heap_Allocate> 200958c: 90 12 20 8c or %o0, 0x8c, %o0 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { 2009590: b4 92 20 00 orcc %o0, 0, %i2 2009594: 12 bf ff b4 bne 2009464 <_Thread_Initialize+0x34> 2009598: 82 10 00 1a mov %i2, %g1 #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 200959c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 20095a0: 40 00 03 22 call 200a228 <_Thread_Stack_Free> <== NOT EXECUTED 20095a4: b0 10 20 00 clr %i0 <== NOT EXECUTED 20095a8: 81 c7 e0 08 ret 20095ac: 81 e8 00 00 restore 20095b0: 92 02 60 01 inc %o1 20095b4: 21 00 80 66 sethi %hi(0x2019800), %l0 20095b8: 93 2a 60 02 sll %o1, 2, %o1 20095bc: 7f ff f7 54 call 200730c <_Heap_Allocate> 20095c0: 90 14 20 8c or %l0, 0x8c, %o0 if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 20095c4: b8 92 20 00 orcc %o0, 0, %i4 20095c8: 02 80 00 1c be 2009638 <_Thread_Initialize+0x208> 20095cc: c2 06 e1 0c ld [ %i3 + 0x10c ], %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 20095d0: 80 a0 7f ff cmp %g1, -1 20095d4: 02 bf ff b1 be 2009498 <_Thread_Initialize+0x68> 20095d8: f8 26 61 7c st %i4, [ %i1 + 0x17c ] 20095dc: 86 00 60 01 add %g1, 1, %g3 20095e0: 84 10 20 00 clr %g2 the_thread->extensions[i] = NULL; 20095e4: 83 28 a0 02 sll %g2, 2, %g1 * call. */ if ( the_thread->extensions ) { int i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 20095e8: 84 00 a0 01 inc %g2 20095ec: 80 a0 80 03 cmp %g2, %g3 20095f0: 12 bf ff fd bne 20095e4 <_Thread_Initialize+0x1b4> 20095f4: c0 27 00 01 clr [ %i4 + %g1 ] /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 20095f8: 10 bf ff a9 b 200949c <_Thread_Initialize+0x6c> 20095fc: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { if ( !_Stack_Is_enough( stack_size ) ) 2009600: 80 a6 ef ff cmp %i3, 0xfff 2009604: 08 80 00 03 bleu 2009610 <_Thread_Initialize+0x1e0> 2009608: 13 00 00 04 sethi %hi(0x1000), %o1 200960c: 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 ); 2009610: 40 00 02 eb call 200a1bc <_Thread_Stack_Allocate> 2009614: 90 10 00 19 mov %i1, %o0 if ( !actual_stack_size || actual_stack_size < stack_size ) 2009618: 80 a2 20 00 cmp %o0, 0 200961c: 02 bf ff d3 be 2009568 <_Thread_Initialize+0x138> 2009620: 80 a6 c0 08 cmp %i3, %o0 2009624: 18 bf ff d1 bgu 2009568 <_Thread_Initialize+0x138> 2009628: 82 10 20 01 mov 1, %g1 return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 200962c: f4 06 60 dc ld [ %i1 + 0xdc ], %i2 the_thread->Start.core_allocated_stack = TRUE; 2009630: 10 bf ff 87 b 200944c <_Thread_Initialize+0x1c> 2009634: c2 26 60 cc st %g1, [ %i1 + 0xcc ] (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 2009638: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 200963c: 02 bf ff d8 be 200959c <_Thread_Initialize+0x16c> <== NOT EXECUTED 2009640: 90 14 20 8c or %l0, 0x8c, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2009644: 7f ff f7 64 call 20073d4 <_Heap_Free> <== NOT EXECUTED 2009648: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); 200964c: 10 bf ff d5 b 20095a0 <_Thread_Initialize+0x170> <== NOT EXECUTED 2009650: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 0200ed34 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { 200ed34: 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; 200ed38: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 200ed3c: c4 06 20 bc ld [ %i0 + 0xbc ], %g2 the_thread->budget_callout = the_thread->Start.budget_callout; 200ed40: 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; 200ed44: 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; 200ed48: c4 3e 20 88 std %g2, [ %i0 + 0x88 ] the_thread->Start.pointer_argument = pointer_argument; 200ed4c: f2 26 20 b0 st %i1, [ %i0 + 0xb0 ] the_thread->Start.numeric_argument = numeric_argument; 200ed50: f4 26 20 b4 st %i2, [ %i0 + 0xb4 ] Thread_Control *the_thread, void *pointer_argument, uint32_t numeric_argument ) { the_thread->resource_count = 0; 200ed54: c0 26 20 1c clr [ %i0 + 0x1c ] the_thread->suspend_count = 0; 200ed58: 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 ) ) { 200ed5c: 7f ff ee f6 call 200a934 <_Thread_queue_Extract_with_proxy> 200ed60: 90 10 00 18 mov %i0, %o0 200ed64: 80 a2 20 00 cmp %o0, 0 200ed68: 32 80 00 07 bne,a 200ed84 <_Thread_Reset+0x50> 200ed6c: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 if ( _Watchdog_Is_active( &the_thread->Timer ) ) 200ed70: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200ed74: 80 a0 60 02 cmp %g1, 2 200ed78: 02 80 00 0c be 200eda8 <_Thread_Reset+0x74> 200ed7c: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200ed80: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 200ed84: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 200ed88: 80 a0 40 19 cmp %g1, %i1 200ed8c: 02 80 00 05 be 200eda0 <_Thread_Reset+0x6c> 200ed90: 01 00 00 00 nop the_thread->real_priority = the_thread->Start.initial_priority; 200ed94: f2 26 20 18 st %i1, [ %i0 + 0x18 ] _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 200ed98: 7f ff ef b0 call 200ac58 <_Thread_Set_priority> 200ed9c: 81 e8 00 00 restore 200eda0: 81 c7 e0 08 ret 200eda4: 81 e8 00 00 restore the_thread->Start.numeric_argument = numeric_argument; if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 200eda8: 7f ff f2 60 call 200b728 <_Watchdog_Remove> <== NOT EXECUTED 200edac: 90 06 20 48 add %i0, 0x48, %o0 <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 200edb0: 10 bf ff f5 b 200ed84 <_Thread_Reset+0x50> <== NOT EXECUTED 200edb4: f2 06 20 c8 ld [ %i0 + 0xc8 ], %i1 <== NOT EXECUTED 0200df1c <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 200df1c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200df20: 03 00 80 66 sethi %hi(0x2019800), %g1 200df24: e0 00 61 20 ld [ %g1 + 0x120 ], %l0 ! 2019920 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200df28: 7f ff cf b5 call 2001dfc 200df2c: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200df30: b0 10 00 08 mov %o0, %i0 if ( _Chain_Has_only_one_node( ready ) ) { 200df34: c4 04 40 00 ld [ %l1 ], %g2 200df38: c2 04 60 08 ld [ %l1 + 8 ], %g1 200df3c: 80 a0 80 01 cmp %g2, %g1 200df40: 32 80 00 04 bne,a 200df50 <_Thread_Reset_timeslice+0x34> 200df44: c6 04 00 00 ld [ %l0 ], %g3 _ISR_Enable( level ); 200df48: 7f ff cf b1 call 2001e0c 200df4c: 81 e8 00 00 restore { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200df50: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200df54: 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; 200df58: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200df5c: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200df60: 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; 200df64: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200df68: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200df6c: 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; 200df70: e0 20 40 00 st %l0, [ %g1 ] return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200df74: 7f ff cf a6 call 2001e0c 200df78: 01 00 00 00 nop 200df7c: 7f ff cf a0 call 2001dfc 200df80: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200df84: 05 00 80 66 sethi %hi(0x2019800), %g2 200df88: c2 00 a0 f8 ld [ %g2 + 0xf8 ], %g1 ! 20198f8 <_Thread_Heir> 200df8c: 80 a4 00 01 cmp %l0, %g1 200df90: 32 80 00 05 bne,a 200dfa4 <_Thread_Reset_timeslice+0x88> 200df94: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200df98: c2 04 40 00 ld [ %l1 ], %g1 200df9c: c2 20 a0 f8 st %g1, [ %g2 + 0xf8 ] _Context_Switch_necessary = TRUE; 200dfa0: 84 10 20 01 mov 1, %g2 200dfa4: 03 00 80 66 sethi %hi(0x2019800), %g1 200dfa8: c4 20 61 30 st %g2, [ %g1 + 0x130 ] ! 2019930 <_Context_Switch_necessary> _ISR_Enable( level ); 200dfac: 7f ff cf 98 call 2001e0c 200dfb0: 81 e8 00 00 restore 200dfb4: 01 00 00 00 nop 0200ba6c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, boolean force ) { 200ba6c: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; States_Control current_state; _ISR_Disable( level ); 200ba70: 7f ff dc 2b call 2002b1c 200ba74: 01 00 00 00 nop 200ba78: a0 10 00 08 mov %o0, %l0 if ( force == TRUE ) 200ba7c: 80 a6 60 01 cmp %i1, 1 200ba80: 22 80 00 13 be,a 200bacc <_Thread_Resume+0x60> 200ba84: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 the_thread->suspend_count = 0; else the_thread->suspend_count--; 200ba88: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED 200ba8c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 200ba90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200ba94: 12 80 00 0c bne 200bac4 <_Thread_Resume+0x58> <== NOT EXECUTED 200ba98: c2 26 20 70 st %g1, [ %i0 + 0x70 ] <== NOT EXECUTED _ISR_Enable( level ); return; } current_state = the_thread->current_state; 200ba9c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 200baa0: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 200baa4: 02 80 00 06 be 200babc <_Thread_Resume+0x50> <== NOT EXECUTED 200baa8: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 200baac: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 200bab0: 80 a0 60 00 cmp %g1, 0 200bab4: 02 80 00 0b be 200bae0 <_Thread_Resume+0x74> 200bab8: c2 26 20 10 st %g1, [ %i0 + 0x10 ] _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 200babc: 7f ff dc 1c call 2002b2c 200bac0: 91 e8 00 10 restore %g0, %l0, %o0 the_thread->suspend_count = 0; else the_thread->suspend_count--; if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); 200bac4: 7f ff dc 1a call 2002b2c <== NOT EXECUTED 200bac8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { 200bacc: 80 88 60 02 btst 2, %g1 200bad0: 02 bf ff fb be 200babc <_Thread_Resume+0x50> 200bad4: c0 26 20 70 clr [ %i0 + 0x70 ] 200bad8: 10 bf ff f6 b 200bab0 <_Thread_Resume+0x44> 200badc: 82 08 7f fd and %g1, -3, %g1 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200bae0: c8 06 20 9c ld [ %i0 + 0x9c ], %g4 200bae4: c4 16 20 a2 lduh [ %i0 + 0xa2 ], %g2 200bae8: c2 11 00 00 lduh [ %g4 ], %g1 if ( _States_Is_ready( current_state ) ) { _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 200baec: c6 06 20 98 ld [ %i0 + 0x98 ], %g3 200baf0: 82 10 40 02 or %g1, %g2, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200baf4: 1b 00 80 99 sethi %hi(0x2026400), %o5 RTEMS_INLINE_ROUTINE void _Priority_Add_to_bit_map ( Priority_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 200baf8: c2 31 00 00 sth %g1, [ %g4 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200bafc: 82 00 e0 04 add %g3, 4, %g1 _Priority_Major_bit_map |= the_priority_map->ready_major; 200bb00: d8 16 20 a0 lduh [ %i0 + 0xa0 ], %o4 200bb04: c2 26 00 00 st %g1, [ %i0 ] 200bb08: c4 13 62 24 lduh [ %o5 + 0x224 ], %g2 old_last_node = the_chain->last; 200bb0c: c8 00 e0 08 ld [ %g3 + 8 ], %g4 the_chain->last = the_node; 200bb10: f0 20 e0 08 st %i0, [ %g3 + 8 ] 200bb14: 84 10 80 0c or %g2, %o4, %g2 old_last_node->next = the_node; the_node->previous = old_last_node; 200bb18: c8 26 20 04 st %g4, [ %i0 + 4 ] 200bb1c: c4 33 62 24 sth %g2, [ %o5 + 0x224 ] 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; 200bb20: f0 21 00 00 st %i0, [ %g4 ] _ISR_Flash( level ); 200bb24: 7f ff dc 02 call 2002b2c 200bb28: 90 10 00 10 mov %l0, %o0 200bb2c: 7f ff db fc call 2002b1c 200bb30: 01 00 00 00 nop if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 200bb34: 09 00 80 99 sethi %hi(0x2026400), %g4 200bb38: c4 01 22 08 ld [ %g4 + 0x208 ], %g2 ! 2026608 <_Thread_Heir> 200bb3c: c6 06 20 14 ld [ %i0 + 0x14 ], %g3 200bb40: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 200bb44: 80 a0 c0 01 cmp %g3, %g1 200bb48: 1a bf ff dd bcc 200babc <_Thread_Resume+0x50> 200bb4c: 01 00 00 00 nop _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200bb50: 03 00 80 99 sethi %hi(0x2026400), %g1 200bb54: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 2026630 <_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; 200bb58: f0 21 22 08 st %i0, [ %g4 + 0x208 ] if ( _Thread_Executing->is_preemptible || 200bb5c: c2 00 a0 7c ld [ %g2 + 0x7c ], %g1 200bb60: 80 a0 60 00 cmp %g1, 0 200bb64: 02 80 00 06 be 200bb7c <_Thread_Resume+0x110> 200bb68: 80 a0 e0 00 cmp %g3, 0 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200bb6c: 84 10 20 01 mov 1, %g2 200bb70: 03 00 80 99 sethi %hi(0x2026400), %g1 200bb74: c4 20 62 40 st %g2, [ %g1 + 0x240 ] ! 2026640 <_Context_Switch_necessary> 200bb78: 30 bf ff d1 b,a 200babc <_Thread_Resume+0x50> _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 200bb7c: 12 bf ff d0 bne 200babc <_Thread_Resume+0x50> 200bb80: 84 10 20 01 mov 1, %g2 the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 200bb84: 10 bf ff fc b 200bb74 <_Thread_Resume+0x108> <== NOT EXECUTED 200bb88: 03 00 80 99 sethi %hi(0x2026400), %g1 <== NOT EXECUTED 0200a1bc <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 200a1bc: 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 ) ) 200a1c0: 80 a6 6f ff cmp %i1, 0xfff 200a1c4: 28 80 00 02 bleu,a 200a1cc <_Thread_Stack_Allocate+0x10> 200a1c8: 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 ) { 200a1cc: 03 00 80 66 sethi %hi(0x2019800), %g1 200a1d0: c2 00 60 74 ld [ %g1 + 0x74 ], %g1 ! 2019874 <_CPU_Table+0x20> 200a1d4: 80 a0 60 00 cmp %g1, 0 200a1d8: 02 80 00 0a be 200a200 <_Thread_Stack_Allocate+0x44> 200a1dc: 92 06 60 10 add %i1, 0x10, %o1 stack_addr = (*_CPU_Table.stack_allocate_hook)( the_stack_size ); 200a1e0: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a1e4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 200a1e8: d0 26 20 dc st %o0, [ %i0 + 0xdc ] <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 200a1ec: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 200a1f0: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 200a1f4: b0 0e 40 18 and %i1, %i0, %i0 <== NOT EXECUTED 200a1f8: 81 c7 e0 08 ret <== NOT EXECUTED 200a1fc: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200a200: 11 00 80 66 sethi %hi(0x2019800), %o0 200a204: b2 10 00 09 mov %o1, %i1 200a208: 7f ff f4 41 call 200730c <_Heap_Allocate> 200a20c: 90 12 20 8c or %o0, 0x8c, %o0 } if ( !stack_addr ) the_stack_size = 0; the_thread->Start.stack = stack_addr; 200a210: 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 ) 200a214: 80 a0 00 08 cmp %g0, %o0 200a218: b0 60 20 00 subx %g0, 0, %i0 the_stack_size = 0; the_thread->Start.stack = stack_addr; return the_stack_size; } 200a21c: b0 0e 40 18 and %i1, %i0, %i0 200a220: 81 c7 e0 08 ret 200a224: 81 e8 00 00 restore 0200a228 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 200a228: 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 ) 200a22c: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 200a230: 80 a0 60 00 cmp %g1, 0 200a234: 02 80 00 08 be 200a254 <_Thread_Stack_Free+0x2c> 200a238: 03 00 80 66 sethi %hi(0x2019800), %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 ) 200a23c: c2 00 60 78 ld [ %g1 + 0x78 ], %g1 ! 2019878 <_CPU_Table+0x24> 200a240: 80 a0 60 00 cmp %g1, 0 200a244: 22 80 00 06 be,a 200a25c <_Thread_Stack_Free+0x34> 200a248: f2 06 20 d4 ld [ %i0 + 0xd4 ], %i1 (*_CPU_Table.stack_free_hook)( the_thread->Start.Initial_stack.area ); 200a24c: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a250: d0 06 20 d4 ld [ %i0 + 0xd4 ], %o0 <== NOT EXECUTED 200a254: 81 c7 e0 08 ret <== NOT EXECUTED 200a258: 81 e8 00 00 restore <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 200a25c: 31 00 80 66 sethi %hi(0x2019800), %i0 200a260: 7f ff f4 5d call 20073d4 <_Heap_Free> 200a264: 91 ee 20 8c restore %i0, 0x8c, %o0 200a268: 01 00 00 00 nop 0200a3b4 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 200a3b4: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 200a3b8: 03 00 80 66 sethi %hi(0x2019800), %g1 200a3bc: e0 00 61 20 ld [ %g1 + 0x120 ], %l0 ! 2019920 <_Thread_Executing> ready = executing->ready; _ISR_Disable( level ); 200a3c0: 7f ff de 8f call 2001dfc 200a3c4: e2 04 20 98 ld [ %l0 + 0x98 ], %l1 200a3c8: b0 10 00 08 mov %o0, %i0 if ( !_Chain_Has_only_one_node( ready ) ) { 200a3cc: c4 04 40 00 ld [ %l1 ], %g2 200a3d0: c2 04 60 08 ld [ %l1 + 8 ], %g1 200a3d4: 80 a0 80 01 cmp %g2, %g1 200a3d8: 12 80 00 0b bne 200a404 <_Thread_Yield_processor+0x50> 200a3dc: 03 00 80 66 sethi %hi(0x2019800), %g1 if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 200a3e0: c4 00 60 f8 ld [ %g1 + 0xf8 ], %g2 ! 20198f8 <_Thread_Heir> 200a3e4: 80 a4 00 02 cmp %l0, %g2 200a3e8: 02 80 00 05 be 200a3fc <_Thread_Yield_processor+0x48> 200a3ec: 01 00 00 00 nop _Context_Switch_necessary = TRUE; 200a3f0: 84 10 20 01 mov 1, %g2 ! 1 200a3f4: 03 00 80 66 sethi %hi(0x2019800), %g1 200a3f8: c4 20 61 30 st %g2, [ %g1 + 0x130 ] ! 2019930 <_Context_Switch_necessary> _ISR_Enable( level ); 200a3fc: 7f ff de 84 call 2001e0c 200a400: 81 e8 00 00 restore ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200a404: c6 04 00 00 ld [ %l0 ], %g3 previous = the_node->previous; 200a408: c4 04 20 04 ld [ %l0 + 4 ], %g2 Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200a40c: 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; 200a410: c6 20 80 00 st %g3, [ %g2 ] Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200a414: c2 24 00 00 st %g1, [ %l0 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200a418: 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; 200a41c: c2 04 60 08 ld [ %l1 + 8 ], %g1 the_chain->last = the_node; 200a420: e0 24 60 08 st %l0, [ %l1 + 8 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200a424: 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; 200a428: e0 20 40 00 st %l0, [ %g1 ] _ISR_Disable( level ); if ( !_Chain_Has_only_one_node( ready ) ) { _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 200a42c: 7f ff de 78 call 2001e0c 200a430: 01 00 00 00 nop 200a434: 7f ff de 72 call 2001dfc 200a438: 01 00 00 00 nop if ( _Thread_Is_heir( executing ) ) 200a43c: 05 00 80 66 sethi %hi(0x2019800), %g2 200a440: c2 00 a0 f8 ld [ %g2 + 0xf8 ], %g1 ! 20198f8 <_Thread_Heir> 200a444: 80 a4 00 01 cmp %l0, %g1 200a448: 32 bf ff eb bne,a 200a3f4 <_Thread_Yield_processor+0x40> 200a44c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; 200a450: c2 04 40 00 ld [ %l1 ], %g1 200a454: 10 bf ff e7 b 200a3f0 <_Thread_Yield_processor+0x3c> 200a458: c2 20 a0 f8 st %g1, [ %g2 + 0xf8 ] 02009748 <_Thread_queue_Dequeue>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2009748: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200974c: 80 a0 60 00 cmp %g1, 0 2009750: 12 80 00 05 bne 2009764 <_Thread_queue_Dequeue+0x1c> 2009754: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); 2009758: 82 13 c0 00 mov %o7, %g1 200975c: 40 00 10 e8 call 200dafc <_Thread_queue_Dequeue_fifo> 2009760: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 2009764: 02 80 00 04 be 2009774 <_Thread_queue_Dequeue+0x2c> 2009768: 01 00 00 00 nop the_thread = NULL; break; } return( the_thread ); } 200976c: 81 c3 e0 08 retl <== NOT EXECUTED 2009770: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_Dequeue_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_Dequeue_priority( the_thread_queue ); 2009774: 82 13 c0 00 mov %o7, %g1 2009778: 40 00 00 03 call 2009784 <_Thread_queue_Dequeue_priority> 200977c: 9e 10 40 00 mov %g1, %o7 2009780: 01 00 00 00 nop 0200dafc <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 200dafc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 200db00: 7f ff d0 bf call 2001dfc 200db04: a0 10 00 18 mov %i0, %l0 200db08: 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)); 200db0c: f0 06 00 00 ld [ %i0 ], %i0 if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 200db10: 82 04 20 04 add %l0, 4, %g1 200db14: 80 a6 00 01 cmp %i0, %g1 200db18: 22 80 00 1d be,a 200db8c <_Thread_queue_Dequeue_fifo+0x90> 200db1c: 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; 200db20: c2 06 00 00 ld [ %i0 ], %g1 the_chain->first = new_first; 200db24: 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 ) ) { 200db28: c4 06 20 50 ld [ %i0 + 0x50 ], %g2 new_first->previous = _Chain_Head(the_chain); 200db2c: e0 20 60 04 st %l0, [ %g1 + 4 ] 200db30: 80 a0 a0 02 cmp %g2, 2 200db34: 02 80 00 0a be 200db5c <_Thread_queue_Dequeue_fifo+0x60> 200db38: c0 26 20 44 clr [ %i0 + 0x44 ] _ISR_Enable( level ); 200db3c: 7f ff d0 b4 call 2001e0c 200db40: 01 00 00 00 nop RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200db44: 90 10 00 18 mov %i0, %o0 200db48: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200db4c: 7f ff ed 13 call 2008f98 <_Thread_Clear_state> 200db50: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 200db54: 81 c7 e0 08 ret 200db58: 81 e8 00 00 restore RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 200db5c: 82 10 20 03 mov 3, %g1 200db60: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200db64: 7f ff d0 aa call 2001e0c 200db68: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200db6c: 7f ff f3 8b call 200a998 <_Watchdog_Remove> 200db70: 90 06 20 48 add %i0, 0x48, %o0 200db74: 90 10 00 18 mov %i0, %o0 200db78: 13 04 00 ff sethi %hi(0x1003fc00), %o1 200db7c: 7f ff ed 07 call 2008f98 <_Thread_Clear_state> 200db80: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 200db84: 81 c7 e0 08 ret 200db88: 81 e8 00 00 restore #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200db8c: 80 a0 60 02 cmp %g1, 2 200db90: 18 80 00 0c bgu 200dbc0 <_Thread_queue_Dequeue_fifo+0xc4> 200db94: 80 a0 60 03 cmp %g1, 3 200db98: 80 a0 60 01 cmp %g1, 1 200db9c: 0a 80 00 0b bcs 200dbc8 <_Thread_queue_Dequeue_fifo+0xcc> 200dba0: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200dba4: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 200dba8: 7f ff d0 99 call 2001e0c <== NOT EXECUTED 200dbac: 01 00 00 00 nop <== NOT EXECUTED return _Thread_Executing; 200dbb0: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200dbb4: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_Thread_Executing> <== NOT EXECUTED } return NULL; /* this is only to prevent warnings */ } 200dbb8: 81 c7 e0 08 ret <== NOT EXECUTED 200dbbc: 81 e8 00 00 restore <== NOT EXECUTED #endif return the_thread; } switch ( the_thread_queue->sync_state ) { 200dbc0: 12 bf ff e5 bne 200db54 <_Thread_queue_Dequeue_fifo+0x58> <== NOT EXECUTED 200dbc4: b0 10 20 00 clr %i0 <== NOT EXECUTED case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 200dbc8: b0 10 20 00 clr %i0 200dbcc: 7f ff d0 90 call 2001e0c 200dbd0: 90 10 00 02 mov %g2, %o0 200dbd4: 81 c7 e0 08 ret 200dbd8: 81 e8 00 00 restore 02009784 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 2009784: 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 ); 2009788: 7f ff e1 9d call 2001dfc 200978c: 01 00 00 00 nop 2009790: 9a 10 00 08 mov %o0, %o5 2009794: 86 10 20 00 clr %g3 2009798: 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)); 200979c: 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 ] ) ) { 20097a0: 85 28 e0 02 sll %g3, 2, %g2 20097a4: 83 28 e0 04 sll %g3, 4, %g1 20097a8: 82 20 40 02 sub %g1, %g2, %g1 20097ac: 82 06 00 01 add %i0, %g1, %g1 20097b0: 82 00 60 04 add %g1, 4, %g1 20097b4: 80 a2 00 01 cmp %o0, %g1 20097b8: 12 80 00 50 bne 20098f8 <_Thread_queue_Dequeue_priority+0x174> 20097bc: 88 01 20 0c add %g4, 0xc, %g4 Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 20097c0: 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 ; 20097c4: 80 a0 e0 04 cmp %g3, 4 20097c8: 32 bf ff f6 bne,a 20097a0 <_Thread_queue_Dequeue_priority+0x1c> 20097cc: d0 01 00 18 ld [ %g4 + %i0 ], %o0 the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 20097d0: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 20097d4: 80 a0 60 02 cmp %g1, 2 20097d8: 08 80 00 23 bleu 2009864 <_Thread_queue_Dequeue_priority+0xe0> 20097dc: 80 a0 60 01 cmp %g1, 1 20097e0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 20097e4: 02 80 00 29 be 2009888 <_Thread_queue_Dequeue_priority+0x104> <== NOT EXECUTED 20097e8: b0 10 20 00 clr %i0 <== NOT EXECUTED return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; new_first_node = the_thread->Wait.Block2n.first; 20097ec: 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 ) ) { 20097f0: 82 06 20 3c add %i0, 0x3c, %g1 _ISR_Enable( level ); return _Thread_Executing; } dequeue: the_thread->Wait.queue = NULL; 20097f4: 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 ) ) { 20097f8: 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; 20097fc: c4 06 00 00 ld [ %i0 ], %g2 previous_node = the_thread->Object.Node.previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 2009800: 02 80 00 27 be 200989c <_Thread_queue_Dequeue_priority+0x118> 2009804: c2 06 20 04 ld [ %i0 + 4 ], %g1 last_node = the_thread->Wait.Block2n.last; 2009808: d8 06 20 40 ld [ %i0 + 0x40 ], %o4 new_second_node = new_first_node->next; 200980c: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 2009810: 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; 2009814: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 2009818: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200981c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 2009820: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 2009824: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2009828: 80 a0 80 01 cmp %g2, %g1 200982c: 12 80 00 2d bne 20098e0 <_Thread_queue_Dequeue_priority+0x15c> 2009830: 82 00 e0 38 add %g3, 0x38, %g1 } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 2009834: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 2009838: 80 a0 60 02 cmp %g1, 2 200983c: 02 80 00 1e be 20098b4 <_Thread_queue_Dequeue_priority+0x130> 2009840: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 2009844: 7f ff e1 72 call 2001e0c 2009848: 90 10 00 0d mov %o5, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200984c: 90 10 00 18 mov %i0, %o0 2009850: 13 04 00 ff sethi %hi(0x1003fc00), %o1 2009854: 7f ff fd d1 call 2008f98 <_Thread_Clear_state> 2009858: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 200985c: 81 c7 e0 08 ret 2009860: 81 e8 00 00 restore the_thread_queue->Queues.Priority[ index ].first; goto dequeue; } } switch ( the_thread_queue->sync_state ) { 2009864: 0a 80 00 09 bcs 2009888 <_Thread_queue_Dequeue_priority+0x104> 2009868: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); return NULL; case THREAD_QUEUE_NOTHING_HAPPENED: case THREAD_QUEUE_TIMEOUT: the_thread_queue->sync_state = THREAD_QUEUE_SATISFIED; 200986c: c2 26 20 30 st %g1, [ %i0 + 0x30 ] <== NOT EXECUTED _ISR_Enable( level ); 2009870: 7f ff e1 67 call 2001e0c <== NOT EXECUTED 2009874: 90 10 00 0d mov %o5, %o0 <== NOT EXECUTED return _Thread_Executing; 2009878: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200987c: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_Thread_Executing> <== NOT EXECUTED 2009880: 81 c7 e0 08 ret <== NOT EXECUTED 2009884: 81 e8 00 00 restore <== NOT EXECUTED } switch ( the_thread_queue->sync_state ) { case THREAD_QUEUE_SYNCHRONIZED: case THREAD_QUEUE_SATISFIED: _ISR_Enable( level ); 2009888: b0 10 20 00 clr %i0 200988c: 7f ff e1 60 call 2001e0c 2009890: 90 10 00 0d mov %o5, %o0 2009894: 81 c7 e0 08 ret 2009898: 81 e8 00 00 restore last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 200989c: 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; 20098a0: c4 20 40 00 st %g2, [ %g1 ] next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 20098a4: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 20098a8: 80 a0 60 02 cmp %g1, 2 20098ac: 12 bf ff e6 bne 2009844 <_Thread_queue_Dequeue_priority+0xc0> 20098b0: 82 10 20 03 mov 3, %g1 RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 20098b4: c2 26 20 50 st %g1, [ %i0 + 0x50 ] _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 20098b8: 7f ff e1 55 call 2001e0c 20098bc: 90 10 00 0d mov %o5, %o0 (void) _Watchdog_Remove( &the_thread->Timer ); 20098c0: 40 00 04 36 call 200a998 <_Watchdog_Remove> 20098c4: 90 06 20 48 add %i0, 0x48, %o0 20098c8: 90 10 00 18 mov %i0, %o0 20098cc: 13 04 00 ff sethi %hi(0x1003fc00), %o1 20098d0: 7f ff fd b2 call 2008f98 <_Thread_Clear_state> 20098d4: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 20098d8: 81 c7 e0 08 ret 20098dc: 81 e8 00 00 restore new_first_node->next = next_node; new_first_node->previous = previous_node; if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { /* > two threads on 2-n */ new_second_node->previous = 20098e0: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 20098e4: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] new_first_thread->Wait.Block2n.last = last_node; 20098e8: d8 20 e0 40 st %o4, [ %g3 + 0x40 ] last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 20098ec: 82 00 e0 3c add %g3, 0x3c, %g1 20098f0: 10 bf ff d1 b 2009834 <_Thread_queue_Dequeue_priority+0xb0> 20098f4: c2 23 00 00 st %g1, [ %o4 ] _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { the_thread = (Thread_Control *) 20098f8: 10 bf ff bd b 20097ec <_Thread_queue_Dequeue_priority+0x68> 20098fc: b0 10 00 08 mov %o0, %i0 0200dbdc <_Thread_queue_Enqueue_fifo>: void _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200dbdc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Thread_queue_States sync_state; _ISR_Disable( level ); 200dbe0: 7f ff d0 87 call 2001dfc 200dbe4: 01 00 00 00 nop sync_state = the_thread_queue->sync_state; 200dbe8: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; switch ( sync_state ) { 200dbec: 80 a0 a0 02 cmp %g2, 2 200dbf0: 02 80 00 22 be 200dc78 <_Thread_queue_Enqueue_fifo+0x9c> 200dbf4: c0 26 20 30 clr [ %i0 + 0x30 ] 200dbf8: 80 a0 a0 03 cmp %g2, 3 200dbfc: 02 80 00 11 be 200dc40 <_Thread_queue_Enqueue_fifo+0x64> 200dc00: 80 a0 a0 01 cmp %g2, 1 200dc04: 02 80 00 07 be 200dc20 <_Thread_queue_Enqueue_fifo+0x44> 200dc08: 82 06 20 04 add %i0, 4, %g1 200dc0c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200dc10: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200dc14: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200dc18: 7f ff ec e0 call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 200dc1c: 81 e8 00 00 restore <== NOT EXECUTED Chain_Node *the_node ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); 200dc20: c2 26 40 00 st %g1, [ %i1 ] old_last_node = the_chain->last; 200dc24: c4 06 20 08 ld [ %i0 + 8 ], %g2 the_chain->last = the_node; 200dc28: f2 26 20 08 st %i1, [ %i0 + 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; 200dc2c: f0 26 60 44 st %i0, [ %i1 + 0x44 ] old_last_node->next = the_node; the_node->previous = old_last_node; 200dc30: c4 26 60 04 st %g2, [ %i1 + 4 ] Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; the_chain->last = the_node; old_last_node->next = the_node; 200dc34: f2 20 80 00 st %i1, [ %g2 ] _ISR_Enable( level ); 200dc38: 7f ff d0 75 call 2001e0c 200dc3c: 91 e8 00 08 restore %g0, %o0, %o0 the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 200dc40: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 200dc44: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200dc48: 12 80 00 16 bne 200dca0 <_Thread_queue_Enqueue_fifo+0xc4> <== NOT EXECUTED 200dc4c: 01 00 00 00 nop <== NOT EXECUTED 200dc50: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 200dc54: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 200dc58: 7f ff d0 6d call 2001e0c <== NOT EXECUTED 200dc5c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 200dc60: 7f ff f3 4e call 200a998 <_Watchdog_Remove> <== NOT EXECUTED 200dc64: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 200dc68: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200dc6c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200dc70: 7f ff ec ca call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 200dc74: 81 e8 00 00 restore <== 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; 200dc78: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 200dc7c: 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; 200dc80: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 200dc84: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 200dc88: 7f ff d0 61 call 2001e0c <== NOT EXECUTED 200dc8c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200dc90: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200dc94: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200dc98: 7f ff ec c0 call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 200dc9c: 81 e8 00 00 restore <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 200dca0: 7f ff d0 5b call 2001e0c <== NOT EXECUTED 200dca4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 200dca8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 200dcac: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 200dcb0: 7f ff ec ba call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 200dcb4: 81 e8 00 00 restore <== NOT EXECUTED 200dcb8: 01 00 00 00 nop 02009984 <_Thread_queue_Enqueue_priority>: void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009984: 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; 2009988: 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); 200998c: 82 06 60 3c add %i1, 0x3c, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009990: 84 06 60 38 add %i1, 0x38, %g2 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009994: c2 26 60 38 st %g1, [ %i1 + 0x38 ] the_chain->permanent_null = NULL; 2009998: c0 26 60 3c clr [ %i1 + 0x3c ] the_chain->last = _Chain_Head(the_chain); 200999c: c4 26 60 40 st %g2, [ %i1 + 0x40 ] void _Thread_queue_Enqueue_priority( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 20099a0: aa 10 00 18 mov %i0, %l5 priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 20099a4: 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); 20099a8: 83 34 a0 06 srl %l2, 6, %g1 20099ac: 12 80 00 40 bne 2009aac <_Thread_queue_Enqueue_priority+0x128> 20099b0: e8 06 20 38 ld [ %i0 + 0x38 ], %l4 20099b4: 85 28 60 04 sll %g1, 4, %g2 20099b8: 83 28 60 02 sll %g1, 2, %g1 goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 20099bc: ac 20 80 01 sub %g2, %g1, %l6 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20099c0: 82 06 00 16 add %i0, %l6, %g1 20099c4: a6 00 60 04 add %g1, 4, %l3 if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 20099c8: 7f ff e1 0d call 2001dfc 20099cc: 01 00 00 00 nop 20099d0: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->first; 20099d4: e0 05 40 16 ld [ %l5 + %l6 ], %l0 while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 20099d8: 80 a4 00 13 cmp %l0, %l3 20099dc: 02 80 00 24 be 2009a6c <_Thread_queue_Enqueue_priority+0xe8> 20099e0: a2 10 3f ff mov -1, %l1 search_priority = search_thread->current_priority; 20099e4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 20099e8: 80 a4 80 11 cmp %l2, %l1 20099ec: 28 80 00 21 bleu,a 2009a70 <_Thread_queue_Enqueue_priority+0xec> 20099f0: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 20099f4: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 20099f8: 80 a4 c0 10 cmp %l3, %l0 20099fc: 32 80 00 19 bne,a 2009a60 <_Thread_queue_Enqueue_priority+0xdc> 2009a00: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009a04: 10 80 00 1b b 2009a70 <_Thread_queue_Enqueue_priority+0xec> 2009a08: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 2009a0c: 7f ff e1 00 call 2001e0c 2009a10: 90 10 00 18 mov %i0, %o0 2009a14: 7f ff e0 fa call 2001dfc 2009a18: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009a1c: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009a20: 80 8d 00 01 btst %l4, %g1 2009a24: 02 80 00 91 be 2009c68 <_Thread_queue_Enqueue_priority+0x2e4> 2009a28: 01 00 00 00 nop _ISR_Enable( level ); goto restart_forward_search; } search_thread = 2009a2c: e0 04 00 00 ld [ %l0 ], %l0 restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 2009a30: 80 a4 00 13 cmp %l0, %l3 2009a34: 22 80 00 0f be,a 2009a70 <_Thread_queue_Enqueue_priority+0xec> 2009a38: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 2009a3c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 2009a40: 80 a4 80 11 cmp %l2, %l1 2009a44: 28 80 00 0b bleu,a 2009a70 <_Thread_queue_Enqueue_priority+0xec> 2009a48: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.next; 2009a4c: e0 04 00 00 ld [ %l0 ], %l0 if ( _Chain_Is_tail( header, (Chain_Node *)search_thread ) ) 2009a50: 80 a4 00 13 cmp %l0, %l3 2009a54: 22 80 00 07 be,a 2009a70 <_Thread_queue_Enqueue_priority+0xec> 2009a58: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; 2009a5c: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority <= search_priority ) 2009a60: 80 a4 80 11 cmp %l2, %l1 2009a64: 18 bf ff ea bgu 2009a0c <_Thread_queue_Enqueue_priority+0x88> 2009a68: 01 00 00 00 nop } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009a6c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 2009a70: 80 a0 60 01 cmp %g1, 1 2009a74: 02 80 00 63 be 2009c00 <_Thread_queue_Enqueue_priority+0x27c> 2009a78: 80 a4 80 11 cmp %l2, %l1 return; synchronize: sync_state = the_thread_queue->sync_state; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 2009a7c: c0 25 60 30 clr [ %l5 + 0x30 ] <== NOT EXECUTED switch ( sync_state ) { 2009a80: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2009a84: 02 80 00 54 be 2009bd4 <_Thread_queue_Enqueue_priority+0x250> <== NOT EXECUTED 2009a88: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED 2009a8c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED 2009a90: 22 80 00 43 be,a 2009b9c <_Thread_queue_Enqueue_priority+0x218> <== NOT EXECUTED 2009a94: c2 06 60 50 ld [ %i1 + 0x50 ], %g1 <== NOT EXECUTED 2009a98: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009a9c: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009aa0: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009aa4: 7f ff fd 3d call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 2009aa8: 81 e8 00 00 restore <== NOT EXECUTED 2009aac: 85 28 60 04 sll %g1, 4, %g2 2009ab0: 83 28 60 02 sll %g1, 2, %g1 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 2009ab4: 82 20 80 01 sub %g2, %g1, %g1 2009ab8: a6 00 40 18 add %g1, %i0, %l3 return; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); 2009abc: 7f ff e0 d0 call 2001dfc 2009ac0: 01 00 00 00 nop 2009ac4: b0 10 00 08 mov %o0, %i0 search_thread = (Thread_Control *) header->last; 2009ac8: e0 04 e0 08 ld [ %l3 + 8 ], %l0 while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2009acc: 80 a4 00 13 cmp %l0, %l3 2009ad0: 02 80 00 24 be 2009b60 <_Thread_queue_Enqueue_priority+0x1dc> 2009ad4: a2 10 21 00 mov 0x100, %l1 search_priority = search_thread->current_priority; 2009ad8: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 if ( priority >= search_priority ) 2009adc: 80 a4 80 11 cmp %l2, %l1 2009ae0: 3a 80 00 21 bcc,a 2009b64 <_Thread_queue_Enqueue_priority+0x1e0> 2009ae4: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2009ae8: e0 04 20 04 ld [ %l0 + 4 ], %l0 if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2009aec: 80 a4 c0 10 cmp %l3, %l0 2009af0: 32 80 00 19 bne,a 2009b54 <_Thread_queue_Enqueue_priority+0x1d0> 2009af4: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009af8: 10 80 00 1b b 2009b64 <_Thread_queue_Enqueue_priority+0x1e0> 2009afc: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 2009b00: 7f ff e0 c3 call 2001e0c 2009b04: 90 10 00 18 mov %i0, %o0 2009b08: 7f ff e0 bd call 2001dfc 2009b0c: 01 00 00 00 nop if ( !_States_Are_set( search_thread->current_state, block_state) ) { 2009b10: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2009b14: 80 8d 00 01 btst %l4, %g1 2009b18: 02 80 00 57 be 2009c74 <_Thread_queue_Enqueue_priority+0x2f0> 2009b1c: 01 00 00 00 nop _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 2009b20: e0 04 20 04 ld [ %l0 + 4 ], %l0 restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 2009b24: 80 a4 00 13 cmp %l0, %l3 2009b28: 22 80 00 0f be,a 2009b64 <_Thread_queue_Enqueue_priority+0x1e0> 2009b2c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 search_priority = search_thread->current_priority; 2009b30: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 2009b34: 80 a4 80 11 cmp %l2, %l1 <== NOT EXECUTED 2009b38: 3a 80 00 0b bcc,a 2009b64 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 2009b3c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; #if ( CPU_UNROLL_ENQUEUE_PRIORITY == TRUE ) search_thread = (Thread_Control *) search_thread->Object.Node.previous; 2009b40: e0 04 20 04 ld [ %l0 + 4 ], %l0 <== NOT EXECUTED if ( _Chain_Is_head( header, (Chain_Node *)search_thread ) ) 2009b44: 80 a4 00 13 cmp %l0, %l3 <== NOT EXECUTED 2009b48: 22 80 00 07 be,a 2009b64 <_Thread_queue_Enqueue_priority+0x1e0> <== NOT EXECUTED 2009b4c: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 <== NOT EXECUTED break; search_priority = search_thread->current_priority; 2009b50: e2 04 20 14 ld [ %l0 + 0x14 ], %l1 <== NOT EXECUTED if ( priority >= search_priority ) 2009b54: 80 a4 80 11 cmp %l2, %l1 2009b58: 0a bf ff ea bcs 2009b00 <_Thread_queue_Enqueue_priority+0x17c> 2009b5c: 01 00 00 00 nop } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) 2009b60: c2 05 60 30 ld [ %l5 + 0x30 ], %g1 2009b64: 80 a0 60 01 cmp %g1, 1 2009b68: 12 bf ff c6 bne 2009a80 <_Thread_queue_Enqueue_priority+0xfc> 2009b6c: c0 25 60 30 clr [ %l5 + 0x30 ] goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009b70: 80 a4 80 11 cmp %l2, %l1 2009b74: 22 80 00 35 be,a 2009c48 <_Thread_queue_Enqueue_priority+0x2c4> 2009b78: 82 04 20 3c add %l0, 0x3c, %g1 goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 2009b7c: c2 04 00 00 ld [ %l0 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = next_node; the_node->previous = search_node; 2009b80: 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; 2009b84: 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; 2009b88: ea 26 60 44 st %l5, [ %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; 2009b8c: f2 24 00 00 st %i1, [ %l0 ] next_node->previous = the_node; 2009b90: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009b94: 7f ff e0 9e call 2001e0c 2009b98: 81 e8 00 00 restore the_thread->Wait.queue = NULL; _ISR_Enable( level ); break; case THREAD_QUEUE_SATISFIED: if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 2009b9c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2009ba0: 12 80 00 22 bne 2009c28 <_Thread_queue_Enqueue_priority+0x2a4> <== NOT EXECUTED 2009ba4: 01 00 00 00 nop <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 2009ba8: c4 26 60 50 st %g2, [ %i1 + 0x50 ] <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; 2009bac: c0 26 60 44 clr [ %i1 + 0x44 ] <== NOT EXECUTED _ISR_Enable( level ); 2009bb0: 7f ff e0 97 call 2001e0c <== NOT EXECUTED 2009bb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 2009bb8: 40 00 03 78 call 200a998 <_Watchdog_Remove> <== NOT EXECUTED 2009bbc: 90 06 60 48 add %i1, 0x48, %o0 <== NOT EXECUTED 2009bc0: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009bc4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009bc8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009bcc: 7f ff fc f3 call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 2009bd0: 81 e8 00 00 restore <== 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; 2009bd4: c4 06 60 44 ld [ %i1 + 0x44 ], %g2 <== NOT EXECUTED the_thread->Wait.queue = NULL; 2009bd8: 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; 2009bdc: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 <== NOT EXECUTED 2009be0: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED the_thread->Wait.queue = NULL; _ISR_Enable( level ); 2009be4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009be8: 7f ff e0 89 call 2001e0c <== NOT EXECUTED 2009bec: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009bf0: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009bf4: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009bf8: 7f ff fc e8 call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 2009bfc: 81 e8 00 00 restore <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_QUEUE_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; if ( priority == search_priority ) 2009c00: 02 80 00 11 be 2009c44 <_Thread_queue_Enqueue_priority+0x2c0> 2009c04: c0 25 60 30 clr [ %l5 + 0x30 ] goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 2009c08: c2 04 20 04 ld [ %l0 + 4 ], %g1 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009c0c: e0 26 40 00 st %l0, [ %i1 ] the_node->previous = previous_node; 2009c10: 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; 2009c14: ea 26 60 44 st %l5, [ %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; 2009c18: f2 20 40 00 st %i1, [ %g1 ] search_node->previous = the_node; 2009c1c: f2 24 20 04 st %i1, [ %l0 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009c20: 7f ff e0 7b call 2001e0c 2009c24: 81 e8 00 00 restore _Watchdog_Deactivate( &the_thread->Timer ); the_thread->Wait.queue = NULL; _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 2009c28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009c2c: 7f ff e0 78 call 2001e0c <== NOT EXECUTED 2009c30: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED 2009c34: 33 04 00 ff sethi %hi(0x1003fc00), %i1 <== NOT EXECUTED 2009c38: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <== NOT EXECUTED 2009c3c: 7f ff fc d7 call 2008f98 <_Thread_Clear_state> <== NOT EXECUTED 2009c40: 81 e8 00 00 restore <== NOT EXECUTED 2009c44: 82 04 20 3c add %l0, 0x3c, %g1 _ISR_Enable( level ); return; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 2009c48: c4 00 60 04 ld [ %g1 + 4 ], %g2 the_node = (Chain_Node *) the_thread; the_node->next = search_node; 2009c4c: c2 26 40 00 st %g1, [ %i1 ] the_node->previous = previous_node; 2009c50: 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; 2009c54: ea 26 60 44 st %l5, [ %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; 2009c58: f2 20 80 00 st %i1, [ %g2 ] search_node->previous = the_node; 2009c5c: f2 20 60 04 st %i1, [ %g1 + 4 ] the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); 2009c60: 7f ff e0 6b call 2001e0c 2009c64: 81 e8 00 00 restore if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 2009c68: 7f ff e0 69 call 2001e0c <== NOT EXECUTED 2009c6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009c70: 30 bf ff 56 b,a 20099c8 <_Thread_queue_Enqueue_priority+0x44> <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 2009c74: 7f ff e0 66 call 2001e0c <== NOT EXECUTED 2009c78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2009c7c: 30 bf ff 90 b,a 2009abc <_Thread_queue_Enqueue_priority+0x138> <== NOT EXECUTED 02009900 <_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 ) { 2009900: 9d e3 bf 98 save %sp, -104, %sp Thread_Control *the_thread; the_thread = _Thread_Executing; 2009904: 03 00 80 66 sethi %hi(0x2019800), %g1 else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 2009908: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 Thread_queue_Timeout_callout handler ) { Thread_Control *the_thread; the_thread = _Thread_Executing; 200990c: e0 00 61 20 ld [ %g1 + 0x120 ], %l0 void _Thread_queue_Enqueue_with_handler( Thread_queue_Control *the_thread_queue, Watchdog_Interval timeout, Thread_queue_Timeout_callout handler ) { 2009910: 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 ); 2009914: 40 00 01 9b call 2009f80 <_Thread_Set_state> 2009918: 90 10 00 10 mov %l0, %o0 /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 200991c: 80 a6 60 00 cmp %i1, 0 2009920: 32 80 00 0e bne,a 2009958 <_Thread_queue_Enqueue_with_handler+0x58> 2009924: c2 04 20 08 ld [ %l0 + 8 ], %g1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 2009928: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 200992c: 80 a0 60 00 cmp %g1, 0 2009930: 12 80 00 04 bne 2009940 <_Thread_queue_Enqueue_with_handler+0x40> 2009934: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); 2009938: 40 00 10 a9 call 200dbdc <_Thread_queue_Enqueue_fifo> 200993c: 93 e8 00 10 restore %g0, %l0, %o1 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 2009940: 02 80 00 04 be 2009950 <_Thread_queue_Enqueue_with_handler+0x50> 2009944: 01 00 00 00 nop 2009948: 81 c7 e0 08 ret <== NOT EXECUTED 200994c: 81 e8 00 00 restore <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Enqueue_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Enqueue_priority( the_thread_queue, the_thread ); 2009950: 40 00 00 0d call 2009984 <_Thread_queue_Enqueue_priority> 2009954: 93 e8 00 10 restore %g0, %l0, %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2009958: f4 24 20 64 st %i2, [ %l0 + 0x64 ] the_watchdog->id = id; 200995c: c2 24 20 68 st %g1, [ %l0 + 0x68 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2009960: f2 24 20 54 st %i1, [ %l0 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2009964: c0 24 20 50 clr [ %l0 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2009968: c0 24 20 6c clr [ %l0 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200996c: 11 00 80 66 sethi %hi(0x2019800), %o0 2009970: 92 04 20 48 add %l0, 0x48, %o1 2009974: 40 00 03 9f call 200a7f0 <_Watchdog_Insert> 2009978: 90 12 21 40 or %o0, 0x140, %o0 } /* * Now enqueue the thread per the discipline for this thread queue. */ switch( the_thread_queue->discipline ) { 200997c: 10 bf ff ec b 200992c <_Thread_queue_Enqueue_with_handler+0x2c> 2009980: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 0200dcbc <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200dcbc: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200dcc0: 80 a0 60 00 cmp %g1, 0 200dcc4: 12 80 00 05 bne 200dcd8 <_Thread_queue_Extract+0x1c> 200dcc8: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 200dccc: 82 13 c0 00 mov %o7, %g1 200dcd0: 40 00 04 9e call 200ef48 <_Thread_queue_Extract_fifo> 200dcd4: 9e 10 40 00 mov %g1, %o7 void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { switch ( the_thread_queue->discipline ) { 200dcd8: 02 80 00 04 be 200dce8 <_Thread_queue_Extract+0x2c> 200dcdc: 94 10 20 00 clr %o2 200dce0: 81 c3 e0 08 retl <== NOT EXECUTED 200dce4: 01 00 00 00 nop <== NOT EXECUTED case THREAD_QUEUE_DISCIPLINE_FIFO: _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 200dce8: 82 13 c0 00 mov %o7, %g1 200dcec: 40 00 00 03 call 200dcf8 <_Thread_queue_Extract_priority_helper> 200dcf0: 9e 10 40 00 mov %g1, %o7 200dcf4: 01 00 00 00 nop 0200ef48 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 200ef48: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; _ISR_Disable( level ); 200ef4c: 7f ff cb ac call 2001dfc 200ef50: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200ef54: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200ef58: 03 00 00 ef sethi %hi(0x3bc00), %g1 200ef5c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200ef60: 80 88 80 01 btst %g2, %g1 200ef64: 02 80 00 19 be 200efc8 <_Thread_queue_Extract_fifo+0x80> 200ef68: 01 00 00 00 nop ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 200ef6c: c2 06 40 00 ld [ %i1 ], %g1 previous = the_node->previous; 200ef70: 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 ) ) { 200ef74: c6 06 60 50 ld [ %i1 + 0x50 ], %g3 next->previous = previous; previous->next = next; 200ef78: c2 20 80 00 st %g1, [ %g2 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200ef7c: c4 20 60 04 st %g2, [ %g1 + 4 ] 200ef80: 80 a0 e0 02 cmp %g3, 2 200ef84: 12 80 00 0c bne 200efb4 <_Thread_queue_Extract_fifo+0x6c> 200ef88: c0 26 60 44 clr [ %i1 + 0x44 ] 200ef8c: 82 10 20 03 mov 3, %g1 200ef90: c2 26 60 50 st %g1, [ %i1 + 0x50 ] _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200ef94: 7f ff cb 9e call 2001e0c 200ef98: 01 00 00 00 nop (void) _Watchdog_Remove( &the_thread->Timer ); 200ef9c: 7f ff ee 7f call 200a998 <_Watchdog_Remove> 200efa0: 90 06 60 48 add %i1, 0x48, %o0 RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 200efa4: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200efa8: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200efac: 7f ff e7 fb call 2008f98 <_Thread_Clear_state> 200efb0: 81 e8 00 00 restore _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); 200efb4: 7f ff cb 96 call 2001e0c 200efb8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200efbc: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200efc0: 7f ff e7 f6 call 2008f98 <_Thread_Clear_state> 200efc4: 81 e8 00 00 restore ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200efc8: 7f ff cb 91 call 2001e0c <== NOT EXECUTED 200efcc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200efd0: 01 00 00 00 nop 0200dcf8 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, boolean requeuing ) { 200dcf8: 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 ); 200dcfc: 7f ff d0 40 call 2001dfc 200dd00: b0 10 00 19 mov %i1, %i0 if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 200dd04: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 200dd08: 03 00 00 ef sethi %hi(0x3bc00), %g1 200dd0c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 200dd10: 80 88 80 01 btst %g2, %g1 200dd14: 02 80 00 29 be 200ddb8 <_Thread_queue_Extract_priority_helper+0xc0> 200dd18: 82 06 60 3c add %i1, 0x3c, %g1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 200dd1c: c6 06 60 38 ld [ %i1 + 0x38 ], %g3 /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 200dd20: c4 06 40 00 ld [ %i1 ], %g2 previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 200dd24: 80 a0 c0 01 cmp %g3, %g1 200dd28: 12 80 00 10 bne 200dd68 <_Thread_queue_Extract_priority_helper+0x70> 200dd2c: c2 06 60 04 ld [ %i1 + 4 ], %g1 new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; next_node->previous = previous_node; 200dd30: 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; 200dd34: c4 20 40 00 st %g2, [ %g1 ] /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200dd38: 80 a6 a0 00 cmp %i2, 0 200dd3c: 12 80 00 1d bne 200ddb0 <_Thread_queue_Extract_priority_helper+0xb8> 200dd40: 01 00 00 00 nop _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 200dd44: c2 06 20 50 ld [ %i0 + 0x50 ], %g1 200dd48: 80 a0 60 02 cmp %g1, 2 200dd4c: 02 80 00 1d be 200ddc0 <_Thread_queue_Extract_priority_helper+0xc8> 200dd50: 82 10 20 03 mov 3, %g1 _ISR_Enable( level ); 200dd54: 7f ff d0 2e call 2001e0c 200dd58: 33 04 00 ff sethi %hi(0x1003fc00), %i1 200dd5c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 200dd60: 7f ff ec 8e call 2008f98 <_Thread_Clear_state> 200dd64: 81 e8 00 00 restore previous_node = the_node->previous; if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 200dd68: da 06 60 40 ld [ %i1 + 0x40 ], %o5 new_second_node = new_first_node->next; 200dd6c: c8 00 c0 00 ld [ %g3 ], %g4 previous_node->next = new_first_node; next_node->previous = new_first_node; 200dd70: 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; 200dd74: c6 20 40 00 st %g3, [ %g1 ] next_node->previous = new_first_node; new_first_node->next = next_node; 200dd78: c4 20 c0 00 st %g2, [ %g3 ] new_first_node->previous = previous_node; 200dd7c: c2 20 e0 04 st %g1, [ %g3 + 4 ] if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 200dd80: c4 06 60 38 ld [ %i1 + 0x38 ], %g2 200dd84: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 200dd88: 80 a0 80 01 cmp %g2, %g1 200dd8c: 02 bf ff ec be 200dd3c <_Thread_queue_Extract_priority_helper+0x44> 200dd90: 80 a6 a0 00 cmp %i2, 0 /* > two threads on 2-n */ new_second_node->previous = 200dd94: 82 00 e0 38 add %g3, 0x38, %g1 <== NOT EXECUTED 200dd98: 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; 200dd9c: c8 20 e0 38 st %g4, [ %g3 + 0x38 ] <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 200dda0: da 20 e0 40 st %o5, [ %g3 + 0x40 ] <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 200dda4: 82 00 e0 3c add %g3, 0x3c, %g1 <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 200dda8: 02 bf ff e7 be 200dd44 <_Thread_queue_Extract_priority_helper+0x4c> <== NOT EXECUTED 200ddac: c2 23 40 00 st %g1, [ %o5 ] <== NOT EXECUTED _ISR_Enable( level ); 200ddb0: 7f ff d0 17 call 2001e0c 200ddb4: 91 e8 00 08 restore %g0, %o0, %o0 Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 200ddb8: 7f ff d0 15 call 2001e0c <== NOT EXECUTED 200ddbc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 200ddc0: c2 26 20 50 st %g1, [ %i0 + 0x50 ] if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 200ddc4: 7f ff d0 12 call 2001e0c 200ddc8: 33 04 00 ff sethi %hi(0x1003fc00), %i1 (void) _Watchdog_Remove( &the_thread->Timer ); 200ddcc: 7f ff f2 f3 call 200a998 <_Watchdog_Remove> 200ddd0: 90 06 20 48 add %i0, 0x48, %o0 200ddd4: b2 16 63 f8 or %i1, 0x3f8, %i1 200ddd8: 7f ff ec 70 call 2008f98 <_Thread_Clear_state> 200dddc: 81 e8 00 00 restore 200dde0: 01 00 00 00 nop 02009c80 <_Thread_queue_Extract_with_proxy>: */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009c80: 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; 2009c84: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 */ boolean _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 2009c88: 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 ) ) { 2009c8c: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009c90: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009c94: 80 88 80 01 btst %g2, %g1 2009c98: 02 80 00 1e be 2009d10 <_Thread_queue_Extract_with_proxy+0x90> 2009c9c: b0 10 20 00 clr %i0 if ( _States_Is_waiting_for_rpc_reply( state ) && 2009ca0: 03 00 00 08 sethi %hi(0x2000), %g1 2009ca4: 80 88 80 01 btst %g2, %g1 2009ca8: 22 80 00 17 be,a 2009d04 <_Thread_queue_Extract_with_proxy+0x84> 2009cac: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 2009cb0: 03 00 00 e7 sethi %hi(0x39c00), %g1 <== NOT EXECUTED 2009cb4: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 39ee0 <== NOT EXECUTED 2009cb8: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2009cbc: 22 80 00 12 be,a 2009d04 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009cc0: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED _States_Is_locally_blocked( state ) ) { the_information = _Objects_Get_information( the_thread->Wait.id ); 2009cc4: c6 04 20 20 ld [ %l0 + 0x20 ], %g3 <== NOT EXECUTED proxy_extract_callout = 2009cc8: 03 00 80 65 sethi %hi(0x2019400), %g1 <== NOT EXECUTED 2009ccc: 85 30 e0 16 srl %g3, 0x16, %g2 <== NOT EXECUTED 2009cd0: 82 10 63 a0 or %g1, 0x3a0, %g1 <== NOT EXECUTED 2009cd4: 84 08 a0 1c and %g2, 0x1c, %g2 <== NOT EXECUTED 2009cd8: c8 00 40 02 ld [ %g1 + %g2 ], %g4 <== NOT EXECUTED 2009cdc: 87 30 e0 1b srl %g3, 0x1b, %g3 <== NOT EXECUTED 2009ce0: 87 28 e0 02 sll %g3, 2, %g3 <== NOT EXECUTED 2009ce4: c2 01 00 03 ld [ %g4 + %g3 ], %g1 <== NOT EXECUTED 2009ce8: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 <== NOT EXECUTED (Objects_Thread_queue_Extract_callout) the_information->extract; if ( proxy_extract_callout ) 2009cec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2009cf0: 22 80 00 05 be,a 2009d04 <_Thread_queue_Extract_with_proxy+0x84> <== NOT EXECUTED 2009cf4: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED (*proxy_extract_callout)( the_thread ); 2009cf8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2009cfc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2009d00: d0 04 20 44 ld [ %l0 + 0x44 ], %o0 <== NOT EXECUTED 2009d04: 92 10 00 10 mov %l0, %o1 2009d08: 40 00 0f ed call 200dcbc <_Thread_queue_Extract> 2009d0c: b0 10 20 01 mov 1, %i0 return TRUE; } return FALSE; } 2009d10: 81 c7 e0 08 ret 2009d14: 81 e8 00 00 restore 0200c4f4 <_Thread_queue_First>: Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 200c4f4: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 200c4f8: 80 a0 60 00 cmp %g1, 0 200c4fc: 12 80 00 05 bne 200c510 <_Thread_queue_First+0x1c> 200c500: 80 a0 60 01 cmp %g1, 1 case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); 200c504: 82 13 c0 00 mov %o7, %g1 200c508: 40 00 10 94 call 2010758 <_Thread_queue_First_fifo> 200c50c: 9e 10 40 00 mov %g1, %o7 Thread_queue_Control *the_thread_queue ) { Thread_Control *the_thread; switch ( the_thread_queue->discipline ) { 200c510: 02 80 00 04 be 200c520 <_Thread_queue_First+0x2c> 200c514: 01 00 00 00 nop the_thread = NULL; break; } return the_thread; } 200c518: 81 c3 e0 08 retl <== NOT EXECUTED 200c51c: 90 10 20 00 clr %o0 ! 0 <== NOT EXECUTED switch ( the_thread_queue->discipline ) { case THREAD_QUEUE_DISCIPLINE_FIFO: the_thread = _Thread_queue_First_fifo( the_thread_queue ); break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: the_thread = _Thread_queue_First_priority( the_thread_queue ); 200c520: 82 13 c0 00 mov %o7, %g1 200c524: 40 00 00 03 call 200c530 <_Thread_queue_First_priority> 200c528: 9e 10 40 00 mov %g1, %o7 200c52c: 01 00 00 00 nop 02009d38 <_Thread_queue_Initialize>: uint32_t timeout_status ) { uint32_t index; the_thread_queue->state = state; 2009d38: d4 22 20 38 st %o2, [ %o0 + 0x38 ] the_thread_queue->discipline = the_discipline; the_thread_queue->timeout_status = timeout_status; 2009d3c: d6 22 20 3c st %o3, [ %o0 + 0x3c ] the_thread_queue->sync_state = THREAD_QUEUE_SYNCHRONIZED; 2009d40: c0 22 20 30 clr [ %o0 + 0x30 ] switch ( the_discipline ) { 2009d44: 80 a2 60 00 cmp %o1, 0 2009d48: 12 80 00 07 bne 2009d64 <_Thread_queue_Initialize+0x2c> 2009d4c: d2 22 20 34 st %o1, [ %o0 + 0x34 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d50: 82 02 20 04 add %o0, 4, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d54: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009d58: c0 22 20 04 clr [ %o0 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d5c: 81 c3 e0 08 retl 2009d60: c2 22 00 00 st %g1, [ %o0 ] 2009d64: 80 a2 60 01 cmp %o1, 1 2009d68: 02 80 00 04 be 2009d78 <_Thread_queue_Initialize+0x40> 2009d6c: 82 02 20 04 add %o0, 4, %g1 2009d70: 81 c3 e0 08 retl <== NOT EXECUTED 2009d74: 01 00 00 00 nop <== NOT EXECUTED 2009d78: 84 02 20 10 add %o0, 0x10, %g2 2009d7c: c2 22 00 00 st %g1, [ %o0 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d80: 82 02 20 0c add %o0, 0xc, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d84: c4 22 20 0c st %g2, [ %o0 + 0xc ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d88: c2 22 20 14 st %g1, [ %o0 + 0x14 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d8c: 84 02 20 1c add %o0, 0x1c, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d90: 82 02 20 18 add %o0, 0x18, %g1 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d94: c4 22 20 18 st %g2, [ %o0 + 0x18 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009d98: c2 22 20 20 st %g1, [ %o0 + 0x20 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009d9c: 84 02 20 28 add %o0, 0x28, %g2 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009da0: 82 02 20 24 add %o0, 0x24, %g1 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009da4: c0 22 20 04 clr [ %o0 + 4 ] the_chain->last = _Chain_Head(the_chain); 2009da8: d0 22 20 08 st %o0, [ %o0 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 2009dac: c0 22 20 10 clr [ %o0 + 0x10 ] 2009db0: c0 22 20 1c clr [ %o0 + 0x1c ] 2009db4: c0 22 20 28 clr [ %o0 + 0x28 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 2009db8: c4 22 20 24 st %g2, [ %o0 + 0x24 ] the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 2009dbc: 81 c3 e0 08 retl 2009dc0: c2 22 20 2c st %g1, [ %o0 + 0x2c ] 02009dc4 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 2009dc4: 9d e3 bf 98 save %sp, -104, %sp /* just in case the thread really wasn't blocked here */ if ( !the_thread_queue ) { 2009dc8: 80 a6 20 00 cmp %i0, 0 2009dcc: 02 80 00 06 be 2009de4 <_Thread_queue_Requeue+0x20> 2009dd0: 01 00 00 00 nop return; } switch ( the_thread_queue->discipline ) { 2009dd4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0 2009dd8: 80 a4 20 01 cmp %l0, 1 2009ddc: 02 80 00 04 be 2009dec <_Thread_queue_Requeue+0x28> 2009de0: 01 00 00 00 nop 2009de4: 81 c7 e0 08 ret <== NOT EXECUTED 2009de8: 81 e8 00 00 restore <== NOT EXECUTED break; case THREAD_QUEUE_DISCIPLINE_PRIORITY: { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; _ISR_Disable( level ); 2009dec: 7f ff e0 04 call 2001dfc 2009df0: 01 00 00 00 nop 2009df4: a2 10 00 08 mov %o0, %l1 if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 2009df8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 2009dfc: 03 00 00 ef sethi %hi(0x3bc00), %g1 2009e00: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 2009e04: 80 88 80 01 btst %g2, %g1 2009e08: 12 80 00 04 bne 2009e18 <_Thread_queue_Requeue+0x54> 2009e0c: 94 10 20 01 mov 1, %o2 _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); _Thread_queue_Enqueue_priority( tq, the_thread ); } _ISR_Enable( level ); 2009e10: 7f ff df ff call 2001e0c <== NOT EXECUTED 2009e14: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 2009e18: 90 10 00 18 mov %i0, %o0 2009e1c: 92 10 00 19 mov %i1, %o1 2009e20: 40 00 0f b6 call 200dcf8 <_Thread_queue_Extract_priority_helper> 2009e24: e0 26 20 30 st %l0, [ %i0 + 0x30 ] _Thread_queue_Enqueue_priority( tq, the_thread ); 2009e28: 90 10 00 18 mov %i0, %o0 2009e2c: 7f ff fe d6 call 2009984 <_Thread_queue_Enqueue_priority> 2009e30: 92 10 00 19 mov %i1, %o1 } _ISR_Enable( level ); 2009e34: 7f ff df f6 call 2001e0c 2009e38: 91 e8 00 11 restore %g0, %l1, %o0 2009e3c: 01 00 00 00 nop 02009e40 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 2009e40: 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 ) ) { 2009e44: 92 96 20 00 orcc %i0, 0, %o1 2009e48: 12 80 00 1a bne 2009eb0 <_Thread_queue_Timeout+0x70> 2009e4c: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2009e50: 31 00 80 66 sethi %hi(0x2019800), %i0 <== NOT EXECUTED 2009e54: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2009e58: 82 00 60 01 inc %g1 <== NOT EXECUTED 2009e5c: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== 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; 2009e60: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 2009e64: d2 00 61 20 ld [ %g1 + 0x120 ], %o1 ! 2019920 <_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; 2009e68: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED */ static inline void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 2009e6c: d0 02 60 44 ld [ %o1 + 0x44 ], %o0 * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && 2009e70: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 2009e74: 80 a0 e0 00 cmp %g3, 0 2009e78: 02 80 00 06 be 2009e90 <_Thread_queue_Timeout+0x50> 2009e7c: 03 00 80 66 sethi %hi(0x2019800), %g1 2009e80: c4 00 61 20 ld [ %g1 + 0x120 ], %g2 ! 2019920 <_Thread_Executing> <== NOT EXECUTED 2009e84: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED 2009e88: 02 80 00 20 be 2009f08 <_Thread_queue_Timeout+0xc8> <== NOT EXECUTED 2009e8c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 2009e90: c2 02 20 3c ld [ %o0 + 0x3c ], %g1 _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 2009e94: 40 00 0f 8a call 200dcbc <_Thread_queue_Extract> 2009e98: 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; 2009e9c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 2009ea0: 82 00 7f ff add %g1, -1, %g1 2009ea4: c2 26 20 40 st %g1, [ %i0 + 0x40 ] 2009ea8: 81 c7 e0 08 ret 2009eac: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2009eb0: 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 ) { 2009eb4: 80 a0 a0 04 cmp %g2, 4 2009eb8: 18 bf ff fc bgu 2009ea8 <_Thread_queue_Timeout+0x68> 2009ebc: 83 32 60 1b srl %o1, 0x1b, %g1 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2009ec0: 80 a0 60 01 cmp %g1, 1 2009ec4: 12 bf ff f9 bne 2009ea8 <_Thread_queue_Timeout+0x68> 2009ec8: 83 28 a0 02 sll %g2, 2, %g1 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2009ecc: 05 00 80 65 sethi %hi(0x2019400), %g2 2009ed0: 84 10 a3 a0 or %g2, 0x3a0, %g2 ! 20197a0 <_Objects_Information_table> 2009ed4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2009ed8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2009edc: 80 a2 20 00 cmp %o0, 0 2009ee0: 02 bf ff f2 be 2009ea8 <_Thread_queue_Timeout+0x68> 2009ee4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2009ee8: 7f ff f7 b9 call 2007dcc <_Objects_Get> 2009eec: 94 07 bf f4 add %fp, -12, %o2 Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2009ef0: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009ef4: 80 a0 60 00 cmp %g1, 0 2009ef8: 12 bf ff ec bne 2009ea8 <_Thread_queue_Timeout+0x68> 2009efc: 92 10 00 08 mov %o0, %o1 2009f00: 10 bf ff db b 2009e6c <_Thread_queue_Timeout+0x2c> 2009f04: 31 00 80 66 sethi %hi(0x2019800), %i0 * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_QUEUE_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_QUEUE_SATISFIED ) 2009f08: 02 bf ff e5 be 2009e9c <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 2009f0c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED the_thread_queue->sync_state = THREAD_QUEUE_TIMEOUT; 2009f10: 10 bf ff e3 b 2009e9c <_Thread_queue_Timeout+0x5c> <== NOT EXECUTED 2009f14: c2 22 20 30 st %g1, [ %o0 + 0x30 ] <== NOT EXECUTED 02013434 <_Timer_Server_body>: */ Thread _Timer_Server_body( uint32_t ignored ) { 2013434: 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; 2013438: 03 00 80 ce sethi %hi(0x2033800), %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201343c: 21 00 80 ce sethi %hi(0x2033800), %l0 2013440: c6 00 62 e4 ld [ %g1 + 0x2e4 ], %g3 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2013444: 05 00 80 ce sethi %hi(0x2033800), %g2 2013448: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 201344c: c8 00 a2 1c ld [ %g2 + 0x21c ], %g4 /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 2013450: 05 00 80 ce sethi %hi(0x2033800), %g2 2013454: 82 00 60 01 inc %g1 2013458: c6 20 a0 70 st %g3, [ %g2 + 0x70 ] 201345c: c2 24 21 60 st %g1, [ %l0 + 0x160 ] _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 2013460: 05 00 80 ce sethi %hi(0x2033800), %g2 2013464: c8 20 a0 6c st %g4, [ %g2 + 0x6c ] ! 203386c <_Timer_Server_seconds_last_time> RTEMS_COMPILER_MEMORY_BARRIER(); 2013468: 03 00 80 ce sethi %hi(0x2033800), %g1 201346c: 05 00 80 ce sethi %hi(0x2033800), %g2 2013470: ba 10 60 64 or %g1, 0x64, %i5 2013474: 03 00 80 ce sethi %hi(0x2033800), %g1 2013478: 39 00 80 d0 sethi %hi(0x2034000), %i4 /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 201347c: b4 10 a2 60 or %g2, 0x260, %i2 2013480: ae 10 60 78 or %g1, 0x78, %l7 2013484: 05 00 80 ce sethi %hi(0x2033800), %g2 2013488: 03 00 80 ce sethi %hi(0x2033800), %g1 201348c: a6 10 a0 80 or %g2, 0x80, %l3 2013490: b6 10 62 54 or %g1, 0x254, %i3 2013494: 2d 00 80 ce sethi %hi(0x2033800), %l6 2013498: 2b 00 80 ce sethi %hi(0x2033800), %l5 201349c: a4 10 00 1c mov %i4, %l2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20134a0: a2 10 00 10 mov %l0, %l1 20134a4: 10 80 00 18 b 2013504 <_Timer_Server_body+0xd0> 20134a8: a8 10 00 13 mov %l3, %l4 _Timer_Server_reset_ticks_timer(); _Timer_Server_reset_seconds_timer(); 20134ac: 80 a0 40 17 cmp %g1, %l7 20134b0: 32 80 00 27 bne,a 201354c <_Timer_Server_body+0x118> 20134b4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED 20134b8: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 20134bc: 82 00 7f ff add %g1, -1, %g1 20134c0: c2 24 21 60 st %g1, [ %l0 + 0x160 ] 20134c4: c4 04 21 60 ld [ %l0 + 0x160 ], %g2 20134c8: 80 a0 a0 00 cmp %g2, 0 20134cc: 02 80 00 2b be 2013578 <_Timer_Server_body+0x144> 20134d0: 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(); 20134d4: d0 04 a3 e8 ld [ %l2 + 0x3e8 ], %o0 <== NOT EXECUTED 20134d8: 40 00 14 81 call 20186dc <_Watchdog_Remove> 20134dc: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_stop_seconds_timer(); 20134e0: 40 00 14 7f call 20186dc <_Watchdog_Remove> 20134e4: 90 10 00 14 mov %l4, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20134e8: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 20134ec: 82 00 60 01 inc %g1 20134f0: c2 24 61 60 st %g1, [ %l1 + 0x160 ] * 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(); 20134f4: 7f ff ff bf call 20133f0 <_Timer_Server_process_ticks_chain> 20134f8: 01 00 00 00 nop _Timer_Server_process_seconds_chain(); 20134fc: 7f ff ff a2 call 2013384 <_Timer_Server_process_seconds_chain> 2013500: 01 00 00 00 nop /* * Block until there is something to do. */ _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 2013504: d0 07 23 e8 ld [ %i4 + 0x3e8 ], %o0 2013508: 40 00 11 1b call 2017974 <_Thread_Set_state> 201350c: 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)); 2013510: c2 05 a0 60 ld [ %l6 + 0x60 ], %g1 _Timer_Server_reset_ticks_timer(); 2013514: 80 a0 40 1d cmp %g1, %i5 2013518: 22 bf ff e5 be,a 20134ac <_Timer_Server_body+0x78> 201351c: c2 05 60 74 ld [ %l5 + 0x74 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013520: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 2013524: d2 04 a3 e8 ld [ %l2 + 0x3e8 ], %o1 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013528: 90 10 00 1a mov %i2, %o0 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 201352c: c2 22 60 54 st %g1, [ %o1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013530: 40 00 14 01 call 2018534 <_Watchdog_Insert> 2013534: 92 02 60 48 add %o1, 0x48, %o1 2013538: c2 05 60 74 ld [ %l5 + 0x74 ], %g1 _Timer_Server_reset_seconds_timer(); 201353c: 80 a0 40 17 cmp %g1, %l7 2013540: 02 bf ff de be 20134b8 <_Timer_Server_body+0x84> 2013544: 01 00 00 00 nop Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013548: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 201354c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013550: c2 24 e0 0c st %g1, [ %l3 + 0xc ] <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 2013554: 40 00 13 f8 call 2018534 <_Watchdog_Insert> <== NOT EXECUTED 2013558: 92 10 00 13 mov %l3, %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 ) 201355c: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 <== NOT EXECUTED 2013560: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2013564: c2 24 21 60 st %g1, [ %l0 + 0x160 ] <== NOT EXECUTED 2013568: c4 04 21 60 ld [ %l0 + 0x160 ], %g2 <== NOT EXECUTED 201356c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2013570: 32 bf ff da bne,a 20134d8 <_Timer_Server_body+0xa4> <== NOT EXECUTED 2013574: d0 04 a3 e8 ld [ %l2 + 0x3e8 ], %o0 <== NOT EXECUTED _Thread_Dispatch(); 2013578: 40 00 0d 5b call 2016ae4 <_Thread_Dispatch> 201357c: 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(); 2013580: 10 bf ff d6 b 20134d8 <_Timer_Server_body+0xa4> 2013584: d0 04 a3 e8 ld [ %l2 + 0x3e8 ], %o0 020133f0 <_Timer_Server_process_ticks_chain>: void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20133f0: 03 00 80 ce sethi %hi(0x2033800), %g1 if ( snapshot >= _Timer_Server_ticks_last_time ) 20133f4: 07 00 80 ce sethi %hi(0x2033800), %g3 void _Timer_Server_process_ticks_chain(void) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 20133f8: c4 00 62 e4 ld [ %g1 + 0x2e4 ], %g2 if ( snapshot >= _Timer_Server_ticks_last_time ) 20133fc: c2 00 e0 70 ld [ %g3 + 0x70 ], %g1 2013400: 80 a0 80 01 cmp %g2, %g1 2013404: 1a 80 00 04 bcc 2013414 <_Timer_Server_process_ticks_chain+0x24> 2013408: 94 20 80 01 sub %g2, %g1, %o2 ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 201340c: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED 2013410: 94 00 40 02 add %g1, %g2, %o2 <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 2013414: 11 00 80 ce sethi %hi(0x2033800), %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; 2013418: c4 20 e0 70 st %g2, [ %g3 + 0x70 ] _Watchdog_Adjust( &_Timer_Ticks_chain, WATCHDOG_FORWARD, ticks ); 201341c: 90 12 20 60 or %o0, 0x60, %o0 2013420: 92 10 20 00 clr %o1 2013424: 82 13 c0 00 mov %o7, %g1 2013428: 40 00 14 12 call 2018470 <_Watchdog_Adjust> 201342c: 9e 10 40 00 mov %g1, %o7 2013430: 01 00 00 00 nop 0200c2ec <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 200c2ec: 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; 200c2f0: 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; 200c2f4: de 06 20 04 ld [ %i0 + 4 ], %o7 right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 200c2f8: 96 10 00 01 mov %g1, %o3 200c2fc: 95 38 60 1f sra %g1, 0x1f, %o2 200c300: 83 30 60 1d srl %g1, 0x1d, %g1 200c304: 9b 2a e0 03 sll %o3, 3, %o5 200c308: 99 2a a0 03 sll %o2, 3, %o4 200c30c: 98 10 40 0c or %g1, %o4, %o4 200c310: 83 33 60 1b srl %o5, 0x1b, %g1 200c314: 85 2b 20 05 sll %o4, 5, %g2 200c318: 87 2b 60 05 sll %o5, 5, %g3 200c31c: 84 10 40 02 or %g1, %g2, %g2 200c320: 86 a0 c0 0d subcc %g3, %o5, %g3 200c324: 83 30 e0 1a srl %g3, 0x1a, %g1 200c328: 84 60 80 0c subx %g2, %o4, %g2 200c32c: 9b 28 e0 06 sll %g3, 6, %o5 200c330: 99 28 a0 06 sll %g2, 6, %o4 200c334: 9a a3 40 03 subcc %o5, %g3, %o5 200c338: 98 10 40 0c or %g1, %o4, %o4 200c33c: 98 63 00 02 subx %o4, %g2, %o4 200c340: 9a 83 40 0b addcc %o5, %o3, %o5 200c344: 83 33 60 1e srl %o5, 0x1e, %g1 200c348: 98 43 00 0a addx %o4, %o2, %o4 200c34c: 87 2b 60 02 sll %o5, 2, %g3 200c350: 85 2b 20 02 sll %o4, 2, %g2 200c354: 9a 83 40 03 addcc %o5, %g3, %o5 200c358: 84 10 40 02 or %g1, %g2, %g2 200c35c: 83 33 60 1e srl %o5, 0x1e, %g1 200c360: 98 43 00 02 addx %o4, %g2, %o4 200c364: 87 2b 60 02 sll %o5, 2, %g3 200c368: 85 2b 20 02 sll %o4, 2, %g2 200c36c: 9a 83 40 03 addcc %o5, %g3, %o5 200c370: 84 10 40 02 or %g1, %g2, %g2 200c374: 83 33 60 1e srl %o5, 0x1e, %g1 200c378: 98 43 00 02 addx %o4, %g2, %o4 200c37c: 85 2b 20 02 sll %o4, 2, %g2 200c380: 84 10 40 02 or %g1, %g2, %g2 right += rhs->tv_nsec; 200c384: 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; 200c388: 87 2b 60 02 sll %o5, 2, %g3 200c38c: 9a 83 40 03 addcc %o5, %g3, %o5 right += rhs->tv_nsec; 200c390: 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; 200c394: 98 43 00 02 addx %o4, %g2, %o4 200c398: 89 33 60 17 srl %o5, 0x17, %g4 200c39c: 85 2b 20 09 sll %o4, 9, %g2 200c3a0: 87 2b 60 09 sll %o5, 9, %g3 200c3a4: 84 11 00 02 or %g4, %g2, %g2 right += rhs->tv_nsec; 200c3a8: 96 80 c0 01 addcc %g3, %g1, %o3 200c3ac: 94 40 80 0a addx %g2, %o2, %o2 if ( right == 0 ) { 200c3b0: 80 92 80 0b orcc %o2, %o3, %g0 200c3b4: 12 80 00 06 bne 200c3cc <_Timespec_Divide+0xe0> 200c3b8: f0 06 00 00 ld [ %i0 ], %i0 *ival_percentage = 0; 200c3bc: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED *fval_percentage = 0; 200c3c0: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED 200c3c4: 81 c7 e0 08 ret <== NOT EXECUTED 200c3c8: 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; 200c3cc: 83 36 20 1d srl %i0, 0x1d, %g1 200c3d0: 9b 2e 20 03 sll %i0, 3, %o5 200c3d4: 91 3e 20 1f sra %i0, 0x1f, %o0 200c3d8: 99 2a 20 03 sll %o0, 3, %o4 200c3dc: 98 10 40 0c or %g1, %o4, %o4 200c3e0: 83 33 60 1b srl %o5, 0x1b, %g1 200c3e4: 85 2b 20 05 sll %o4, 5, %g2 200c3e8: 87 2b 60 05 sll %o5, 5, %g3 200c3ec: 84 10 40 02 or %g1, %g2, %g2 200c3f0: 86 a0 c0 0d subcc %g3, %o5, %g3 200c3f4: 83 30 e0 1a srl %g3, 0x1a, %g1 200c3f8: 84 60 80 0c subx %g2, %o4, %g2 200c3fc: 9b 28 e0 06 sll %g3, 6, %o5 200c400: 99 28 a0 06 sll %g2, 6, %o4 200c404: 9a a3 40 03 subcc %o5, %g3, %o5 200c408: 98 10 40 0c or %g1, %o4, %o4 200c40c: 98 63 00 02 subx %o4, %g2, %o4 200c410: 9a 83 40 18 addcc %o5, %i0, %o5 200c414: 83 33 60 1e srl %o5, 0x1e, %g1 200c418: 98 43 00 08 addx %o4, %o0, %o4 200c41c: 87 2b 60 02 sll %o5, 2, %g3 200c420: 85 2b 20 02 sll %o4, 2, %g2 200c424: 9a 83 40 03 addcc %o5, %g3, %o5 200c428: 84 10 40 02 or %g1, %g2, %g2 200c42c: 83 33 60 1e srl %o5, 0x1e, %g1 200c430: 98 43 00 02 addx %o4, %g2, %o4 200c434: 87 2b 60 02 sll %o5, 2, %g3 200c438: 85 2b 20 02 sll %o4, 2, %g2 200c43c: 9a 83 40 03 addcc %o5, %g3, %o5 200c440: 84 10 40 02 or %g1, %g2, %g2 200c444: 83 33 60 1e srl %o5, 0x1e, %g1 200c448: 98 43 00 02 addx %o4, %g2, %o4 200c44c: 87 2b 60 02 sll %o5, 2, %g3 200c450: 85 2b 20 02 sll %o4, 2, %g2 200c454: 9a 83 40 03 addcc %o5, %g3, %o5 200c458: 84 10 40 02 or %g1, %g2, %g2 200c45c: 83 33 60 17 srl %o5, 0x17, %g1 200c460: 98 43 00 02 addx %o4, %g2, %o4 200c464: 93 2b 60 09 sll %o5, 9, %o1 200c468: 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; 200c46c: 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; 200c470: 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; 200c474: 83 32 60 1e srl %o1, 0x1e, %g1 200c478: a1 3b e0 1f sra %o7, 0x1f, %l0 200c47c: 87 2a 60 02 sll %o1, 2, %g3 200c480: 90 42 00 10 addx %o0, %l0, %o0 200c484: 85 2a 20 02 sll %o0, 2, %g2 200c488: 84 10 40 02 or %g1, %g2, %g2 200c48c: 83 30 e0 1b srl %g3, 0x1b, %g1 200c490: 99 28 a0 05 sll %g2, 5, %o4 200c494: 9b 28 e0 05 sll %g3, 5, %o5 200c498: 98 10 40 0c or %g1, %o4, %o4 200c49c: 9a a3 40 03 subcc %o5, %g3, %o5 200c4a0: 98 63 00 02 subx %o4, %g2, %o4 200c4a4: 9a 83 40 09 addcc %o5, %o1, %o5 200c4a8: 83 33 60 1e srl %o5, 0x1e, %g1 200c4ac: 98 43 00 08 addx %o4, %o0, %o4 200c4b0: 87 2b 60 02 sll %o5, 2, %g3 200c4b4: 85 2b 20 02 sll %o4, 2, %g2 200c4b8: 9a 83 40 03 addcc %o5, %g3, %o5 200c4bc: 84 10 40 02 or %g1, %g2, %g2 200c4c0: 83 33 60 1e srl %o5, 0x1e, %g1 200c4c4: 87 2b 60 02 sll %o5, 2, %g3 200c4c8: 98 43 00 02 addx %o4, %g2, %o4 200c4cc: 9a 83 40 03 addcc %o5, %g3, %o5 200c4d0: 85 2b 20 02 sll %o4, 2, %g2 200c4d4: 84 10 40 02 or %g1, %g2, %g2 200c4d8: 83 33 60 1b srl %o5, 0x1b, %g1 200c4dc: 98 43 00 02 addx %o4, %g2, %o4 200c4e0: 93 2b 60 05 sll %o5, 5, %o1 200c4e4: 91 2b 20 05 sll %o4, 5, %o0 200c4e8: 40 00 36 2f call 2019da4 <__udivdi3> 200c4ec: 90 10 40 08 or %g1, %o0, %o0 *ival_percentage = answer / 1000; 200c4f0: 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; 200c4f4: a0 10 00 08 mov %o0, %l0 200c4f8: a2 10 00 09 mov %o1, %l1 *ival_percentage = answer / 1000; 200c4fc: 96 10 23 e8 mov 0x3e8, %o3 200c500: 40 00 36 29 call 2019da4 <__udivdi3> 200c504: 90 10 00 10 mov %l0, %o0 *fval_percentage = answer % 1000; 200c508: 90 10 00 10 mov %l0, %o0 * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; *ival_percentage = answer / 1000; 200c50c: d2 26 80 00 st %o1, [ %i2 ] *fval_percentage = answer % 1000; 200c510: 94 10 20 00 clr %o2 200c514: 92 10 00 11 mov %l1, %o1 200c518: 40 00 37 02 call 201a120 <__umoddi3> 200c51c: 96 10 23 e8 mov 0x3e8, %o3 200c520: d2 26 c0 00 st %o1, [ %i3 ] 200c524: 81 c7 e0 08 ret 200c528: 81 e8 00 00 restore 0200a608 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, boolean is_internal, uint32_t the_error ) { 200a608: 9d e3 bf 98 save %sp, -104, %sp Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 200a60c: 03 00 80 66 sethi %hi(0x2019800), %g1 200a610: 82 10 62 c4 or %g1, 0x2c4, %g1 ! 2019ac4 <_User_extensions_List> 200a614: e0 00 60 08 ld [ %g1 + 8 ], %l0 !_Chain_Is_head( &_User_extensions_List, the_node ) ; 200a618: 80 a4 00 01 cmp %l0, %g1 200a61c: 02 80 00 0d be 200a650 <_User_extensions_Fatal+0x48> 200a620: a2 10 00 01 mov %g1, %l1 the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 200a624: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 200a628: 80 a0 60 00 cmp %g1, 0 200a62c: 02 80 00 05 be 200a640 <_User_extensions_Fatal+0x38> 200a630: 90 10 00 18 mov %i0, %o0 (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 200a634: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200a638: 9f c0 40 00 call %g1 <== NOT EXECUTED 200a63c: 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 ) { 200a640: 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 ) ; 200a644: 80 a4 00 11 cmp %l0, %l1 200a648: 32 bf ff f8 bne,a 200a628 <_User_extensions_Fatal+0x20> 200a64c: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 200a650: 81 c7 e0 08 ret 200a654: 81 e8 00 00 restore 020118b0 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 20118b0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 20118b4: 40 00 14 cb call 2016be0 <_Chain_Extract> <== NOT EXECUTED 20118b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 20118bc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED 20118c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20118c4: 02 80 00 04 be 20118d4 <_User_extensions_Remove_set+0x24> <== NOT EXECUTED 20118c8: 01 00 00 00 nop <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 20118cc: 40 00 14 c5 call 2016be0 <_Chain_Extract> <== NOT EXECUTED 20118d0: 91 ee 20 08 restore %i0, 8, %o0 <== NOT EXECUTED 20118d4: 81 c7 e0 08 ret <== NOT EXECUTED 20118d8: 81 e8 00 00 restore <== NOT EXECUTED 0200a6a4 <_User_extensions_Thread_create>: */ boolean _User_extensions_Thread_create ( Thread_Control *the_thread ) { 200a6a4: 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 ; 200a6a8: 03 00 80 66 sethi %hi(0x2019800), %g1 200a6ac: e0 00 62 c4 ld [ %g1 + 0x2c4 ], %l0 ! 2019ac4 <_User_extensions_List> 200a6b0: 82 10 62 c4 or %g1, 0x2c4, %g1 200a6b4: a2 00 60 04 add %g1, 4, %l1 !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 200a6b8: 80 a4 00 11 cmp %l0, %l1 200a6bc: 02 80 00 0f be 200a6f8 <_User_extensions_Thread_create+0x54> 200a6c0: 25 00 80 66 sethi %hi(0x2019800), %l2 the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 200a6c4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 200a6c8: 80 a0 60 00 cmp %g1, 0 200a6cc: 02 80 00 07 be 200a6e8 <_User_extensions_Thread_create+0x44> 200a6d0: 92 10 00 18 mov %i0, %o1 status = (*the_extension->Callouts.thread_create)( 200a6d4: 9f c0 40 00 call %g1 200a6d8: d0 04 a1 20 ld [ %l2 + 0x120 ], %o0 _Thread_Executing, the_thread ); if ( !status ) 200a6dc: 80 a2 20 00 cmp %o0, 0 200a6e0: 02 80 00 08 be 200a700 <_User_extensions_Thread_create+0x5c> 200a6e4: 01 00 00 00 nop 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 ) { 200a6e8: 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 ) ; 200a6ec: 80 a4 00 11 cmp %l0, %l1 200a6f0: 32 bf ff f6 bne,a 200a6c8 <_User_extensions_Thread_create+0x24> 200a6f4: c2 04 20 14 ld [ %l0 + 0x14 ], %g1 return FALSE; } } return TRUE; } 200a6f8: 81 c7 e0 08 ret 200a6fc: 91 e8 20 01 restore %g0, 1, %o0 if ( the_extension->Callouts.thread_create != NULL ) { status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) 200a700: 81 c7 e0 08 ret <== NOT EXECUTED 200a704: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 0200a7f0 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a7f0: 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; 200a7f4: 03 00 80 66 sethi %hi(0x2019800), %g1 void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 200a7f8: ac 10 00 18 mov %i0, %l6 Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 200a7fc: e6 00 61 08 ld [ %g1 + 0x108 ], %l3 _ISR_Disable( level ); 200a800: 7f ff dd 7f call 2001dfc 200a804: 01 00 00 00 nop 200a808: 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 ) { 200a80c: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a810: 80 a0 60 00 cmp %g1, 0 200a814: 12 80 00 49 bne 200a938 <_Watchdog_Insert+0x148> 200a818: 01 00 00 00 nop _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; 200a81c: 2b 00 80 66 sethi %hi(0x2019800), %l5 200a820: c2 05 61 c0 ld [ %l5 + 0x1c0 ], %g1 ! 20199c0 <_Watchdog_Sync_count> if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a824: 84 10 20 01 mov 1, %g2 _Watchdog_Sync_count++; 200a828: 82 00 60 01 inc %g1 200a82c: 29 00 80 66 sethi %hi(0x2019800), %l4 if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 200a830: c4 26 60 08 st %g2, [ %i1 + 8 ] _Watchdog_Sync_count++; 200a834: c2 25 61 c0 st %g1, [ %l5 + 0x1c0 ] if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a838: ae 10 00 14 mov %l4, %l7 the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a83c: 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 ; 200a840: e2 05 80 00 ld [ %l6 ], %l1 ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a844: 80 a4 a0 00 cmp %l2, 0 200a848: 02 80 00 2b be 200a8f4 <_Watchdog_Insert+0x104> 200a84c: 03 00 80 66 sethi %hi(0x2019800), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200a850: c2 04 40 00 ld [ %l1 ], %g1 200a854: 80 a0 60 00 cmp %g1, 0 200a858: 02 80 00 27 be 200a8f4 <_Watchdog_Insert+0x104> 200a85c: 03 00 80 66 sethi %hi(0x2019800), %g1 break; if ( delta_interval < after->delta_interval ) { 200a860: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a864: 80 a4 80 10 cmp %l2, %l0 200a868: 1a 80 00 13 bcc 200a8b4 <_Watchdog_Insert+0xc4> 200a86c: 01 00 00 00 nop after->delta_interval -= delta_interval; 200a870: 10 80 00 1f b 200a8ec <_Watchdog_Insert+0xfc> 200a874: a0 24 00 12 sub %l0, %l2, %l0 if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 200a878: c2 05 21 1c ld [ %l4 + 0x11c ], %g1 200a87c: 80 a4 c0 01 cmp %l3, %g1 200a880: 0a 80 00 30 bcs 200a940 <_Watchdog_Insert+0x150> 200a884: 01 00 00 00 nop */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 200a888: a4 a4 80 10 subcc %l2, %l0, %l2 200a88c: 02 80 00 19 be 200a8f0 <_Watchdog_Insert+0x100> 200a890: e2 04 40 00 ld [ %l1 ], %l1 200a894: c2 04 40 00 ld [ %l1 ], %g1 200a898: 80 a0 60 00 cmp %g1, 0 200a89c: 02 80 00 16 be 200a8f4 <_Watchdog_Insert+0x104> 200a8a0: 03 00 80 66 sethi %hi(0x2019800), %g1 break; if ( delta_interval < after->delta_interval ) { 200a8a4: e0 04 60 10 ld [ %l1 + 0x10 ], %l0 200a8a8: 80 a4 00 12 cmp %l0, %l2 200a8ac: 38 80 00 10 bgu,a 200a8ec <_Watchdog_Insert+0xfc> 200a8b0: a0 24 00 12 sub %l0, %l2, %l0 * 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 ); 200a8b4: 7f ff dd 56 call 2001e0c 200a8b8: 90 10 00 18 mov %i0, %o0 200a8bc: 7f ff dd 50 call 2001dfc 200a8c0: 01 00 00 00 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 200a8c4: c2 06 60 08 ld [ %i1 + 8 ], %g1 200a8c8: 80 a0 60 01 cmp %g1, 1 200a8cc: 02 bf ff eb be 200a878 <_Watchdog_Insert+0x88> 200a8d0: 01 00 00 00 nop _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a8d4: e6 25 21 1c st %l3, [ %l4 + 0x11c ] <== NOT EXECUTED _Watchdog_Sync_count--; 200a8d8: c2 05 61 c0 ld [ %l5 + 0x1c0 ], %g1 <== NOT EXECUTED 200a8dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200a8e0: c2 25 61 c0 st %g1, [ %l5 + 0x1c0 ] <== NOT EXECUTED _ISR_Enable( level ); 200a8e4: 7f ff dd 4a call 2001e0c <== NOT EXECUTED 200a8e8: 81 e8 00 00 restore <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 200a8ec: e0 24 60 10 st %l0, [ %l1 + 0x10 ] the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a8f0: 03 00 80 66 sethi %hi(0x2019800), %g1 200a8f4: c6 00 61 c4 ld [ %g1 + 0x1c4 ], %g3 ! 20199c4 <_Watchdog_Ticks_since_boot> _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 200a8f8: c4 04 60 04 ld [ %l1 + 4 ], %g2 the_watchdog->start_time = _Watchdog_Ticks_since_boot; 200a8fc: c6 26 60 14 st %g3, [ %i1 + 0x14 ] } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 200a900: e4 26 60 10 st %l2, [ %i1 + 0x10 ] RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 200a904: 82 10 20 02 mov 2, %g1 ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 200a908: c8 00 80 00 ld [ %g2 ], %g4 _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); the_watchdog->start_time = _Watchdog_Ticks_since_boot; exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 200a90c: e6 25 21 1c st %l3, [ %l4 + 0x11c ] 200a910: c2 26 60 08 st %g1, [ %i1 + 8 ] _Watchdog_Sync_count--; 200a914: c2 05 61 c0 ld [ %l5 + 0x1c0 ], %g1 after_node->next = the_node; 200a918: f2 20 80 00 st %i1, [ %g2 ] Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 200a91c: c4 26 60 04 st %g2, [ %i1 + 4 ] 200a920: 82 00 7f ff add %g1, -1, %g1 before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; before_node->previous = the_node; 200a924: f2 21 20 04 st %i1, [ %g4 + 4 ] Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; after_node->next = the_node; the_node->next = before_node; 200a928: c8 26 40 00 st %g4, [ %i1 ] 200a92c: c2 25 61 c0 st %g1, [ %l5 + 0x1c0 ] _ISR_Enable( level ); 200a930: 7f ff dd 37 call 2001e0c 200a934: 81 e8 00 00 restore * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 200a938: 7f ff dd 35 call 2001e0c <== NOT EXECUTED 200a93c: 81 e8 00 00 restore <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { _Watchdog_Sync_level = insert_isr_nest_level; 200a940: e6 25 e1 1c st %l3, [ %l7 + 0x11c ] the_watchdog->state = WATCHDOG_BEING_INSERTED; _Watchdog_Sync_count++; restart: delta_interval = the_watchdog->initial; 200a944: 10 bf ff bf b 200a840 <_Watchdog_Insert+0x50> 200a948: e4 06 60 0c ld [ %i1 + 0xc ], %l2 0200b684 <_Watchdog_Insert_ticks_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 200b684: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; (void) _Watchdog_Remove( timer ); 200b688: 40 00 18 ea call 2011a30 <_Watchdog_Remove> 200b68c: 90 10 00 18 mov %i0, %o0 _ISR_Disable( level ); 200b690: 7f ff ec 81 call 2006894 200b694: 01 00 00 00 nop 200b698: 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 ) { 200b69c: c2 06 20 08 ld [ %i0 + 8 ], %g1 200b6a0: 80 a0 60 00 cmp %g1, 0 200b6a4: 22 80 00 06 be,a 200b6bc <_Watchdog_Insert_ticks_helper+0x38> 200b6a8: f6 26 20 1c st %i3, [ %i0 + 0x1c ] _ISR_Enable( level ); 200b6ac: 7f ff ec 7e call 20068a4 <== NOT EXECUTED 200b6b0: b0 10 20 00 clr %i0 <== NOT EXECUTED 200b6b4: 81 c7 e0 08 ret <== NOT EXECUTED 200b6b8: 81 e8 00 00 restore <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200b6bc: f4 26 20 20 st %i2, [ %i0 + 0x20 ] the_watchdog->user_data = user_data; 200b6c0: f8 26 20 24 st %i4, [ %i0 + 0x24 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200b6c4: f2 26 20 0c st %i1, [ %i0 + 0xc ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200b6c8: c0 26 20 08 clr [ %i0 + 8 ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 200b6cc: 92 10 00 18 mov %i0, %o1 200b6d0: 11 00 80 93 sethi %hi(0x2024c00), %o0 200b6d4: 40 00 18 6d call 2011888 <_Watchdog_Insert> 200b6d8: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 2024dd0 <_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 ); 200b6dc: b0 10 20 01 mov 1, %i0 200b6e0: 7f ff ec 71 call 20068a4 200b6e4: 90 10 00 10 mov %l0, %o0 return TRUE; } 200b6e8: 81 c7 e0 08 ret 200b6ec: 81 e8 00 00 restore 0200a998 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 200a998: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 200a99c: 7f ff dd 18 call 2001dfc 200a9a0: a0 10 00 18 mov %i0, %l0 previous_state = the_watchdog->state; 200a9a4: f0 06 20 08 ld [ %i0 + 8 ], %i0 switch ( previous_state ) { 200a9a8: 80 a6 20 01 cmp %i0, 1 200a9ac: 02 80 00 2a be 200aa54 <_Watchdog_Remove+0xbc> 200a9b0: 03 00 80 66 sethi %hi(0x2019800), %g1 200a9b4: 1a 80 00 09 bcc 200a9d8 <_Watchdog_Remove+0x40> 200a9b8: 80 a6 20 03 cmp %i0, 3 _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200a9bc: 03 00 80 66 sethi %hi(0x2019800), %g1 200a9c0: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 ! 20199c4 <_Watchdog_Ticks_since_boot> 200a9c4: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 200a9c8: 7f ff dd 11 call 2001e0c 200a9cc: 01 00 00 00 nop return( previous_state ); } 200a9d0: 81 c7 e0 08 ret 200a9d4: 81 e8 00 00 restore Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 200a9d8: 18 bf ff fa bgu 200a9c0 <_Watchdog_Remove+0x28> 200a9dc: 03 00 80 66 sethi %hi(0x2019800), %g1 RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next( Watchdog_Control *the_watchdog ) { return ( (Watchdog_Control *) the_watchdog->Node.next ); 200a9e0: c8 04 00 00 ld [ %l0 ], %g4 break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 200a9e4: c0 24 20 08 clr [ %l0 + 8 ] next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 200a9e8: c2 01 00 00 ld [ %g4 ], %g1 200a9ec: 80 a0 60 00 cmp %g1, 0 200a9f0: 02 80 00 07 be 200aa0c <_Watchdog_Remove+0x74> 200a9f4: 03 00 80 66 sethi %hi(0x2019800), %g1 next_watchdog->delta_interval += the_watchdog->delta_interval; 200a9f8: c2 01 20 10 ld [ %g4 + 0x10 ], %g1 200a9fc: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 200aa00: 82 00 40 02 add %g1, %g2, %g1 200aa04: c2 21 20 10 st %g1, [ %g4 + 0x10 ] if ( _Watchdog_Sync_count ) 200aa08: 03 00 80 66 sethi %hi(0x2019800), %g1 200aa0c: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 20199c0 <_Watchdog_Sync_count> 200aa10: 80 a0 a0 00 cmp %g2, 0 200aa14: 22 80 00 07 be,a 200aa30 <_Watchdog_Remove+0x98> 200aa18: c2 04 20 04 ld [ %l0 + 4 ], %g1 _Watchdog_Sync_level = _ISR_Nest_level; 200aa1c: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 200aa20: c6 00 61 08 ld [ %g1 + 0x108 ], %g3 ! 2019908 <_ISR_Nest_level> <== NOT EXECUTED 200aa24: 05 00 80 66 sethi %hi(0x2019800), %g2 <== NOT EXECUTED 200aa28: c6 20 a1 1c st %g3, [ %g2 + 0x11c ] ! 201991c <_Watchdog_Sync_level> <== NOT EXECUTED { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 200aa2c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED next->previous = previous; previous->next = next; 200aa30: c8 20 40 00 st %g4, [ %g1 ] Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; next->previous = previous; 200aa34: c2 21 20 04 st %g1, [ %g4 + 4 ] _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200aa38: 03 00 80 66 sethi %hi(0x2019800), %g1 200aa3c: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 ! 20199c4 <_Watchdog_Ticks_since_boot> 200aa40: c4 24 20 18 st %g2, [ %l0 + 0x18 ] _ISR_Enable( level ); 200aa44: 7f ff dc f2 call 2001e0c 200aa48: 01 00 00 00 nop return( previous_state ); } 200aa4c: 81 c7 e0 08 ret 200aa50: 81 e8 00 00 restore _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200aa54: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 <== NOT EXECUTED /* * It is not actually on the chain so just change the state and * the Insert operation we interrupted will be aborted. */ the_watchdog->state = WATCHDOG_INACTIVE; 200aa58: c0 24 20 08 clr [ %l0 + 8 ] <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 200aa5c: c4 24 20 18 st %g2, [ %l0 + 0x18 ] <== NOT EXECUTED _ISR_Enable( level ); 200aa60: 7f ff dc eb call 2001e0c <== NOT EXECUTED 200aa64: 01 00 00 00 nop <== NOT EXECUTED return( previous_state ); } 200aa68: 81 c7 e0 08 ret <== NOT EXECUTED 200aa6c: 81 e8 00 00 restore <== NOT EXECUTED 0200ab1c <_Workspace_Allocate_or_fatal_error>: */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 200ab1c: 9d e3 bf 98 save %sp, -104, %sp RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 200ab20: 11 00 80 66 sethi %hi(0x2019800), %o0 200ab24: 92 10 00 18 mov %i0, %o1 200ab28: 7f ff f1 f9 call 200730c <_Heap_Allocate> 200ab2c: 90 12 20 8c or %o0, 0x8c, %o0 void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 200ab30: b0 92 20 00 orcc %o0, 0, %i0 200ab34: 12 80 00 04 bne 200ab44 <_Workspace_Allocate_or_fatal_error+0x28> 200ab38: 92 10 20 01 mov 1, %o1 _Internal_error_Occurred( 200ab3c: 7f ff f3 26 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200ab40: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 200ab44: 81 c7 e0 08 ret 200ab48: 81 e8 00 00 restore 0200ab4c <_Workspace_Handler_initialization>: void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 200ab4c: 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 ) ) 200ab50: 80 a6 20 00 cmp %i0, 0 200ab54: 02 80 00 1d be 200abc8 <_Workspace_Handler_initialization+0x7c> 200ab58: 80 8e 20 07 btst 7, %i0 200ab5c: 12 80 00 1c bne 200abcc <_Workspace_Handler_initialization+0x80> 200ab60: 90 10 20 00 clr %o0 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _CPU_Table.do_zero_of_workspace ) { 200ab64: 03 00 80 66 sethi %hi(0x2019800), %g1 200ab68: c4 00 60 64 ld [ %g1 + 0x64 ], %g2 ! 2019864 <_CPU_Table+0x10> 200ab6c: 80 a0 a0 00 cmp %g2, 0 200ab70: 02 80 00 0c be 200aba0 <_Workspace_Handler_initialization+0x54> 200ab74: 92 10 00 18 mov %i0, %o1 for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; 200ab78: 87 36 60 02 srl %i1, 2, %g3 <== NOT EXECUTED 200ab7c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200ab80: 02 80 00 08 be 200aba0 <_Workspace_Handler_initialization+0x54> <== NOT EXECUTED 200ab84: 84 10 20 00 clr %g2 <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; 200ab88: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED ); if ( _CPU_Table.do_zero_of_workspace ) { for( zero_out_array = (uint32_t *) starting_address, index = 0 ; index < size / sizeof( uint32_t ) ; index++ ) 200ab8c: 84 00 a0 01 inc %g2 <== 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 ) ; 200ab90: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED 200ab94: 12 bf ff fd bne 200ab88 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 200ab98: c0 20 40 18 clr [ %g1 + %i0 ] <== NOT EXECUTED index++ ) zero_out_array[ index ] = 0; } memory_available = _Heap_Initialize( 200ab9c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200aba0: 94 10 00 19 mov %i1, %o2 200aba4: 11 00 80 66 sethi %hi(0x2019800), %o0 200aba8: 96 10 20 08 mov 8, %o3 200abac: 7f ff f2 bd call 20076a0 <_Heap_Initialize> 200abb0: 90 12 20 8c or %o0, 0x8c, %o0 starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 200abb4: 80 a2 20 00 cmp %o0, 0 200abb8: 02 80 00 0a be 200abe0 <_Workspace_Handler_initialization+0x94> 200abbc: b0 10 20 00 clr %i0 200abc0: 81 c7 e0 08 ret 200abc4: 81 e8 00 00 restore uint32_t *zero_out_array; uint32_t index; uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 200abc8: 90 10 20 00 clr %o0 <== NOT EXECUTED 200abcc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 200abd0: 7f ff f3 01 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200abd4: 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 ) { 200abd8: 10 bf ff e4 b 200ab68 <_Workspace_Handler_initialization+0x1c> <== NOT EXECUTED 200abdc: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 200abe0: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED 200abe4: 7f ff f2 fc call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 200abe8: 95 e8 20 03 restore %g0, 3, %o2 <== NOT EXECUTED 200abec: 01 00 00 00 nop 02016f48 <_exit>: #include #if !defined(RTEMS_UNIX) void _exit(int status) { 2016f48: 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(); 2016f4c: 7f ff ff e4 call 2016edc 2016f50: 01 00 00 00 nop rtems_shutdown_executive(status); 2016f54: 40 00 00 4c call 2017084 2016f58: 90 10 00 18 mov %i0, %o0 2016f5c: 30 80 00 00 b,a 2016f5c <_exit+0x14> <== NOT EXECUTED 02023118 <_fcntl_r>: int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 2023118: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 202311c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2023120: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED 2023124: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2023128: 7f ff ff 6f call 2022ee4 <== NOT EXECUTED 202312c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2023130: 01 00 00 00 nop 02024758 <_getpid_r>: pid_t _getpid_r( struct _reent *ptr ) { return getpid(); 2024758: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 202475c: 7f ff ff fd call 2024750 <== NOT EXECUTED 2024760: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2024764: 01 00 00 00 nop 0200c3f8 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 200c3f8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 200c3fc: 7f ff ff e6 call 200c394 <== NOT EXECUTED 200c400: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 200c404: 01 00 00 00 nop 02024a04 <_kill_r>: struct _reent *ptr, pid_t pid, int sig ) { return kill( pid, sig ); 2024a04: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2024a08: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2024a0c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2024a10: 7f ff ff f8 call 20249f0 <== NOT EXECUTED 2024a14: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2024a18: 01 00 00 00 nop 02003d0c <_link_r>: struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 2003d0c: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2003d10: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2003d14: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2003d18: 7f ff ff 59 call 2003a7c <== NOT EXECUTED 2003d1c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2003d20: 01 00 00 00 nop 02002edc <_open_r>: const char *buf, int flags, int mode ) { return open( buf, flags, mode ); 2002edc: 90 10 00 09 mov %o1, %o0 2002ee0: 92 10 00 0a mov %o2, %o1 2002ee4: 94 10 00 0b mov %o3, %o2 2002ee8: 82 13 c0 00 mov %o7, %g1 2002eec: 7f ff ff 36 call 2002bc4 2002ef0: 9e 10 40 00 mov %g1, %o7 2002ef4: 01 00 00 00 nop <== NOT EXECUTED 020025fc <_realloc_r>: struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 20025fc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2002600: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2002604: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2002608: 7f ff ff b6 call 20024e0 <== NOT EXECUTED 200260c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2002610: 01 00 00 00 nop 02005a44 <_stat_r>: struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 2005a44: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 2005a48: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED 2005a4c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2005a50: 7f ff ff b3 call 200591c <== NOT EXECUTED 2005a54: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2005a58: 01 00 00 00 nop 020191cc <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) { return unlink( path ); 20191cc: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED 20191d0: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20191d4: 7f ff ff a5 call 2019068 <== NOT EXECUTED 20191d8: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20191dc: 01 00 00 00 nop 020055cc : int alphasort(d1, d2) const void *d1; const void *d2; { return(strcmp((*(struct dirent **)d1)->d_name, 20055cc: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 20055d0: d2 02 40 00 ld [ %o1 ], %o1 <== NOT EXECUTED 20055d4: 90 02 20 0c add %o0, 0xc, %o0 <== NOT EXECUTED 20055d8: 92 02 60 0c add %o1, 0xc, %o1 <== NOT EXECUTED 20055dc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20055e0: 40 00 39 b4 call 2013cb0 <== NOT EXECUTED 20055e4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20055e8: 01 00 00 00 nop 02017254 : #include int chdir( const char *pathname ) { 2017254: 9d e3 bf 88 save %sp, -120, %sp /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 2017258: 92 10 20 01 mov 1, %o1 201725c: 90 10 00 18 mov %i0, %o0 2017260: a0 07 bf e8 add %fp, -24, %l0 2017264: 96 10 20 01 mov 1, %o3 2017268: 94 10 00 10 mov %l0, %o2 201726c: 7f ff b3 41 call 2003f70 2017270: b0 10 3f ff mov -1, %i0 pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, TRUE ); if ( result != 0 ) 2017274: 80 a2 20 00 cmp %o0, 0 2017278: 12 80 00 2f bne 2017334 201727c: c4 07 bf f0 ld [ %fp + -16 ], %g2 /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 2017280: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2017284: 80 a0 60 00 cmp %g1, 0 2017288: 22 80 00 2d be,a 201733c 201728c: c2 00 a0 1c ld [ %g2 + 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 ) { 2017290: 9f c0 40 00 call %g1 2017294: 90 10 00 10 mov %l0, %o0 2017298: 80 a2 20 01 cmp %o0, 1 201729c: 12 80 00 19 bne 2017300 20172a0: c2 07 bf f0 ld [ %fp + -16 ], %g1 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 20172a4: 21 00 80 ec sethi %hi(0x203b000), %l0 20172a8: d0 04 22 00 ld [ %l0 + 0x200 ], %o0 ! 203b200 20172ac: c2 02 20 0c ld [ %o0 + 0xc ], %g1 20172b0: 80 a0 60 00 cmp %g1, 0 20172b4: 22 80 00 09 be,a 20172d8 20172b8: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED 20172bc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20172c0: 80 a0 60 00 cmp %g1, 0 20172c4: 22 80 00 05 be,a 20172d8 20172c8: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED 20172cc: 9f c0 40 00 call %g1 20172d0: 90 02 20 04 add %o0, 4, %o0 rtems_filesystem_current = loc; 20172d4: c2 07 bf e8 ld [ %fp + -24 ], %g1 20172d8: c6 04 22 00 ld [ %l0 + 0x200 ], %g3 20172dc: c2 20 e0 04 st %g1, [ %g3 + 4 ] 20172e0: c4 07 bf ec ld [ %fp + -20 ], %g2 20172e4: c4 20 e0 08 st %g2, [ %g3 + 8 ] 20172e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20172ec: c2 20 e0 0c st %g1, [ %g3 + 0xc ] 20172f0: c4 07 bf f4 ld [ %fp + -12 ], %g2 20172f4: c4 20 e0 10 st %g2, [ %g3 + 0x10 ] return 0; } 20172f8: 81 c7 e0 08 ret 20172fc: 91 e8 20 00 restore %g0, 0, %o0 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 2017300: 80 a0 60 00 cmp %g1, 0 2017304: 02 80 00 08 be 2017324 2017308: 01 00 00 00 nop 201730c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2017310: 80 a0 60 00 cmp %g1, 0 2017314: 02 80 00 04 be 2017324 2017318: 01 00 00 00 nop 201731c: 9f c0 40 00 call %g1 2017320: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 2017324: 40 00 39 3d call 2025818 <__errno> 2017328: b0 10 3f ff mov -1, %i0 201732c: 82 10 20 14 mov 0x14, %g1 2017330: c2 22 00 00 st %g1, [ %o0 ] 2017334: 81 c7 e0 08 ret 2017338: 81 e8 00 00 restore /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { rtems_filesystem_freenode( &loc ); 201733c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017340: 02 80 00 04 be 2017350 <== NOT EXECUTED 2017344: 01 00 00 00 nop <== NOT EXECUTED 2017348: 9f c0 40 00 call %g1 <== NOT EXECUTED 201734c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2017350: 40 00 39 32 call 2025818 <__errno> <== NOT EXECUTED 2017354: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2017358: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 201735c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017360: 81 c7 e0 08 ret <== NOT EXECUTED 2017364: 81 e8 00 00 restore <== NOT EXECUTED 02017368 : int chmod( const char *path, mode_t mode ) { 2017368: 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 ); 201736c: 92 10 20 00 clr %o1 2017370: 90 10 00 18 mov %i0, %o0 2017374: a0 07 bf e8 add %fp, -24, %l0 2017378: 96 10 20 01 mov 1, %o3 201737c: 94 10 00 10 mov %l0, %o2 2017380: 7f ff b2 fc call 2003f70 2017384: b0 10 3f ff mov -1, %i0 if ( status != 0 ) 2017388: 80 a2 20 00 cmp %o0, 0 201738c: 12 80 00 16 bne 20173e4 2017390: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !loc.handlers ){ 2017394: 80 a0 60 00 cmp %g1, 0 2017398: 22 80 00 25 be,a 201742c 201739c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( !loc.handlers->fchmod_h ){ 20173a0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20173a4: 80 a0 60 00 cmp %g1, 0 20173a8: 02 80 00 11 be 20173ec 20173ac: 93 2e 60 10 sll %i1, 0x10, %o1 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->fchmod_h)( &loc, mode ); 20173b0: 90 10 00 10 mov %l0, %o0 20173b4: 9f c0 40 00 call %g1 20173b8: 93 32 60 10 srl %o1, 0x10, %o1 rtems_filesystem_freenode( &loc ); 20173bc: c2 07 bf f0 ld [ %fp + -16 ], %g1 20173c0: 80 a0 60 00 cmp %g1, 0 20173c4: 02 80 00 08 be 20173e4 20173c8: b0 10 00 08 mov %o0, %i0 20173cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20173d0: 80 a0 60 00 cmp %g1, 0 20173d4: 02 80 00 23 be 2017460 20173d8: 01 00 00 00 nop 20173dc: 9f c0 40 00 call %g1 20173e0: 90 10 00 10 mov %l0, %o0 return result; } 20173e4: 81 c7 e0 08 ret 20173e8: 81 e8 00 00 restore rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( !loc.handlers->fchmod_h ){ rtems_filesystem_freenode( &loc ); 20173ec: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 20173f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20173f4: 02 80 00 08 be 2017414 <== NOT EXECUTED 20173f8: 01 00 00 00 nop <== NOT EXECUTED 20173fc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2017400: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017404: 02 80 00 04 be 2017414 <== NOT EXECUTED 2017408: 01 00 00 00 nop <== NOT EXECUTED 201740c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2017410: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2017414: 40 00 39 01 call 2025818 <__errno> <== NOT EXECUTED 2017418: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201741c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2017420: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017424: 81 c7 e0 08 ret <== NOT EXECUTED 2017428: 81 e8 00 00 restore <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, 0, &loc, TRUE ); if ( status != 0 ) return -1; if ( !loc.handlers ){ rtems_filesystem_freenode( &loc ); 201742c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017430: 02 80 00 08 be 2017450 <== NOT EXECUTED 2017434: 01 00 00 00 nop <== NOT EXECUTED 2017438: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 201743c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017440: 02 80 00 04 be 2017450 <== NOT EXECUTED 2017444: 01 00 00 00 nop <== NOT EXECUTED 2017448: 9f c0 40 00 call %g1 <== NOT EXECUTED 201744c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 2017450: 40 00 38 f2 call 2025818 <__errno> <== NOT EXECUTED 2017454: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2017458: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 201745c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017460: 81 c7 e0 08 ret <== NOT EXECUTED 2017464: 81 e8 00 00 restore <== NOT EXECUTED 02017468 : int chown( const char *path, uid_t owner, gid_t group ) { 2017468: 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 ) ) 201746c: 92 10 20 00 clr %o1 2017470: 90 10 00 18 mov %i0, %o0 2017474: a0 07 bf e8 add %fp, -24, %l0 2017478: 96 10 20 01 mov 1, %o3 201747c: 94 10 00 10 mov %l0, %o2 2017480: 7f ff b2 bc call 2003f70 2017484: b0 10 3f ff mov -1, %i0 2017488: 80 a2 20 00 cmp %o0, 0 201748c: 12 80 00 15 bne 20174e0 2017490: c2 07 bf f0 ld [ %fp + -16 ], %g1 return -1; if ( !loc.ops->chown_h ) { 2017494: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 2017498: 80 a0 a0 00 cmp %g2, 0 201749c: 02 80 00 13 be 20174e8 20174a0: 93 2e 60 10 sll %i1, 0x10, %o1 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->chown_h)( &loc, owner, group ); 20174a4: 95 2e a0 10 sll %i2, 0x10, %o2 20174a8: 93 32 60 10 srl %o1, 0x10, %o1 20174ac: 95 32 a0 10 srl %o2, 0x10, %o2 20174b0: 9f c0 80 00 call %g2 20174b4: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 20174b8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20174bc: 80 a0 60 00 cmp %g1, 0 20174c0: 02 80 00 08 be 20174e0 20174c4: b0 10 00 08 mov %o0, %i0 20174c8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20174cc: 80 a0 60 00 cmp %g1, 0 20174d0: 02 80 00 10 be 2017510 20174d4: 01 00 00 00 nop 20174d8: 9f c0 40 00 call %g1 20174dc: 90 10 00 10 mov %l0, %o0 return result; } 20174e0: 81 c7 e0 08 ret 20174e4: 81 e8 00 00 restore if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, TRUE ) ) return -1; if ( !loc.ops->chown_h ) { rtems_filesystem_freenode( &loc ); 20174e8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 20174ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20174f0: 02 80 00 04 be 2017500 <== NOT EXECUTED 20174f4: 01 00 00 00 nop <== NOT EXECUTED 20174f8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20174fc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2017500: 40 00 38 c6 call 2025818 <__errno> <== NOT EXECUTED 2017504: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2017508: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 201750c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017510: 81 c7 e0 08 ret <== NOT EXECUTED 2017514: 81 e8 00 00 restore <== NOT EXECUTED 02017518 : #include int chroot( const char *pathname ) { 2017518: 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) { 201751c: 23 00 80 ec sethi %hi(0x203b000), %l1 2017520: e0 04 62 00 ld [ %l1 + 0x200 ], %l0 ! 203b200 2017524: 03 00 80 f7 sethi %hi(0x203dc00), %g1 2017528: 82 10 60 84 or %g1, 0x84, %g1 ! 203dc84 201752c: 80 a4 00 01 cmp %l0, %g1 2017530: 02 80 00 24 be 20175c0 2017534: 01 00 00 00 nop rtems_libio_set_private_env(); /* try to set a new private env*/ if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ rtems_set_errno_and_return_minus_one( ENOTSUP ); }; result = chdir(pathname); 2017538: 7f ff ff 47 call 2017254 201753c: 90 10 00 18 mov %i0, %o0 if (result) { 2017540: 80 a2 20 00 cmp %o0, 0 2017544: 12 80 00 2b bne 20175f0 2017548: 11 00 80 de sethi %hi(0x2037800), %o0 rtems_set_errno_and_return_minus_one( errno ); }; /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 201754c: 92 10 20 00 clr %o1 2017550: 90 12 21 20 or %o0, 0x120, %o0 2017554: 94 07 bf e8 add %fp, -24, %o2 2017558: 7f ff b2 86 call 2003f70 201755c: 96 10 20 00 clr %o3 2017560: 80 a2 20 00 cmp %o0, 0 2017564: 12 80 00 23 bne 20175f0 2017568: d0 04 62 00 ld [ %l1 + 0x200 ], %o0 /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); } rtems_filesystem_freenode(&rtems_filesystem_root); 201756c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2017570: 80 a0 60 00 cmp %g1, 0 2017574: 22 80 00 09 be,a 2017598 2017578: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED 201757c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2017580: 80 a0 60 00 cmp %g1, 0 2017584: 22 80 00 05 be,a 2017598 2017588: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED 201758c: 9f c0 40 00 call %g1 2017590: 90 02 20 14 add %o0, 0x14, %o0 rtems_filesystem_root = loc; 2017594: c2 07 bf e8 ld [ %fp + -24 ], %g1 2017598: c6 04 62 00 ld [ %l1 + 0x200 ], %g3 201759c: c2 20 e0 14 st %g1, [ %g3 + 0x14 ] 20175a0: c4 07 bf ec ld [ %fp + -20 ], %g2 20175a4: c4 20 e0 18 st %g2, [ %g3 + 0x18 ] 20175a8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20175ac: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] 20175b0: c4 07 bf f4 ld [ %fp + -12 ], %g2 20175b4: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] return 0; } 20175b8: 81 c7 e0 08 ret 20175bc: 91 e8 20 00 restore %g0, 0, %o0 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) { rtems_libio_set_private_env(); /* try to set a new private env*/ 20175c0: 40 00 05 59 call 2018b24 20175c4: 01 00 00 00 nop if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 20175c8: c2 04 62 00 ld [ %l1 + 0x200 ], %g1 20175cc: 80 a0 40 10 cmp %g1, %l0 20175d0: 12 bf ff da bne 2017538 20175d4: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); 20175d8: 40 00 38 90 call 2025818 <__errno> <== NOT EXECUTED 20175dc: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 20175e0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 20175e4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20175e8: 81 c7 e0 08 ret <== NOT EXECUTED 20175ec: 81 e8 00 00 restore <== NOT EXECUTED rtems_set_errno_and_return_minus_one( errno ); }; /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { /* our cwd has changed, though - but there is no easy way of return :-( */ rtems_set_errno_and_return_minus_one( errno ); 20175f0: 40 00 38 8a call 2025818 <__errno> <== NOT EXECUTED 20175f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20175f8: 40 00 38 88 call 2025818 <__errno> <== NOT EXECUTED 20175fc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2017600: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2017604: c2 24 00 00 st %g1, [ %l0 ] <== NOT EXECUTED 2017608: 81 c7 e0 08 ret <== NOT EXECUTED 201760c: 81 e8 00 00 restore <== NOT EXECUTED 02006330 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 2006330: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 2006334: 90 96 60 00 orcc %i1, 0, %o0 2006338: 02 80 00 1d be 20063ac 200633c: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 2006340: 02 80 00 09 be 2006364 2006344: 01 00 00 00 nop 2006348: 08 80 00 0b bleu 2006374 200634c: 80 a6 20 01 cmp %i0, 1 2006350: 80 a6 20 03 cmp %i0, 3 <== NOT EXECUTED 2006354: 02 80 00 14 be 20063a4 <== NOT EXECUTED 2006358: 80 a6 20 04 cmp %i0, 4 <== NOT EXECUTED 200635c: 12 80 00 08 bne 200637c <== NOT EXECUTED 2006360: 01 00 00 00 nop <== NOT EXECUTED break; #endif #ifdef _POSIX_CPUTIME case CLOCK_PROCESS_CPUTIME: _TOD_Get_uptime(tp); 2006364: 40 00 0b 86 call 200917c <_TOD_Get_uptime> <== NOT EXECUTED 2006368: b0 10 20 00 clr %i0 ! 0 <== NOT EXECUTED 200636c: 81 c7 e0 08 ret <== NOT EXECUTED 2006370: 81 e8 00 00 restore <== NOT EXECUTED ) { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 2006374: 02 80 00 08 be 2006394 2006378: 01 00 00 00 nop case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 200637c: 40 00 2a 45 call 2010c90 <__errno> <== NOT EXECUTED 2006380: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2006384: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2006388: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return 0; } 200638c: 81 c7 e0 08 ret <== NOT EXECUTED 2006390: 81 e8 00 00 restore <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { case CLOCK_REALTIME: _TOD_Get(tp); 2006394: 40 00 0b 61 call 2009118 <_TOD_Get> 2006398: b0 10 20 00 clr %i0 200639c: 81 c7 e0 08 ret 20063a0: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 20063a4: 40 00 03 56 call 20070fc <== NOT EXECUTED 20063a8: 81 e8 00 00 restore <== NOT EXECUTED clockid_t clock_id, struct timespec *tp ) { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); 20063ac: 40 00 2a 39 call 2010c90 <__errno> <== NOT EXECUTED 20063b0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20063b4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20063b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20063bc: 81 c7 e0 08 ret <== NOT EXECUTED 20063c0: 81 e8 00 00 restore <== NOT EXECUTED 020063c4 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 20063c4: 9d e3 bf 98 save %sp, -104, %sp if ( !tp ) 20063c8: 90 96 60 00 orcc %i1, 0, %o0 20063cc: 02 80 00 26 be 2006464 20063d0: 80 a6 20 02 cmp %i0, 2 rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 20063d4: 02 80 00 22 be 200645c 20063d8: 80 a6 20 03 cmp %i0, 3 20063dc: 02 80 00 20 be 200645c 20063e0: 80 a6 20 01 cmp %i0, 1 20063e4: 22 80 00 08 be,a 2006404 20063e8: c4 02 00 00 ld [ %o0 ], %g2 case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); break; #endif default: rtems_set_errno_and_return_minus_one( EINVAL ); 20063ec: 40 00 2a 29 call 2010c90 <__errno> 20063f0: b0 10 3f ff mov -1, %i0 20063f4: 82 10 20 16 mov 0x16, %g1 20063f8: c2 22 00 00 st %g1, [ %o0 ] } return 0; } 20063fc: 81 c7 e0 08 ret 2006400: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 2006404: 03 08 76 b9 sethi %hi(0x21dae400), %g1 2006408: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff 200640c: 80 a0 80 01 cmp %g2, %g1 2006410: 08 80 00 15 bleu 2006464 2006414: 21 00 80 75 sethi %hi(0x201d400), %l0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006418: c2 04 23 40 ld [ %l0 + 0x340 ], %g1 ! 201d740 <_Thread_Dispatch_disable_level> 200641c: 82 00 60 01 inc %g1 2006420: c2 24 23 40 st %g1, [ %l0 + 0x340 ] rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 2006424: 40 00 0b 7e call 200921c <_TOD_Set> 2006428: 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 ) 200642c: c2 04 23 40 ld [ %l0 + 0x340 ], %g1 2006430: b0 10 20 00 clr %i0 2006434: 82 00 7f ff add %g1, -1, %g1 2006438: c2 24 23 40 st %g1, [ %l0 + 0x340 ] 200643c: c4 04 23 40 ld [ %l0 + 0x340 ], %g2 2006440: 80 a0 a0 00 cmp %g2, 0 2006444: 12 80 00 0c bne 2006474 2006448: 01 00 00 00 nop _Thread_Dispatch(); 200644c: 40 00 13 68 call 200b1ec <_Thread_Dispatch> 2006450: 01 00 00 00 nop 2006454: 81 c7 e0 08 ret 2006458: 81 e8 00 00 restore break; #endif #ifdef _POSIX_THREAD_CPUTIME case CLOCK_THREAD_CPUTIME: return POSIX_NOT_IMPLEMENTED(); 200645c: 40 00 03 28 call 20070fc <== NOT EXECUTED 2006460: 81 e8 00 00 restore <== NOT EXECUTED switch ( clock_id ) { case CLOCK_REALTIME: if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) rtems_set_errno_and_return_minus_one( EINVAL ); 2006464: 40 00 2a 0b call 2010c90 <__errno> <== NOT EXECUTED 2006468: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200646c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2006470: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2006474: 81 c7 e0 08 ret <== NOT EXECUTED 2006478: 81 e8 00 00 restore <== NOT EXECUTED 02017610 : * close a directory. */ int closedir(dirp) register DIR *dirp; { 2017610: 9d e3 bf 98 save %sp, -104, %sp int fd; if ( !dirp ) 2017614: a0 96 20 00 orcc %i0, 0, %l0 2017618: 02 80 00 0b be 2017644 201761c: 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); 2017620: d0 04 20 0c ld [ %l0 + 0xc ], %o0 int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 2017624: f0 04 00 00 ld [ %l0 ], %i0 dirp->dd_fd = -1; dirp->dd_loc = 0; 2017628: c0 24 20 04 clr [ %l0 + 4 ] (void)free((void *)dirp->dd_buf); 201762c: 7f ff b3 cf call 2004568 2017630: c2 24 00 00 st %g1, [ %l0 ] (void)free((void *)dirp); 2017634: 7f ff b3 cd call 2004568 2017638: 90 10 00 10 mov %l0, %o0 return(close(fd)); 201763c: 7f ff b1 ec call 2003dec 2017640: 81 e8 00 00 restore register DIR *dirp; { int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 2017644: 40 00 38 75 call 2025818 <__errno> <== NOT EXECUTED 2017648: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201764c: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 2017650: 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)); } 2017654: 81 c7 e0 08 ret <== NOT EXECUTED 2017658: 81 e8 00 00 restore <== NOT EXECUTED 0200e208 : */ int device_close( rtems_libio_t *iop ) { 200e208: 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; 200e20c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 args.iop = iop; 200e210: f0 27 bf ec st %i0, [ %fp + -20 ] args.flags = 0; 200e214: c0 27 bf f0 clr [ %fp + -16 ] args.mode = 0; 200e218: c0 27 bf f4 clr [ %fp + -12 ] status = rtems_io_close( 200e21c: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 200e220: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 200e224: 94 07 bf ec add %fp, -20, %o2 200e228: 40 00 02 52 call 200eb70 200e22c: b0 10 20 00 clr %i0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 200e230: 80 a2 20 00 cmp %o0, 0 200e234: 12 80 00 04 bne 200e244 200e238: 01 00 00 00 nop return rtems_deviceio_errno(status); } return 0; } 200e23c: 81 c7 e0 08 ret 200e240: 81 e8 00 00 restore the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { return rtems_deviceio_errno(status); 200e244: 7f ff ff a1 call 200e0c8 <== NOT EXECUTED 200e248: 01 00 00 00 nop <== NOT EXECUTED } return 0; } 200e24c: 81 c7 e0 08 ret <== NOT EXECUTED 200e250: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 0200e0fc : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 200e0fc: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED args.iop = iop; args.command = command; args.buffer = buffer; the_jnode = iop->file_info; 200e100: 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; 200e104: f2 27 bf ec st %i1, [ %fp + -20 ] <== NOT EXECUTED args.buffer = buffer; 200e108: 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; 200e10c: 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( 200e110: d2 00 60 50 ld [ %g1 + 0x50 ], %o1 <== NOT EXECUTED 200e114: d0 00 60 4c ld [ %g1 + 0x4c ], %o0 <== NOT EXECUTED 200e118: 40 00 02 ac call 200ebc8 <== NOT EXECUTED 200e11c: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200e120: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200e124: 12 80 00 05 bne 200e138 <== NOT EXECUTED 200e128: 01 00 00 00 nop <== NOT EXECUTED return rtems_deviceio_errno(status); return args.ioctl_return; 200e12c: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED } 200e130: 81 c7 e0 08 ret <== NOT EXECUTED 200e134: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 200e138: 7f ff ff e4 call 200e0c8 <== NOT EXECUTED 200e13c: 01 00 00 00 nop <== NOT EXECUTED return args.ioctl_return; } 200e140: 81 c7 e0 08 ret <== NOT EXECUTED 200e144: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 0200e254 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 200e254: 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; 200e258: 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; 200e25c: c4 06 20 2c ld [ %i0 + 0x2c ], %g2 args.iop = iop; 200e260: f0 27 bf ec st %i0, [ %fp + -20 ] args.flags = iop->flags; 200e264: c2 27 bf f0 st %g1, [ %fp + -16 ] args.mode = mode; 200e268: f6 27 bf f4 st %i3, [ %fp + -12 ] status = rtems_io_open( 200e26c: d2 00 a0 50 ld [ %g2 + 0x50 ], %o1 200e270: d0 00 a0 4c ld [ %g2 + 0x4c ], %o0 200e274: 94 07 bf ec add %fp, -20, %o2 200e278: 40 00 02 6a call 200ec20 200e27c: b0 10 20 00 clr %i0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200e280: 80 a2 20 00 cmp %o0, 0 200e284: 12 80 00 04 bne 200e294 200e288: 01 00 00 00 nop return rtems_deviceio_errno(status); return 0; } 200e28c: 81 c7 e0 08 ret 200e290: 81 e8 00 00 restore the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 200e294: 7f ff ff 8d call 200e0c8 <== NOT EXECUTED 200e298: 01 00 00 00 nop <== NOT EXECUTED return 0; } 200e29c: 81 c7 e0 08 ret <== NOT EXECUTED 200e2a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 0200e1a8 : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 200e1a8: 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; 200e1ac: 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; 200e1b0: 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; 200e1b4: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 <== NOT EXECUTED args.iop = iop; args.offset = iop->offset; args.buffer = buffer; 200e1b8: 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; 200e1bc: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED args.buffer = buffer; args.count = count; 200e1c0: f4 27 bf ec st %i2, [ %fp + -20 ] <== NOT EXECUTED args.flags = iop->flags; 200e1c4: 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; 200e1c8: 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; 200e1cc: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED status = rtems_io_read( 200e1d0: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 <== NOT EXECUTED 200e1d4: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 <== NOT EXECUTED 200e1d8: 40 00 02 a8 call 200ec78 <== NOT EXECUTED 200e1dc: 94 07 bf e0 add %fp, -32, %o2 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200e1e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200e1e4: 12 80 00 05 bne 200e1f8 <== NOT EXECUTED 200e1e8: 01 00 00 00 nop <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 200e1ec: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED } 200e1f0: 81 c7 e0 08 ret <== NOT EXECUTED 200e1f4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 200e1f8: 7f ff ff b4 call 200e0c8 <== NOT EXECUTED 200e1fc: 01 00 00 00 nop <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 200e200: 81 c7 e0 08 ret <== NOT EXECUTED 200e204: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 0200e148 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 200e148: 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; 200e14c: 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; 200e150: 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; 200e154: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; 200e158: 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; 200e15c: c2 27 bf e4 st %g1, [ %fp + -28 ] args.buffer = (void *) buffer; args.count = count; 200e160: f4 27 bf ec st %i2, [ %fp + -20 ] args.flags = iop->flags; 200e164: 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; 200e168: 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; 200e16c: c0 27 bf f4 clr [ %fp + -12 ] status = rtems_io_write( 200e170: d2 00 e0 50 ld [ %g3 + 0x50 ], %o1 200e174: d0 00 e0 4c ld [ %g3 + 0x4c ], %o0 200e178: 40 00 02 d6 call 200ecd0 200e17c: 94 07 bf e0 add %fp, -32, %o2 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 200e180: 80 a2 20 00 cmp %o0, 0 200e184: 12 80 00 05 bne 200e198 200e188: 01 00 00 00 nop return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 200e18c: d0 07 bf f4 ld [ %fp + -12 ], %o0 } 200e190: 81 c7 e0 08 ret 200e194: 91 e8 00 08 restore %g0, %o0, %o0 the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 200e198: 7f ff ff cc call 200e0c8 <== NOT EXECUTED 200e19c: 01 00 00 00 nop <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 200e1a0: 81 c7 e0 08 ret <== NOT EXECUTED 200e1a4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 020041e8 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 20041e8: 9d e3 bf 98 save %sp, -104, %sp rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 20041ec: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1 20041f0: 80 a0 60 00 cmp %g1, 0 20041f4: 12 80 00 04 bne 2004204 20041f8: 01 00 00 00 nop 20041fc: 81 c7 e0 08 ret 2004200: 81 e8 00 00 restore rtems_interrupt_disable (level); 2004204: 7f ff f6 fe call 2001dfc <== NOT EXECUTED 2004208: 01 00 00 00 nop <== NOT EXECUTED while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 200420c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED 2004210: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2004214: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004218: 12 80 00 0a bne 2004240 <== NOT EXECUTED 200421c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2004220: 30 80 00 1b b,a 200428c <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 2004224: 7f ff f6 f6 call 2001dfc <== NOT EXECUTED 2004228: 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) { 200422c: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED 2004230: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2004234: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004238: 02 80 00 15 be 200428c <== NOT EXECUTED 200423c: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED tty->rawOutBufState = rob_wait; 2004240: c2 26 20 94 st %g1, [ %i0 + 0x94 ] <== NOT EXECUTED rtems_interrupt_enable (level); 2004244: 7f ff f6 f2 call 2001e0c <== NOT EXECUTED 2004248: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 200424c: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED 2004250: 92 10 20 00 clr %o1 <== NOT EXECUTED 2004254: 40 00 06 eb call 2005e00 <== NOT EXECUTED 2004258: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 200425c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004260: 02 bf ff f1 be 2004224 <== NOT EXECUTED 2004264: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004268: 40 00 0a 02 call 2006a70 <== NOT EXECUTED 200426c: 01 00 00 00 nop <== NOT EXECUTED rtems_interrupt_disable (level); 2004270: 7f ff f6 e3 call 2001dfc <== NOT EXECUTED 2004274: 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) { 2004278: c4 06 20 84 ld [ %i0 + 0x84 ], %g2 <== NOT EXECUTED 200427c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2004280: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004284: 12 bf ff ef bne 2004240 <== NOT EXECUTED 2004288: 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); 200428c: 7f ff f6 e0 call 2001e0c <== NOT EXECUTED 2004290: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 2004294: 01 00 00 00 nop 02002f0c : int dup2( int fildes, int fildes2 ) { 2002f0c: 9d e3 bf 48 save %sp, -184, %sp /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 2002f10: a0 07 bf a8 add %fp, -88, %l0 2002f14: 90 10 00 18 mov %i0, %o0 2002f18: 40 00 01 ce call 2003650 2002f1c: 92 10 00 10 mov %l0, %o1 if ( status == -1 ) 2002f20: 80 a2 3f ff cmp %o0, -1 2002f24: 32 80 00 05 bne,a 2002f38 2002f28: 92 10 00 10 mov %l0, %o1 /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 2002f2c: 90 10 3f ff mov -1, %o0 } 2002f30: 81 c7 e0 08 ret 2002f34: 91 e8 00 08 restore %g0, %o0, %o0 /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 2002f38: 40 00 01 c6 call 2003650 2002f3c: 90 10 00 19 mov %i1, %o0 if ( status == -1 ) 2002f40: 80 a2 3f ff cmp %o0, -1 2002f44: 02 bf ff fa be 2002f2c 2002f48: 90 10 00 18 mov %i0, %o0 /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 2002f4c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 2002f50: 40 00 00 a1 call 20031d4 <== NOT EXECUTED 2002f54: 92 10 20 00 clr %o1 <== NOT EXECUTED 2002f58: 30 bf ff f6 b,a 2002f30 <== NOT EXECUTED 02003bf8 : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 2003bf8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 2003bfc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 2003c00: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 2003c04: 02 80 00 18 be 2003c64 <== NOT EXECUTED 2003c08: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2003c0c: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 2018e30 <__ctype_ptr> <== NOT EXECUTED 2003c10: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED 2003c14: c2 0a 00 02 ldub [ %o0 + %g2 ], %g1 <== NOT EXECUTED 2003c18: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003c1c: 02 80 00 13 be 2003c68 <== NOT EXECUTED 2003c20: 80 a2 20 09 cmp %o0, 9 <== NOT EXECUTED 2003c24: 02 80 00 11 be 2003c68 <== NOT EXECUTED 2003c28: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED 2003c2c: 02 80 00 0f be 2003c68 <== NOT EXECUTED 2003c30: 82 1e 20 40 xor %i0, 0x40, %g1 <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 2003c34: 84 10 20 5e mov 0x5e, %g2 <== NOT EXECUTED echobuf[1] = c ^ 0x40; 2003c38: 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] = '^'; 2003c3c: c4 2f bf f6 stb %g2, [ %fp + -10 ] <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); 2003c40: 90 07 bf f6 add %fp, -10, %o0 <== NOT EXECUTED 2003c44: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2003c48: 7f ff ff 36 call 2003920 <== NOT EXECUTED 2003c4c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED tty->column += 2; 2003c50: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED 2003c54: 82 00 60 02 add %g1, 2, %g1 <== NOT EXECUTED 2003c58: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED 2003c5c: 81 c7 e0 08 ret <== NOT EXECUTED 2003c60: 81 e8 00 00 restore <== NOT EXECUTED 2003c64: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED } else { oproc (c, tty); 2003c68: 7f ff ff 83 call 2003a74 <== NOT EXECUTED 2003c6c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2003c70: 81 c7 e0 08 ret <== NOT EXECUTED 2003c74: 81 e8 00 00 restore <== NOT EXECUTED 02017e1c : group_fp = fopen("/etc/group", "r"); } void endgrent(void) { if (group_fp != NULL) 2017e1c: 03 00 80 f2 sethi %hi(0x203c800), %g1 <== NOT EXECUTED 2017e20: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 203caac <== NOT EXECUTED 2017e24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017e28: 02 80 00 05 be 2017e3c <== NOT EXECUTED 2017e2c: 01 00 00 00 nop <== NOT EXECUTED fclose(group_fp); 2017e30: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2017e34: 40 00 36 cf call 2025970 <== NOT EXECUTED 2017e38: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2017e3c: 81 c3 e0 08 retl <== NOT EXECUTED 2017e40: 01 00 00 00 nop 02017e44 : passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { if (passwd_fp != NULL) 2017e44: 03 00 80 f2 sethi %hi(0x203c800), %g1 <== NOT EXECUTED 2017e48: d0 00 61 c4 ld [ %g1 + 0x1c4 ], %o0 ! 203c9c4 <== NOT EXECUTED 2017e4c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017e50: 02 80 00 05 be 2017e64 <== NOT EXECUTED 2017e54: 01 00 00 00 nop <== NOT EXECUTED fclose(passwd_fp); 2017e58: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2017e5c: 40 00 36 c5 call 2025970 <== NOT EXECUTED 2017e60: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2017e64: 81 c3 e0 08 retl <== NOT EXECUTED 2017e68: 01 00 00 00 nop 02003c78 : * 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) { 2003c78: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (tty->ccount == 0) 2003c7c: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 <== NOT EXECUTED 2003c80: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003c84: 02 80 00 36 be 2003d5c <== NOT EXECUTED 2003c88: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED return; if (lineFlag) { 2003c8c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2003c90: 12 80 00 35 bne 2003d64 <== NOT EXECUTED 2003c94: c6 06 20 3c ld [ %i0 + 0x3c ], %g3 <== NOT EXECUTED 2003c98: 27 00 80 5e sethi %hi(0x2017800), %l3 <== NOT EXECUTED 2003c9c: 03 00 80 5e sethi %hi(0x2017800), %g1 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 2003ca0: 25 00 80 63 sethi %hi(0x2018c00), %l2 <== NOT EXECUTED 2003ca4: a2 10 61 90 or %g1, 0x190, %l1 <== NOT EXECUTED 2003ca8: 10 80 00 0d b 2003cdc <== NOT EXECUTED 2003cac: a8 14 e1 98 or %l3, 0x198, %l4 <== NOT EXECUTED 2003cb0: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED 2003cb4: 12 80 00 6a bne 2003e5c <== NOT EXECUTED 2003cb8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 2003cbc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2003cc0: 02 80 00 65 be 2003e54 <== NOT EXECUTED 2003cc4: 01 00 00 00 nop <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 2003cc8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 2003ccc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003cd0: 02 80 00 61 be 2003e54 <== NOT EXECUTED 2003cd4: 01 00 00 00 nop <== NOT EXECUTED 2003cd8: c6 04 20 3c ld [ %l0 + 0x3c ], %g3 <== NOT EXECUTED unsigned char c = tty->cbuf[--tty->ccount]; 2003cdc: da 04 20 1c ld [ %l0 + 0x1c ], %o5 <== NOT EXECUTED 2003ce0: 88 00 bf ff add %g2, -1, %g4 <== NOT EXECUTED 2003ce4: c8 24 20 20 st %g4, [ %l0 + 0x20 ] <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 2003ce8: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED 2003cec: 02 bf ff f4 be 2003cbc <== NOT EXECUTED 2003cf0: c4 0b 40 04 ldub [ %o5 + %g4 ], %g2 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 2003cf4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2003cf8: 12 80 00 05 bne 2003d0c <== NOT EXECUTED 2003cfc: 83 28 a0 18 sll %g2, 0x18, %g1 <== NOT EXECUTED 2003d00: 80 88 e0 10 btst 0x10, %g3 <== NOT EXECUTED 2003d04: 22 80 00 6a be,a 2003eac <== NOT EXECUTED 2003d08: f0 0c 20 43 ldub [ %l0 + 0x43 ], %i0 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 2003d0c: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED 2003d10: 80 a0 60 09 cmp %g1, 9 <== NOT EXECUTED 2003d14: 02 80 00 24 be 2003da4 <== NOT EXECUTED 2003d18: c2 04 a2 30 ld [ %l2 + 0x230 ], %g1 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 2003d1c: b0 08 a0 ff and %g2, 0xff, %i0 <== NOT EXECUTED 2003d20: c4 0e 00 01 ldub [ %i0 + %g1 ], %g2 <== NOT EXECUTED 2003d24: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED 2003d28: 12 bf ff e2 bne 2003cb0 <== NOT EXECUTED 2003d2c: 90 10 00 13 mov %l3, %o0 <== 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); 2003d30: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED 2003d34: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2003d38: 7f ff fe fa call 2003920 <== NOT EXECUTED 2003d3c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED if (tty->column) 2003d40: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003d44: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003d48: 02 bf ff de be 2003cc0 <== NOT EXECUTED 2003d4c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED tty->column--; 2003d50: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED } } } if (!lineFlag) 2003d54: 12 bf ff dd bne 2003cc8 <== NOT EXECUTED 2003d58: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED 2003d5c: 81 c7 e0 08 ret <== NOT EXECUTED 2003d60: 81 e8 00 00 restore <== NOT EXECUTED erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 2003d64: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED 2003d68: 22 bf ff fd be,a 2003d5c <== NOT EXECUTED 2003d6c: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 2003d70: 80 88 e0 10 btst 0x10, %g3 <== NOT EXECUTED 2003d74: 12 bf ff ca bne 2003c9c <== NOT EXECUTED 2003d78: 27 00 80 5e sethi %hi(0x2017800), %l3 <== NOT EXECUTED tty->ccount = 0; echo (tty->termios.c_cc[VKILL], tty); 2003d7c: 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; 2003d80: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 2003d84: 7f ff ff 9d call 2003bf8 <== NOT EXECUTED 2003d88: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 2003d8c: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED 2003d90: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003d94: 02 bf ff f2 be 2003d5c <== NOT EXECUTED 2003d98: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED echo ('\n', tty); 2003d9c: 7f ff ff 97 call 2003bf8 <== NOT EXECUTED 2003da0: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 2003da4: 80 a1 20 00 cmp %g4, 0 <== NOT EXECUTED 2003da8: 02 80 00 19 be 2003e0c <== NOT EXECUTED 2003dac: f0 04 20 2c ld [ %l0 + 0x2c ], %i0 <== NOT EXECUTED c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 2003db0: d8 04 a2 30 ld [ %l2 + 0x230 ], %o4 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 2003db4: 96 08 e2 00 and %g3, 0x200, %o3 <== NOT EXECUTED while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 2003db8: 10 80 00 07 b 2003dd4 <== NOT EXECUTED 2003dbc: 86 10 20 00 clr %g3 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 2003dc0: 32 80 00 02 bne,a 2003dc8 <== NOT EXECUTED 2003dc4: b0 06 20 02 add %i0, 2, %i0 <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 2003dc8: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED 2003dcc: 22 80 00 11 be,a 2003e10 <== NOT EXECUTED 2003dd0: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED c = tty->cbuf[i++]; 2003dd4: c2 08 c0 0d ldub [ %g3 + %o5 ], %g1 <== NOT EXECUTED if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 2003dd8: 84 08 60 ff and %g1, 0xff, %g2 <== NOT EXECUTED /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { 2003ddc: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED 2003de0: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED 2003de4: 80 a0 60 09 cmp %g1, 9 <== NOT EXECUTED 2003de8: 02 80 00 18 be 2003e48 <== NOT EXECUTED 2003dec: 86 00 e0 01 inc %g3 <== NOT EXECUTED col = (col | 7) + 1; } else if (iscntrl (c)) { 2003df0: c2 08 80 0c ldub [ %g2 + %o4 ], %g1 <== NOT EXECUTED 2003df4: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2003df8: 12 bf ff f2 bne 2003dc0 <== NOT EXECUTED 2003dfc: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 2003e00: 80 a0 c0 04 cmp %g3, %g4 <== NOT EXECUTED 2003e04: 12 bf ff f4 bne 2003dd4 <== NOT EXECUTED 2003e08: b0 06 20 01 inc %i0 <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 2003e0c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003e10: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2003e14: 16 bf ff ab bge 2003cc0 <== NOT EXECUTED 2003e18: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); 2003e1c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2003e20: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2003e24: 7f ff fe bf call 2003920 <== NOT EXECUTED 2003e28: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED tty->column--; 2003e2c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003e30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 2003e34: 80 a0 40 18 cmp %g1, %i0 <== NOT EXECUTED 2003e38: 14 bf ff f9 bg 2003e1c <== NOT EXECUTED 2003e3c: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 2003e40: 10 bf ff a0 b 2003cc0 <== NOT EXECUTED 2003e44: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; 2003e48: 82 16 20 07 or %i0, 7, %g1 <== NOT EXECUTED 2003e4c: 10 bf ff df b 2003dc8 <== NOT EXECUTED 2003e50: b0 00 60 01 add %g1, 1, %i0 <== NOT EXECUTED 2003e54: 81 c7 e0 08 ret <== NOT EXECUTED 2003e58: 81 e8 00 00 restore <== NOT EXECUTED tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 2003e5c: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2003e60: 7f ff fe b0 call 2003920 <== NOT EXECUTED 2003e64: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED if (tty->column) 2003e68: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED 2003e6c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003e70: 02 80 00 04 be 2003e80 <== NOT EXECUTED 2003e74: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED tty->column--; 2003e78: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003e7c: c2 24 20 28 st %g1, [ %l0 + 0x28 ] <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 2003e80: c2 04 a2 30 ld [ %l2 + 0x230 ], %g1 <== NOT EXECUTED 2003e84: c4 0e 00 01 ldub [ %i0 + %g1 ], %g2 <== NOT EXECUTED 2003e88: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED 2003e8c: 22 bf ff aa be,a 2003d34 <== NOT EXECUTED 2003e90: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED 2003e94: c6 04 20 3c ld [ %l0 + 0x3c ], %g3 <== NOT EXECUTED 2003e98: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED 2003e9c: 32 bf ff a6 bne,a 2003d34 <== NOT EXECUTED 2003ea0: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 2003ea4: 10 bf ff 87 b 2003cc0 <== NOT EXECUTED 2003ea8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); 2003eac: 7f ff ff 53 call 2003bf8 <== NOT EXECUTED 2003eb0: 93 e8 00 10 restore %g0, %l0, %o1 <== NOT EXECUTED 2003eb4: 01 00 00 00 nop 02022ee4 : int fcntl( int fd, int cmd, ... ) { 2022ee4: 9d e3 bf 90 save %sp, -112, %sp int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 2022ee8: 03 00 80 ea sethi %hi(0x203a800), %g1 2022eec: d8 00 61 ec ld [ %g1 + 0x1ec ], %o4 ! 203a9ec ... ) { int ret; va_list ap; va_start( ap, cmd ); 2022ef0: 88 07 a0 4c add %fp, 0x4c, %g4 int fcntl( int fd, int cmd, ... ) { 2022ef4: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 2022ef8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2022efc: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2022f00: fa 27 a0 58 st %i5, [ %fp + 0x58 ] int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 2022f04: 80 a6 00 0c cmp %i0, %o4 2022f08: 1a 80 00 78 bcc 20230e8 2022f0c: c8 27 bf f4 st %g4, [ %fp + -12 ] iop = rtems_libio_iop( fd ); 2022f10: 3b 00 80 f5 sethi %hi(0x203d400), %i5 2022f14: da 07 60 20 ld [ %i5 + 0x20 ], %o5 ! 203d420 2022f18: 85 2e 20 02 sll %i0, 2, %g2 2022f1c: 83 2e 20 04 sll %i0, 4, %g1 2022f20: 82 20 40 02 sub %g1, %g2, %g1 2022f24: 82 00 40 18 add %g1, %i0, %g1 2022f28: 83 28 60 02 sll %g1, 2, %g1 2022f2c: b0 00 40 0d add %g1, %o5, %i0 rtems_libio_check_is_open(iop); 2022f30: d0 06 20 0c ld [ %i0 + 0xc ], %o0 2022f34: 80 8a 21 00 btst 0x100, %o0 2022f38: 02 80 00 6c be 20230e8 2022f3c: 80 a6 60 09 cmp %i1, 9 /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 2022f40: 08 80 00 09 bleu 2022f64 2022f44: 83 2e 60 02 sll %i1, 2, %g1 errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 2022f48: 40 00 0a 34 call 2025818 <__errno> 2022f4c: 01 00 00 00 nop 2022f50: 82 10 20 16 mov 0x16, %g1 ! 16 2022f54: c2 22 00 00 st %g1, [ %o0 ] { int ret; va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); 2022f58: b8 10 3f ff mov -1, %i4 return ret; } 2022f5c: 81 c7 e0 08 ret 2022f60: 91 e8 00 1c restore %g0, %i4, %o0 /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 2022f64: 05 00 80 8b sethi %hi(0x2022c00), %g2 2022f68: 84 10 a2 bc or %g2, 0x2bc, %g2 ! 2022ebc 2022f6c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2022f70: 81 c0 c0 00 jmp %g3 2022f74: 01 00 00 00 nop errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 2022f78: 40 00 0a 28 call 2025818 <__errno> 2022f7c: b8 10 3f ff mov -1, %i4 ! ffffffff 2022f80: 82 10 20 86 mov 0x86, %g1 2022f84: 10 bf ff f6 b 2022f5c 2022f88: c2 22 00 00 st %g1, [ %o0 ] case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 2022f8c: d0 01 00 00 ld [ %g4 ], %o0 2022f90: 7f ff 85 5d call 2004504 2022f94: 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); 2022f98: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2022f9c: 90 0a 22 01 and %o0, 0x201, %o0 2022fa0: 82 08 7d fe and %g1, -514, %g1 2022fa4: 90 12 00 01 or %o0, %g1, %o0 2022fa8: d0 26 20 0c st %o0, [ %i0 + 0xc ] * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { if (iop->handlers->fcntl_h) { 2022fac: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2022fb0: c2 00 60 30 ld [ %g1 + 0x30 ], %g1 2022fb4: 80 a0 60 00 cmp %g1, 0 2022fb8: 02 bf ff e9 be 2022f5c 2022fbc: 90 10 00 19 mov %i1, %o0 int err = (*iop->handlers->fcntl_h)( cmd, iop ); 2022fc0: 9f c0 40 00 call %g1 2022fc4: 92 10 00 18 mov %i0, %o1 if (err) { 2022fc8: ba 92 20 00 orcc %o0, 0, %i5 2022fcc: 02 bf ff e4 be 2022f5c 2022fd0: 01 00 00 00 nop errno = err; 2022fd4: 40 00 0a 11 call 2025818 <__errno> <== NOT EXECUTED 2022fd8: b8 10 3f ff mov -1, %i4 ! ffffffff <== NOT EXECUTED 2022fdc: 10 bf ff e0 b 2022f5c <== NOT EXECUTED 2022fe0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 2022fe4: 7f ff 84 9a call 200424c 2022fe8: 01 00 00 00 nop 2022fec: b8 10 00 08 mov %o0, %i4 /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 2022ff0: 80 a7 20 00 cmp %i4, 0 2022ff4: 36 bf ff ef bge,a 2022fb0 2022ff8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2022ffc: 30 bf ff d8 b,a 2022f5c <== NOT EXECUTED * 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 ) ) 2023000: c2 01 00 00 ld [ %g4 ], %g1 2023004: 80 a0 60 00 cmp %g1, 0 2023008: 22 80 00 2d be,a 20230bc 202300c: 90 0a 37 ff and %o0, -2049, %o0 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 2023010: 90 12 28 00 or %o0, 0x800, %o0 2023014: b8 10 20 00 clr %i4 2023018: 10 bf ff e5 b 2022fac 202301c: d0 26 20 0c st %o0, [ %i0 + 0xc ] diop->pathinfo = iop->pathinfo; ret = (int) (diop - rtems_libio_iops); break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 2023020: 83 32 20 0b srl %o0, 0xb, %g1 2023024: 10 bf ff e2 b 2022fac 2023028: b8 08 60 01 and %g1, 1, %i4 * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 202302c: c6 01 00 00 ld [ %g4 ], %g3 if ( fd2 ) 2023030: 80 a0 e0 00 cmp %g3, 0 2023034: 02 80 00 32 be 20230fc 2023038: 80 a3 00 03 cmp %o4, %g3 diop = rtems_libio_iop( fd2 ); 202303c: 96 10 20 00 clr %o3 <== NOT EXECUTED 2023040: 18 80 00 22 bgu 20230c8 <== NOT EXECUTED 2023044: 98 10 20 00 clr %o4 <== NOT EXECUTED } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; 2023048: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 break; } } diop->handlers = iop->handlers; diop->file_info = iop->file_info; 202304c: c6 06 20 2c ld [ %i0 + 0x2c ], %g3 diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; 2023050: c2 23 20 10 st %g1, [ %o4 + 0x10 ] 2023054: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 ret = (int) (diop - rtems_libio_iops); 2023058: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; 202305c: c4 23 20 14 st %g2, [ %o4 + 0x14 ] 2023060: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 ret = -1; break; } } diop->handlers = iop->handlers; 2023064: da 06 20 30 ld [ %i0 + 0x30 ], %o5 diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; 2023068: c2 23 20 18 st %g1, [ %o4 + 0x18 ] 202306c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 ret = (int) (diop - rtems_libio_iops); 2023070: 88 22 c0 04 sub %o3, %g4, %g4 break; } } diop->handlers = iop->handlers; diop->file_info = iop->file_info; 2023074: c6 23 20 2c st %g3, [ %o4 + 0x2c ] diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; ret = (int) (diop - rtems_libio_iops); 2023078: 89 39 20 02 sra %g4, 2, %g4 202307c: 87 29 20 02 sll %g4, 2, %g3 } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; 2023080: c4 23 20 1c st %g2, [ %o4 + 0x1c ] ret = -1; break; } } diop->handlers = iop->handlers; 2023084: da 23 20 30 st %o5, [ %o4 + 0x30 ] diop->file_info = iop->file_info; diop->flags = iop->flags; diop->pathinfo = iop->pathinfo; ret = (int) (diop - rtems_libio_iops); 2023088: 85 29 20 06 sll %g4, 6, %g2 } } diop->handlers = iop->handlers; diop->file_info = iop->file_info; diop->flags = iop->flags; 202308c: d0 23 20 0c st %o0, [ %o4 + 0xc ] diop->pathinfo = iop->pathinfo; ret = (int) (diop - rtems_libio_iops); 2023090: 84 20 80 03 sub %g2, %g3, %g2 2023094: 83 28 a0 06 sll %g2, 6, %g1 2023098: 82 20 40 02 sub %g1, %g2, %g1 202309c: 87 28 60 0c sll %g1, 0xc, %g3 20230a0: 82 00 40 03 add %g1, %g3, %g1 20230a4: 82 00 40 04 add %g1, %g4, %g1 20230a8: 83 28 60 04 sll %g1, 4, %g1 20230ac: 82 20 40 04 sub %g1, %g4, %g1 20230b0: 83 28 60 02 sll %g1, 2, %g1 20230b4: 10 bf ff cf b 2022ff0 20230b8: b8 21 00 01 sub %g4, %g1, %i4 */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 20230bc: b8 10 20 00 clr %i4 <== NOT EXECUTED 20230c0: 10 bf ff bb b 2022fac <== NOT EXECUTED 20230c4: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); 20230c8: 85 28 e0 02 sll %g3, 2, %g2 <== NOT EXECUTED 20230cc: 83 28 e0 04 sll %g3, 4, %g1 <== NOT EXECUTED 20230d0: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 20230d4: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED 20230d8: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 20230dc: 96 03 40 01 add %o5, %g1, %o3 <== NOT EXECUTED 20230e0: 10 bf ff da b 2023048 <== NOT EXECUTED 20230e4: 98 10 00 0b mov %o3, %o4 <== NOT EXECUTED int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 20230e8: 40 00 09 cc call 2025818 <__errno> <== NOT EXECUTED 20230ec: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED 20230f0: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 20230f4: 10 bf ff 9a b 2022f5c <== NOT EXECUTED 20230f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); 20230fc: 7f ff 84 c4 call 200440c 2023100: 01 00 00 00 nop if ( diop == 0 ) { 2023104: 98 92 20 00 orcc %o0, 0, %o4 2023108: 02 bf ff 94 be 2022f58 202310c: 96 10 00 0c mov %o4, %o3 2023110: 10 bf ff ce b 2023048 2023114: d0 06 20 0c ld [ %i0 + 0xc ], %o0 020072f8 : /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 20072f8: 03 00 80 6b sethi %hi(0x201ac00), %g1 20072fc: c4 00 61 44 ld [ %g1 + 0x144 ], %g2 ! 201ad44 2007300: 82 10 61 44 or %g1, 0x144, %g1 2007304: 86 00 60 04 add %g1, 4, %g3 !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); 2007308: 80 a0 80 03 cmp %g2, %g3 200730c: 02 80 00 10 be 200734c 2007310: 01 00 00 00 nop the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 2007314: d2 02 60 0c ld [ %o1 + 0xc ], %o1 2007318: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 200731c: 80 a0 40 09 cmp %g1, %o1 2007320: 32 80 00 08 bne,a 2007340 2007324: c4 00 80 00 ld [ %g2 ], %g2 * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); 2007328: 81 c3 e0 08 retl <== NOT EXECUTED 200732c: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 2007330: 80 a0 40 09 cmp %g1, %o1 2007334: 02 80 00 08 be 2007354 2007338: 90 10 20 01 mov 1, %o0 * mount 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 ) { 200733c: c4 00 80 00 ld [ %g2 ], %g2 * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); 2007340: 80 a0 80 03 cmp %g2, %g3 2007344: 32 bf ff fb bne,a 2007330 2007348: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 return TRUE; } } return FALSE; } 200734c: 81 c3 e0 08 retl 2007350: 90 10 20 00 clr %o0 2007354: 81 c3 e0 08 retl 2007358: 01 00 00 00 nop 0200350c : long fpathconf( int fd, int name ) { 200350c: 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); 2003510: 03 00 80 61 sethi %hi(0x2018400), %g1 2003514: c4 00 63 dc ld [ %g1 + 0x3dc ], %g2 ! 20187dc 2003518: 80 a6 00 02 cmp %i0, %g2 200351c: 1a 80 00 41 bcc 2003620 2003520: 03 00 80 66 sethi %hi(0x2019800), %g1 iop = rtems_libio_iop(fd); 2003524: c6 00 61 9c ld [ %g1 + 0x19c ], %g3 ! 201999c 2003528: 85 2e 20 02 sll %i0, 2, %g2 200352c: 83 2e 20 04 sll %i0, 4, %g1 2003530: 82 20 40 02 sub %g1, %g2, %g1 2003534: 82 00 40 18 add %g1, %i0, %g1 2003538: 83 28 60 02 sll %g1, 2, %g1 200353c: 82 00 40 03 add %g1, %g3, %g1 rtems_libio_check_is_open(iop); 2003540: c6 00 60 0c ld [ %g1 + 0xc ], %g3 2003544: 80 88 e1 00 btst 0x100, %g3 2003548: 02 80 00 36 be 2003620 200354c: 80 88 e0 02 btst 2, %g3 rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 2003550: 02 80 00 3a be 2003638 2003554: 80 a6 60 0b cmp %i1, 0xb * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 2003558: 08 80 00 08 bleu 2003578 200355c: f0 00 60 1c ld [ %g1 + 0x1c ], %i0 break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2003560: 40 00 39 d7 call 2011cbc <__errno> 2003564: b0 10 3f ff mov -1, %i0 2003568: 82 10 20 16 mov 0x16, %g1 200356c: c2 22 00 00 st %g1, [ %o0 ] break; } return return_value; } 2003570: 81 c7 e0 08 ret 2003574: 81 e8 00 00 restore * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 2003578: 83 2e 60 02 sll %i1, 2, %g1 200357c: 05 00 80 0d sethi %hi(0x2003400), %g2 2003580: 84 10 a0 dc or %g2, 0xdc, %g2 ! 20034dc 2003584: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2003588: 81 c0 c0 00 jmp %g3 200358c: 01 00 00 00 nop break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 2003590: f0 06 20 58 ld [ %i0 + 0x58 ], %i0 2003594: 81 c7 e0 08 ret 2003598: 81 e8 00 00 restore break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 200359c: f0 06 20 54 ld [ %i0 + 0x54 ], %i0 20035a0: 81 c7 e0 08 ret 20035a4: 81 e8 00 00 restore break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 20035a8: f0 06 20 48 ld [ %i0 + 0x48 ], %i0 20035ac: 81 c7 e0 08 ret 20035b0: 81 e8 00 00 restore break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 20035b4: f0 06 20 5c ld [ %i0 + 0x5c ], %i0 20035b8: 81 c7 e0 08 ret 20035bc: 81 e8 00 00 restore break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 20035c0: f0 06 20 50 ld [ %i0 + 0x50 ], %i0 20035c4: 81 c7 e0 08 ret 20035c8: 81 e8 00 00 restore break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 20035cc: f0 06 20 4c ld [ %i0 + 0x4c ], %i0 20035d0: 81 c7 e0 08 ret 20035d4: 81 e8 00 00 restore break; case _PC_PATH_MAX: return_value = the_limits->path_max; break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 20035d8: f0 06 20 44 ld [ %i0 + 0x44 ], %i0 20035dc: 81 c7 e0 08 ret 20035e0: 81 e8 00 00 restore break; case _PC_NAME_MAX: return_value = the_limits->name_max; break; case _PC_PATH_MAX: return_value = the_limits->path_max; 20035e4: f0 06 20 40 ld [ %i0 + 0x40 ], %i0 20035e8: 81 c7 e0 08 ret 20035ec: 81 e8 00 00 restore break; case _PC_MAX_INPUT: return_value = the_limits->max_input; break; case _PC_NAME_MAX: return_value = the_limits->name_max; 20035f0: f0 06 20 3c ld [ %i0 + 0x3c ], %i0 20035f4: 81 c7 e0 08 ret 20035f8: 81 e8 00 00 restore break; case _PC_MAX_CANON: return_value = the_limits->max_canon; break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 20035fc: f0 06 20 38 ld [ %i0 + 0x38 ], %i0 2003600: 81 c7 e0 08 ret 2003604: 81 e8 00 00 restore switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 2003608: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 200360c: 81 c7 e0 08 ret 2003610: 81 e8 00 00 restore the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; 2003614: f0 06 20 30 ld [ %i0 + 0x30 ], %i0 2003618: 81 c7 e0 08 ret 200361c: 81 e8 00 00 restore rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 2003620: 40 00 39 a7 call 2011cbc <__errno> 2003624: b0 10 3f ff mov -1, %i0 2003628: 82 10 20 09 mov 9, %g1 200362c: c2 22 00 00 st %g1, [ %o0 ] 2003630: 81 c7 e0 08 ret 2003634: 81 e8 00 00 restore rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 2003638: 40 00 39 a1 call 2011cbc <__errno> <== NOT EXECUTED 200363c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003640: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2003644: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003648: 81 c7 e0 08 ret <== NOT EXECUTED 200364c: 81 e8 00 00 restore <== NOT EXECUTED 020022f8 : } void free( void *ptr ) { 20022f8: 9d e3 bf 98 save %sp, -104, %sp MSBUMP(free_calls, 1); if ( !ptr ) 20022fc: 80 a6 20 00 cmp %i0, 0 2002300: 02 80 00 19 be 2002364 2002304: 03 00 80 66 sethi %hi(0x2019800), %g1 /* * Do not attempt to free memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 2002308: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> 200230c: 80 a0 a0 03 cmp %g2, 3 2002310: 12 80 00 0e bne 2002348 2002314: 03 00 80 66 sethi %hi(0x2019800), %g1 if ((_Thread_Dispatch_disable_level > 0) || (_ISR_Nest_level > 0)) { 2002318: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 200231c: 80 a0 a0 00 cmp %g2, 0 2002320: 12 80 00 06 bne 2002338 2002324: 03 00 80 66 sethi %hi(0x2019800), %g1 2002328: c4 00 61 08 ld [ %g1 + 0x108 ], %g2 ! 2019908 <_ISR_Nest_level> 200232c: 80 a0 a0 00 cmp %g2, 0 2002330: 02 80 00 07 be 200234c 2002334: 37 00 80 65 sethi %hi(0x2019400), %i3 Chain_Append(&RTEMS_Malloc_GC_list, (Chain_Node *)ptr); 2002338: b2 10 00 18 mov %i0, %i1 200233c: 31 00 80 65 sethi %hi(0x2019400), %i0 2002340: 40 00 12 a2 call 2006dc8 <_Chain_Append> 2002344: 91 ee 22 d8 restore %i0, 0x2d8, %o0 MSBUMP(lifetime_freed, size); } } #endif if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 2002348: 37 00 80 65 sethi %hi(0x2019400), %i3 <== NOT EXECUTED 200234c: 92 10 00 18 mov %i0, %o1 2002350: 40 00 18 ce call 2008688 <_Protected_heap_Free> 2002354: 90 16 e2 7c or %i3, 0x27c, %o0 2002358: 80 a2 20 00 cmp %o0, 0 200235c: 02 80 00 04 be 200236c 2002360: 82 16 e2 7c or %i3, 0x27c, %g1 2002364: 81 c7 e0 08 ret 2002368: 81 e8 00 00 restore printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 200236c: f6 00 60 1c ld [ %g1 + 0x1c ], %i3 <== NOT EXECUTED 2002370: f4 00 60 18 ld [ %g1 + 0x18 ], %i2 <== NOT EXECUTED 2002374: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED 2002378: 31 00 80 5e sethi %hi(0x2017800), %i0 <== NOT EXECUTED 200237c: 40 00 03 c8 call 200329c <== NOT EXECUTED 2002380: 91 ee 21 20 restore %i0, 0x120, %o0 <== NOT EXECUTED 2002384: 01 00 00 00 nop 020189f8 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 20189f8: 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 20189fc: 03 00 80 f7 sethi %hi(0x203dc00), %g1 <== NOT EXECUTED 2018a00: 82 10 60 84 or %g1, 0x84, %g1 ! 203dc84 <== NOT EXECUTED 2018a04: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED 2018a08: 02 80 00 18 be 2018a68 <== NOT EXECUTED 2018a0c: 01 00 00 00 nop <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 2018a10: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 2018a14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018a18: 22 80 00 09 be,a 2018a3c <== NOT EXECUTED 2018a1c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 2018a20: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2018a24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018a28: 22 80 00 05 be,a 2018a3c <== NOT EXECUTED 2018a2c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 2018a30: 9f c0 40 00 call %g1 <== NOT EXECUTED 2018a34: 90 06 20 04 add %i0, 4, %o0 <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 2018a38: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED 2018a3c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018a40: 02 80 00 08 be 2018a60 <== NOT EXECUTED 2018a44: 01 00 00 00 nop <== NOT EXECUTED 2018a48: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2018a4c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018a50: 02 80 00 04 be 2018a60 <== NOT EXECUTED 2018a54: 01 00 00 00 nop <== NOT EXECUTED 2018a58: 9f c0 40 00 call %g1 <== NOT EXECUTED 2018a5c: 90 06 20 14 add %i0, 0x14, %o0 <== NOT EXECUTED free(env); 2018a60: 7f ff ae c2 call 2004568 <== NOT EXECUTED 2018a64: 81 e8 00 00 restore <== NOT EXECUTED 2018a68: 81 c7 e0 08 ret <== NOT EXECUTED 2018a6c: 81 e8 00 00 restore <== NOT EXECUTED 02016c44 : int fstat( int fd, struct stat *sbuf ) { 2016c44: 9d e3 bf 98 save %sp, -104, %sp /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 2016c48: 92 96 60 00 orcc %i1, 0, %o1 2016c4c: 02 80 00 3f be 2016d48 2016c50: 03 00 80 61 sethi %hi(0x2018400), %g1 /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 2016c54: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20184ec 2016c58: 80 a6 00 02 cmp %i0, %g2 2016c5c: 1a 80 00 2f bcc 2016d18 2016c60: 03 00 80 65 sethi %hi(0x2019400), %g1 2016c64: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 ! 2019670 2016c68: 85 2e 20 02 sll %i0, 2, %g2 2016c6c: 83 2e 20 04 sll %i0, 4, %g1 2016c70: 82 20 40 02 sub %g1, %g2, %g1 2016c74: 82 00 40 18 add %g1, %i0, %g1 2016c78: 83 28 60 02 sll %g1, 2, %g1 2016c7c: 90 00 40 03 add %g1, %g3, %o0 rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 2016c80: c4 02 20 0c ld [ %o0 + 0xc ], %g2 2016c84: 80 88 a1 00 btst 0x100, %g2 2016c88: 02 80 00 24 be 2016d18 2016c8c: 01 00 00 00 nop if ( !iop->handlers ) 2016c90: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2016c94: 80 a0 60 00 cmp %g1, 0 2016c98: 02 80 00 20 be 2016d18 2016c9c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 2016ca0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 2016ca4: 80 a0 60 00 cmp %g1, 0 2016ca8: 02 80 00 22 be 2016d30 2016cac: 01 00 00 00 nop /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 2016cb0: c0 22 40 00 clr [ %o1 ] 2016cb4: c0 22 60 04 clr [ %o1 + 4 ] 2016cb8: c0 22 60 08 clr [ %o1 + 8 ] 2016cbc: c0 22 60 0c clr [ %o1 + 0xc ] 2016cc0: c0 22 60 10 clr [ %o1 + 0x10 ] 2016cc4: c0 22 60 14 clr [ %o1 + 0x14 ] 2016cc8: c0 22 60 18 clr [ %o1 + 0x18 ] 2016ccc: c0 22 60 1c clr [ %o1 + 0x1c ] 2016cd0: c0 22 60 20 clr [ %o1 + 0x20 ] 2016cd4: c0 22 60 24 clr [ %o1 + 0x24 ] 2016cd8: c0 22 60 28 clr [ %o1 + 0x28 ] 2016cdc: c0 22 60 2c clr [ %o1 + 0x2c ] 2016ce0: c0 22 60 30 clr [ %o1 + 0x30 ] 2016ce4: c0 22 60 34 clr [ %o1 + 0x34 ] 2016ce8: c0 22 60 38 clr [ %o1 + 0x38 ] 2016cec: c0 22 60 3c clr [ %o1 + 0x3c ] 2016cf0: c0 22 60 40 clr [ %o1 + 0x40 ] 2016cf4: c0 22 60 44 clr [ %o1 + 0x44 ] 2016cf8: c0 22 60 48 clr [ %o1 + 0x48 ] 2016cfc: c0 22 60 4c clr [ %o1 + 0x4c ] return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 2016d00: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 2016d04: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 2016d08: 9f c0 80 00 call %g2 2016d0c: 90 02 20 10 add %o0, 0x10, %o0 } 2016d10: 81 c7 e0 08 ret 2016d14: 91 e8 00 08 restore %g0, %o0, %o0 iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 2016d18: 7f ff e0 ea call 200f0c0 <__errno> 2016d1c: 01 00 00 00 nop 2016d20: 82 10 20 09 mov 9, %g1 ! 9 2016d24: c2 22 00 00 st %g1, [ %o0 ] 2016d28: 10 bf ff fa b 2016d10 2016d2c: 90 10 3f ff mov -1, %o0 if ( !iop->handlers->fstat_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2016d30: 7f ff e0 e4 call 200f0c0 <__errno> <== NOT EXECUTED 2016d34: 01 00 00 00 nop <== NOT EXECUTED 2016d38: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2016d3c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016d40: 10 bf ff f4 b 2016d10 <== NOT EXECUTED 2016d44: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 2016d48: 7f ff e0 de call 200f0c0 <__errno> 2016d4c: 01 00 00 00 nop 2016d50: 82 10 20 0e mov 0xe, %g1 ! e 2016d54: c2 22 00 00 st %g1, [ %o0 ] 2016d58: 10 bf ff ee b 2016d10 2016d5c: 90 10 3f ff mov -1, %o0 02003784 : #include int fsync( int fd ) { 2003784: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2003788: 03 00 80 61 sethi %hi(0x2018400), %g1 200378c: c4 00 63 dc ld [ %g1 + 0x3dc ], %g2 ! 20187dc 2003790: 80 a6 00 02 cmp %i0, %g2 2003794: 1a 80 00 1b bcc 2003800 2003798: 03 00 80 66 sethi %hi(0x2019800), %g1 iop = rtems_libio_iop( fd ); 200379c: c6 00 61 9c ld [ %g1 + 0x19c ], %g3 ! 201999c 20037a0: 85 2e 20 02 sll %i0, 2, %g2 20037a4: 83 2e 20 04 sll %i0, 4, %g1 20037a8: 82 20 40 02 sub %g1, %g2, %g1 20037ac: 82 00 40 18 add %g1, %i0, %g1 20037b0: 83 28 60 02 sll %g1, 2, %g1 20037b4: 90 00 40 03 add %g1, %g3, %o0 rtems_libio_check_is_open(iop); 20037b8: c6 02 20 0c ld [ %o0 + 0xc ], %g3 20037bc: 80 88 e1 00 btst 0x100, %g3 20037c0: 02 80 00 10 be 2003800 20037c4: 80 88 e0 04 btst 4, %g3 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 20037c8: 02 80 00 14 be 2003818 20037cc: 01 00 00 00 nop /* * Now process the fsync(). */ if ( !iop->handlers ) 20037d0: c6 02 20 30 ld [ %o0 + 0x30 ], %g3 20037d4: 80 a0 e0 00 cmp %g3, 0 20037d8: 02 80 00 0a be 2003800 20037dc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) 20037e0: c2 00 e0 28 ld [ %g3 + 0x28 ], %g1 20037e4: 80 a0 60 00 cmp %g1, 0 20037e8: 02 80 00 12 be 2003830 20037ec: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 20037f0: 9f c0 40 00 call %g1 20037f4: 01 00 00 00 nop } 20037f8: 81 c7 e0 08 ret 20037fc: 91 e8 00 08 restore %g0, %o0, %o0 /* * Now process the fsync(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 2003800: 40 00 39 2f call 2011cbc <__errno> <== NOT EXECUTED 2003804: 01 00 00 00 nop <== NOT EXECUTED 2003808: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 200380c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003810: 10 bf ff fa b 20037f8 <== NOT EXECUTED 2003814: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 2003818: 40 00 39 29 call 2011cbc <__errno> 200381c: 01 00 00 00 nop 2003820: 82 10 20 16 mov 0x16, %g1 ! 16 2003824: c2 22 00 00 st %g1, [ %o0 ] 2003828: 10 bf ff f4 b 20037f8 200382c: 90 10 3f ff mov -1, %o0 if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2003830: 40 00 39 23 call 2011cbc <__errno> 2003834: 01 00 00 00 nop 2003838: 82 10 20 86 mov 0x86, %g1 ! 86 200383c: c2 22 00 00 st %g1, [ %o0 ] 2003840: 10 bf ff ee b 20037f8 2003844: 90 10 3f ff mov -1, %o0 0200c258 : int ftruncate( int fd, off_t length ) { 200c258: 9d e3 bf 88 save %sp, -120, %sp rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 200c25c: 03 00 80 61 sethi %hi(0x2018400), %g1 200c260: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20184ec 200c264: 80 a6 00 02 cmp %i0, %g2 200c268: 1a 80 00 2b bcc 200c314 200c26c: 03 00 80 65 sethi %hi(0x2019400), %g1 iop = rtems_libio_iop( fd ); 200c270: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 ! 2019670 200c274: 85 2e 20 02 sll %i0, 2, %g2 200c278: 83 2e 20 04 sll %i0, 4, %g1 200c27c: 82 20 40 02 sub %g1, %g2, %g1 200c280: 82 00 40 18 add %g1, %i0, %g1 200c284: 83 28 60 02 sll %g1, 2, %g1 200c288: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 200c28c: c4 06 20 0c ld [ %i0 + 0xc ], %g2 200c290: 80 88 a1 00 btst 0x100, %g2 200c294: 02 80 00 20 be 200c314 200c298: 01 00 00 00 nop /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 200c29c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 200c2a0: c2 27 bf e8 st %g1, [ %fp + -24 ] 200c2a4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 200c2a8: c4 27 bf ec st %g2, [ %fp + -20 ] 200c2ac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 200c2b0: c2 27 bf f0 st %g1, [ %fp + -16 ] 200c2b4: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 if ( !loc.ops->node_type_h ) 200c2b8: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 200c2bc: 80 a0 60 00 cmp %g1, 0 200c2c0: 02 80 00 1b be 200c32c 200c2c4: c4 27 bf f4 st %g2, [ %fp + -12 ] rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 200c2c8: 9f c0 40 00 call %g1 200c2cc: 90 07 bf e8 add %fp, -24, %o0 200c2d0: 80 a2 20 01 cmp %o0, 1 200c2d4: 02 80 00 22 be 200c35c 200c2d8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 200c2dc: c2 06 20 0c ld [ %i0 + 0xc ], %g1 200c2e0: 80 88 60 04 btst 4, %g1 200c2e4: 02 80 00 18 be 200c344 200c2e8: 01 00 00 00 nop if ( !iop->handlers->ftruncate_h ) 200c2ec: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 200c2f0: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 200c2f4: 80 a0 60 00 cmp %g1, 0 200c2f8: 02 80 00 0d be 200c32c 200c2fc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->ftruncate_h)( iop, length ); 200c300: 90 10 00 18 mov %i0, %o0 200c304: 9f c0 40 00 call %g1 200c308: 92 10 00 19 mov %i1, %o1 } 200c30c: 81 c7 e0 08 ret 200c310: 91 e8 00 08 restore %g0, %o0, %o0 rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 200c314: 40 00 0b 6b call 200f0c0 <__errno> <== NOT EXECUTED 200c318: 01 00 00 00 nop <== NOT EXECUTED 200c31c: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 200c320: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200c324: 10 bf ff fa b 200c30c <== NOT EXECUTED 200c328: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->handlers->ftruncate_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 200c32c: 40 00 0b 65 call 200f0c0 <__errno> <== NOT EXECUTED 200c330: 01 00 00 00 nop <== NOT EXECUTED 200c334: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 200c338: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200c33c: 10 bf ff f4 b 200c30c <== NOT EXECUTED 200c340: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 200c344: 40 00 0b 5f call 200f0c0 <__errno> <== NOT EXECUTED 200c348: 01 00 00 00 nop <== NOT EXECUTED 200c34c: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200c350: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200c354: 10 bf ff ee b 200c30c <== NOT EXECUTED 200c358: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED loc = iop->pathinfo; if ( !loc.ops->node_type_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( EISDIR ); 200c35c: 40 00 0b 59 call 200f0c0 <__errno> <== NOT EXECUTED 200c360: 01 00 00 00 nop <== NOT EXECUTED 200c364: 82 10 20 15 mov 0x15, %g1 ! 15 <== NOT EXECUTED 200c368: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200c36c: 10 bf ff e8 b 200c30c <== NOT EXECUTED 200c370: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 020179b4 : char * getcwd (pt, size) char *pt; size_t size; { 20179b4: 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) 20179b8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 20179bc: 02 80 00 fa be 2017da4 <== NOT EXECUTED 20179c0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED if (!size) { errno = EINVAL; return (char *) NULL; } ept = pt + size; 20179c4: b6 10 20 00 clr %i3 <== NOT EXECUTED */ if (pt) { ptsize = 0; if (!size) 20179c8: 02 80 00 f1 be 2017d8c <== NOT EXECUTED 20179cc: b2 06 00 19 add %i0, %i1, %i1 <== NOT EXECUTED return (char *) NULL; } ept = pt + ptsize; } bpt = ept - 1; *bpt = '\0'; 20179d0: 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))) 20179d4: 90 10 23 fc mov 0x3fc, %o0 <== NOT EXECUTED 20179d8: 7f ff b3 0d call 200460c <== NOT EXECUTED 20179dc: b8 06 7f ff add %i1, -1, %i4 <== NOT EXECUTED 20179e0: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 20179e4: 02 80 00 0c be 2017a14 <== NOT EXECUTED 20179e8: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; up[1] = '\0'; 20179ec: c0 2c 60 01 clrb [ %l1 + 1 ] <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 20179f0: c2 2c 40 00 stb %g1, [ %l1 ] <== NOT EXECUTED up[1] = '\0'; /* Save root values, so know when to stop. */ if (stat ("/", &s)) 20179f4: ae 07 bf a8 add %fp, -88, %l7 <== NOT EXECUTED 20179f8: 11 00 80 dd sethi %hi(0x2037400), %o0 <== NOT EXECUTED 20179fc: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED 2017a00: 7f ff b7 c7 call 200591c <== NOT EXECUTED 2017a04: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED 2017a08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017a0c: 02 80 00 10 be 2017a4c <== NOT EXECUTED 2017a10: c4 1f bf a8 ldd [ %fp + -88 ], %g2 <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 2017a14: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 2017a18: 12 80 00 06 bne 2017a30 <== NOT EXECUTED 2017a1c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED free (pt); free (up); 2017a20: 7f ff b2 d2 call 2004568 <== NOT EXECUTED 2017a24: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017a28: 81 c7 e0 08 ret <== NOT EXECUTED 2017a2c: 81 e8 00 00 restore <== NOT EXECUTED err: if(dir) (void) _closedir (dir); if (ptsize) free (pt); 2017a30: 7f ff b2 ce call 2004568 <== NOT EXECUTED 2017a34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED free (up); 2017a38: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2017a3c: 7f ff b2 cb call 2004568 <== NOT EXECUTED 2017a40: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017a44: 81 c7 e0 08 ret <== NOT EXECUTED 2017a48: 81 e8 00 00 restore <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 2017a4c: 82 04 64 00 add %l1, 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; 2017a50: c4 3f bf 98 std %g2, [ %fp + -104 ] <== NOT EXECUTED root_ino = s.st_ino; 2017a54: c6 07 bf b0 ld [ %fp + -80 ], %g3 <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 2017a58: 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. */ 2017a5c: 40 00 37 6f call 2025818 <__errno> <== NOT EXECUTED 2017a60: c6 27 bf a0 st %g3, [ %fp + -96 ] <== NOT EXECUTED 2017a64: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 2017a68: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED 2017a6c: a8 10 00 11 mov %l1, %l4 <== NOT EXECUTED 2017a70: c4 27 bf 94 st %g2, [ %fp + -108 ] <== NOT EXECUTED 2017a74: b4 10 23 fc mov 0x3fc, %i2 <== NOT EXECUTED for (first = 1;; first = 0) { /* Stat the current level. */ if (_stat (up, &s)) 2017a78: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2017a7c: 7f ff b7 a8 call 200591c <== NOT EXECUTED 2017a80: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED 2017a84: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017a88: 12 bf ff e3 bne 2017a14 <== NOT EXECUTED 2017a8c: e4 1f bf a8 ldd [ %fp + -88 ], %l2 <== 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) 2017a90: c6 07 bf 98 ld [ %fp + -104 ], %g3 <== NOT EXECUTED 2017a94: 80 a0 c0 12 cmp %g3, %l2 <== NOT EXECUTED 2017a98: 02 80 00 a9 be 2017d3c <== NOT EXECUTED 2017a9c: fa 07 bf b0 ld [ %fp + -80 ], %i5 <== 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) 2017aa0: c6 07 bf a4 ld [ %fp + -92 ], %g3 <== NOT EXECUTED 2017aa4: 82 05 24 04 add %l4, 0x404, %g1 <== NOT EXECUTED 2017aa8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2017aac: 08 80 00 5a bleu 2017c14 <== NOT EXECUTED 2017ab0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED goto err; } bup = up; eup = up + upsize; } *bup++ = '.'; 2017ab4: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED *bup++ = '.'; *bup = '\0'; 2017ab8: c0 2d 20 02 clrb [ %l4 + 2 ] <== NOT EXECUTED } bup = up; eup = up + upsize; } *bup++ = '.'; *bup++ = '.'; 2017abc: c2 2d 20 01 stb %g1, [ %l4 + 1 ] <== NOT EXECUTED goto err; } bup = up; eup = up + upsize; } *bup++ = '.'; 2017ac0: c2 2d 00 00 stb %g1, [ %l4 ] <== NOT EXECUTED *bup++ = '.'; *bup = '\0'; /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 2017ac4: 40 00 03 a8 call 2018964 <== NOT EXECUTED 2017ac8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2017acc: aa 92 20 00 orcc %o0, 0, %l5 <== NOT EXECUTED 2017ad0: 02 bf ff d2 be 2017a18 <== NOT EXECUTED 2017ad4: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 2017ad8: d0 05 40 00 ld [ %l5 ], %o0 <== NOT EXECUTED 2017adc: 40 00 2d 96 call 2023134 <== NOT EXECUTED 2017ae0: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED 2017ae4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017ae8: 12 80 00 39 bne 2017bcc <== NOT EXECUTED 2017aec: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 2017af0: c2 2d 20 02 stb %g1, [ %l4 + 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) 2017af4: c2 07 bf a8 ld [ %fp + -88 ], %g1 <== NOT EXECUTED 2017af8: 80 a0 40 12 cmp %g1, %l2 <== NOT EXECUTED 2017afc: 02 80 00 4f be 2017c38 <== NOT EXECUTED 2017b00: a8 05 20 03 add %l4, 3, %l4 <== NOT EXECUTED 2017b04: ac 10 20 00 clr %l6 <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 2017b08: 40 00 04 59 call 2018c6c <== NOT EXECUTED 2017b0c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2017b10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017b14: 02 80 00 28 be 2017bb4 <== NOT EXECUTED 2017b18: 01 00 00 00 nop <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 2017b1c: c2 4a 20 0c ldsb [ %o0 + 0xc ], %g1 <== NOT EXECUTED 2017b20: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED 2017b24: 12 80 00 0d bne 2017b58 <== NOT EXECUTED 2017b28: a0 02 20 0c add %o0, 0xc, %l0 <== NOT EXECUTED 2017b2c: c2 4a 20 0d ldsb [ %o0 + 0xd ], %g1 <== NOT EXECUTED 2017b30: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017b34: 02 bf ff f5 be 2017b08 <== NOT EXECUTED 2017b38: 05 00 3f ff sethi %hi(0xfffc00), %g2 <== NOT EXECUTED 2017b3c: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 2017b40: 07 00 0b 80 sethi %hi(0x2e0000), %g3 <== NOT EXECUTED 2017b44: 84 10 a3 00 or %g2, 0x300, %g2 <== NOT EXECUTED 2017b48: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 2017b4c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2017b50: 02 bf ff ee be 2017b08 <== NOT EXECUTED 2017b54: 01 00 00 00 nop <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 2017b58: 40 00 4c 27 call 202abf4 <== NOT EXECUTED 2017b5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2017b60: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2017b64: 94 02 20 01 add %o0, 1, %o2 <== NOT EXECUTED 2017b68: 40 00 3e 0d call 202739c <== NOT EXECUTED 2017b6c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 2017b70: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2017b74: 7f ff b7 6a call 200591c <== NOT EXECUTED 2017b78: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED 2017b7c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017b80: 02 80 00 17 be 2017bdc <== NOT EXECUTED 2017b84: c2 07 bf a8 ld [ %fp + -88 ], %g1 <== NOT EXECUTED { if (!save_errno) 2017b88: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 2017b8c: 02 80 00 1e be 2017c04 <== NOT EXECUTED 2017b90: 01 00 00 00 nop <== NOT EXECUTED save_errno = errno; errno = 0; 2017b94: 40 00 37 21 call 2025818 <__errno> <== NOT EXECUTED 2017b98: 01 00 00 00 nop <== NOT EXECUTED 2017b9c: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 2017ba0: 40 00 04 33 call 2018c6c <== NOT EXECUTED 2017ba4: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2017ba8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017bac: 32 bf ff dd bne,a 2017b20 <== NOT EXECUTED 2017bb0: c2 4a 20 0c ldsb [ %o0 + 0xc ], %g1 <== 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) 2017bb4: 40 00 37 19 call 2025818 <__errno> <== NOT EXECUTED 2017bb8: 01 00 00 00 nop <== NOT EXECUTED 2017bbc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2017bc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017bc4: 02 80 00 57 be 2017d20 <== NOT EXECUTED 2017bc8: 01 00 00 00 nop <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 2017bcc: 7f ff fe 91 call 2017610 <== NOT EXECUTED 2017bd0: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED if (ptsize) 2017bd4: 10 bf ff 91 b 2017a18 <== NOT EXECUTED 2017bd8: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED if (!save_errno) save_errno = errno; errno = 0; continue; } if (s.st_dev == dev && s.st_ino == ino) 2017bdc: 80 a0 40 12 cmp %g1, %l2 <== NOT EXECUTED 2017be0: 12 bf ff ca bne 2017b08 <== NOT EXECUTED 2017be4: c2 07 bf ac ld [ %fp + -84 ], %g1 <== NOT EXECUTED 2017be8: 80 a0 40 13 cmp %g1, %l3 <== NOT EXECUTED 2017bec: 12 bf ff c7 bne 2017b08 <== NOT EXECUTED 2017bf0: c2 07 bf b0 ld [ %fp + -80 ], %g1 <== NOT EXECUTED 2017bf4: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 2017bf8: 12 bf ff c4 bne 2017b08 <== NOT EXECUTED 2017bfc: 01 00 00 00 nop <== NOT EXECUTED 2017c00: 30 80 00 1b b,a 2017c6c <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) { if (!save_errno) save_errno = errno; 2017c04: 40 00 37 05 call 2025818 <__errno> <== NOT EXECUTED 2017c08: 01 00 00 00 nop <== NOT EXECUTED 2017c0c: 10 bf ff e2 b 2017b94 <== NOT EXECUTED 2017c10: ec 02 00 00 ld [ %o0 ], %l6 <== NOT EXECUTED * possible component name, plus a trailing NULL. */ if (bup + 3 + MAXNAMLEN + 1 >= eup) { if (!(up = (char *) realloc (up, upsize *= 2))) 2017c14: b5 2e a0 01 sll %i2, 1, %i2 <== NOT EXECUTED 2017c18: 7f ff b2 ce call 2004750 <== NOT EXECUTED 2017c1c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2017c20: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 2017c24: 02 bf ff 7c be 2017a14 <== NOT EXECUTED 2017c28: 82 04 40 1a add %l1, %i2, %g1 <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 2017c2c: a8 10 00 11 mov %l1, %l4 <== NOT EXECUTED 2017c30: 10 bf ff a1 b 2017ab4 <== NOT EXECUTED 2017c34: c2 27 bf a4 st %g1, [ %fp + -92 ] <== 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) 2017c38: c2 07 bf ac ld [ %fp + -84 ], %g1 <== NOT EXECUTED 2017c3c: 80 a0 40 13 cmp %g1, %l3 <== NOT EXECUTED 2017c40: 12 bf ff b2 bne 2017b08 <== NOT EXECUTED 2017c44: ac 10 20 00 clr %l6 <== NOT EXECUTED { for (;;) { if (!(dp = _readdir (dir))) 2017c48: 40 00 04 09 call 2018c6c <== NOT EXECUTED 2017c4c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED 2017c50: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017c54: 02 bf ff d8 be 2017bb4 <== NOT EXECUTED 2017c58: ac 10 20 00 clr %l6 <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 2017c5c: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2017c60: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 2017c64: 12 bf ff f9 bne 2017c48 <== NOT EXECUTED 2017c68: a0 02 20 0c add %o0, 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)) 2017c6c: 40 00 4b e2 call 202abf4 <== NOT EXECUTED 2017c70: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2017c74: c2 07 bf 94 ld [ %fp + -108 ], %g1 <== NOT EXECUTED 2017c78: a4 27 00 18 sub %i4, %i0, %l2 <== NOT EXECUTED 2017c7c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2017c80: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED 2017c84: 82 00 60 01 inc %g1 <== NOT EXECUTED 2017c88: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 2017c8c: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED 2017c90: 18 80 00 13 bgu 2017cdc <== NOT EXECUTED 2017c94: c4 07 bf 94 ld [ %fp + -108 ], %g2 <== NOT EXECUTED { size_t len, off; if (!ptsize) 2017c98: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 2017c9c: 02 80 00 4a be 2017dc4 <== NOT EXECUTED 2017ca0: 01 00 00 00 nop <== NOT EXECUTED errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 2017ca4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2017ca8: b7 2e e0 01 sll %i3, 1, %i3 <== NOT EXECUTED 2017cac: 7f ff b2 a9 call 2004750 <== NOT EXECUTED 2017cb0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 2017cb4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2017cb8: 02 bf ff c5 be 2017bcc <== NOT EXECUTED 2017cbc: 82 26 40 1c sub %i1, %i4, %g1 <== NOT EXECUTED { goto err; } bpt = pt + off; ept = pt + ptsize; (void) bcopy (bpt, ept - len, len); 2017cc0: 92 06 00 12 add %i0, %l2, %o1 <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 2017cc4: b2 06 00 1b add %i0, %i3, %i1 <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 2017cc8: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 2017ccc: b8 26 40 01 sub %i1, %g1, %i4 <== NOT EXECUTED 2017cd0: 40 00 3d b3 call 202739c <== NOT EXECUTED 2017cd4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED bpt = ept - len; } if (!first) 2017cd8: c4 07 bf 94 ld [ %fp + -108 ], %g2 <== NOT EXECUTED 2017cdc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2017ce0: 12 80 00 04 bne 2017cf0 <== NOT EXECUTED 2017ce4: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED *--bpt = '/'; 2017ce8: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED 2017cec: c2 2f 00 00 stb %g1, [ %i4 ] <== NOT EXECUTED bpt -= strlen (dp->d_name); 2017cf0: 40 00 4b c1 call 202abf4 <== NOT EXECUTED 2017cf4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 2017cf8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2017cfc: 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); 2017d00: b8 27 00 08 sub %i4, %o0, %i4 <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); (void) _closedir (dir); dir = 0; /* Truncate any file name. */ *bup = '\0'; 2017d04: 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)); 2017d08: 40 00 3d a5 call 202739c <== NOT EXECUTED 2017d0c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED (void) _closedir (dir); 2017d10: 7f ff fe 40 call 2017610 <== NOT EXECUTED 2017d14: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 2017d18: 10 bf ff 58 b 2017a78 <== NOT EXECUTED 2017d1c: c0 2d 00 00 clrb [ %l4 ] <== NOT EXECUTED * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) errno = save_errno ? save_errno : ENOENT; 2017d20: 40 00 36 be call 2025818 <__errno> <== NOT EXECUTED 2017d24: 01 00 00 00 nop <== NOT EXECUTED 2017d28: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 2017d2c: 22 80 00 16 be,a 2017d84 <== NOT EXECUTED 2017d30: ac 10 20 02 mov 2, %l6 <== NOT EXECUTED 2017d34: 10 bf ff a6 b 2017bcc <== NOT EXECUTED 2017d38: ec 22 00 00 st %l6, [ %o0 ] <== 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) 2017d3c: c2 07 bf 9c ld [ %fp + -100 ], %g1 <== NOT EXECUTED 2017d40: 80 a0 40 13 cmp %g1, %l3 <== NOT EXECUTED 2017d44: 12 bf ff 58 bne 2017aa4 <== NOT EXECUTED 2017d48: c6 07 bf a4 ld [ %fp + -92 ], %g3 <== NOT EXECUTED 2017d4c: c4 07 bf a0 ld [ %fp + -96 ], %g2 <== NOT EXECUTED 2017d50: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED 2017d54: 12 bf ff 55 bne 2017aa8 <== NOT EXECUTED 2017d58: 82 05 24 04 add %l4, 0x404, %g1 <== NOT EXECUTED { *--bpt = '/'; 2017d5c: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED 2017d60: 92 07 3f ff add %i4, -1, %o1 <== NOT EXECUTED 2017d64: c2 2f 3f ff stb %g1, [ %i4 + -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); 2017d68: 94 26 40 09 sub %i1, %o1, %o2 <== NOT EXECUTED 2017d6c: 40 00 3d 8c call 202739c <== NOT EXECUTED 2017d70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED free (up); 2017d74: 7f ff b1 fd call 2004568 <== NOT EXECUTED 2017d78: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2017d7c: 81 c7 e0 08 ret <== NOT EXECUTED 2017d80: 81 e8 00 00 restore <== NOT EXECUTED * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) errno = save_errno ? save_errno : ENOENT; 2017d84: 10 bf ff 92 b 2017bcc <== NOT EXECUTED 2017d88: ec 22 00 00 st %l6, [ %o0 ] <== NOT EXECUTED if (pt) { ptsize = 0; if (!size) { errno = EINVAL; 2017d8c: 40 00 36 a3 call 2025818 <__errno> <== NOT EXECUTED 2017d90: b0 10 20 00 clr %i0 <== NOT EXECUTED 2017d94: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2017d98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017d9c: 81 c7 e0 08 ret <== NOT EXECUTED 2017da0: 81 e8 00 00 restore <== NOT EXECUTED } ept = pt + size; } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 2017da4: 7f ff b2 1a call 200460c <== NOT EXECUTED 2017da8: 90 10 23 fc mov 0x3fc, %o0 <== NOT EXECUTED 2017dac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2017db0: 02 bf ff 1e be 2017a28 <== NOT EXECUTED 2017db4: b6 10 23 fc mov 0x3fc, %i3 <== NOT EXECUTED 2017db8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 2017dbc: 10 bf ff 05 b 20179d0 <== NOT EXECUTED 2017dc0: b2 02 23 fc add %o0, 0x3fc, %i1 <== NOT EXECUTED { size_t len, off; if (!ptsize) { errno = ERANGE; 2017dc4: 40 00 36 95 call 2025818 <__errno> <== NOT EXECUTED 2017dc8: 01 00 00 00 nop <== NOT EXECUTED 2017dcc: 82 10 20 22 mov 0x22, %g1 ! 22 <== NOT EXECUTED 2017dd0: 10 bf ff 7f b 2017bcc <== NOT EXECUTED 2017dd4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 02023268 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 2023268: 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 ); 202326c: 03 00 80 ea sethi %hi(0x203a800), %g1 2023270: c4 00 61 ec ld [ %g1 + 0x1ec ], %g2 ! 203a9ec int getdents( int dd_fd, char *dd_buf, int dd_len ) { 2023274: 88 10 00 18 mov %i0, %g4 /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 2023278: 80 a6 00 02 cmp %i0, %g2 202327c: 1a 80 00 0a bcc 20232a4 2023280: b0 10 20 00 clr %i0 2023284: 03 00 80 f5 sethi %hi(0x203d400), %g1 2023288: c6 00 60 20 ld [ %g1 + 0x20 ], %g3 ! 203d420 202328c: 85 29 20 02 sll %g4, 2, %g2 2023290: 83 29 20 04 sll %g4, 4, %g1 2023294: 82 20 40 02 sub %g1, %g2, %g1 2023298: 82 00 40 04 add %g1, %g4, %g1 202329c: 83 28 60 02 sll %g1, 2, %g1 20232a0: b0 00 40 03 add %g1, %g3, %i0 /* * Make sure we are working on a directory */ loc = iop->pathinfo; 20232a4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 20232a8: c2 27 bf e8 st %g1, [ %fp + -24 ] 20232ac: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 20232b0: c4 27 bf ec st %g2, [ %fp + -20 ] 20232b4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 20232b8: c2 27 bf f0 st %g1, [ %fp + -16 ] 20232bc: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 if ( !loc.ops->node_type_h ) 20232c0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 20232c4: 80 a0 60 00 cmp %g1, 0 20232c8: 02 80 00 17 be 2023324 20232cc: c4 27 bf f4 st %g2, [ %fp + -12 ] rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 20232d0: 9f c0 40 00 call %g1 20232d4: 90 07 bf e8 add %fp, -24, %o0 20232d8: 80 a2 20 01 cmp %o0, 1 20232dc: 12 80 00 0c bne 202330c 20232e0: 01 00 00 00 nop /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 20232e4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 20232e8: c2 00 60 08 ld [ %g1 + 8 ], %g1 20232ec: 80 a0 60 00 cmp %g1, 0 20232f0: 02 80 00 0d be 2023324 20232f4: 92 10 00 19 mov %i1, %o1 rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 20232f8: 90 10 00 18 mov %i0, %o0 20232fc: 9f c0 40 00 call %g1 2023300: 94 10 00 1a mov %i2, %o2 } 2023304: 81 c7 e0 08 ret 2023308: 91 e8 00 08 restore %g0, %o0, %o0 loc = iop->pathinfo; if ( !loc.ops->node_type_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 202330c: 40 00 09 43 call 2025818 <__errno> 2023310: 01 00 00 00 nop 2023314: 82 10 20 14 mov 0x14, %g1 ! 14 2023318: c2 22 00 00 st %g1, [ %o0 ] 202331c: 10 bf ff fa b 2023304 2023320: 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 ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2023324: 40 00 09 3d call 2025818 <__errno> <== NOT EXECUTED 2023328: 01 00 00 00 nop <== NOT EXECUTED 202332c: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2023330: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2023334: 10 bf ff f4 b 2023304 <== NOT EXECUTED 2023338: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 02017df8 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 2017df8: 03 00 80 ec sethi %hi(0x203b000), %g1 <== NOT EXECUTED 2017dfc: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 203b200 <== NOT EXECUTED return _POSIX_types_Gid; } 2017e00: 81 c3 e0 08 retl <== NOT EXECUTED 2017e04: d0 10 a0 2a lduh [ %g2 + 0x2a ], %o0 <== NOT EXECUTED 020184d0 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 20184d0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 20184d4: 7f ff ff b3 call 20183a0 <== NOT EXECUTED 20184d8: 01 00 00 00 nop <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 20184dc: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 20184e0: 13 00 80 e8 sethi %hi(0x203a000), %o1 <== NOT EXECUTED 20184e4: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED 20184e8: 40 00 37 20 call 2026168 <== NOT EXECUTED 20184ec: 92 12 63 80 or %o1, 0x380, %o1 <== NOT EXECUTED 20184f0: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED 20184f4: 12 80 00 0b bne 2018520 <== NOT EXECUTED 20184f8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 20184fc: 30 80 00 27 b,a 2018598 <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(grp->gr_name, name) == 0); 2018500: 40 00 43 9c call 2029370 <== NOT EXECUTED 2018504: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2018508: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 201850c: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } else { match = (grp->gr_gid == gid); } if (match) { 2018510: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018514: 12 80 00 14 bne 2018564 <== NOT EXECUTED 2018518: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 201851c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2018520: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018524: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 2018528: 7f ff fe d2 call 2018070 <== NOT EXECUTED 201852c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018530: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018534: 02 80 00 11 be 2018578 <== NOT EXECUTED 2018538: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 201853c: 32 bf ff f1 bne,a 2018500 <== NOT EXECUTED 2018540: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); } else { match = (grp->gr_gid == gid); 2018544: c2 16 a0 08 lduh [ %i2 + 8 ], %g1 <== NOT EXECUTED 2018548: 82 18 40 19 xor %g1, %i1, %g1 <== NOT EXECUTED 201854c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2018550: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } if (match) { 2018554: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018558: 02 bf ff f2 be 2018520 <== NOT EXECUTED 201855c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED fclose(fp); 2018560: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018564: 40 00 35 03 call 2025970 <== NOT EXECUTED 2018568: b0 10 20 00 clr %i0 <== NOT EXECUTED *result = grp; 201856c: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 2018570: 81 c7 e0 08 ret <== NOT EXECUTED 2018574: 81 e8 00 00 restore <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { errno = EINVAL; 2018578: 40 00 34 a8 call 2025818 <__errno> <== NOT EXECUTED 201857c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2018580: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2018584: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED fclose(fp); 2018588: 40 00 34 fa call 2025970 <== NOT EXECUTED 201858c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018590: 81 c7 e0 08 ret <== NOT EXECUTED 2018594: 81 e8 00 00 restore <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; 2018598: 40 00 34 a0 call 2025818 <__errno> <== NOT EXECUTED 201859c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20185a0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20185a4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20185a8: 81 c7 e0 08 ret <== NOT EXECUTED 20185ac: 81 e8 00 00 restore <== NOT EXECUTED 020181ec : return NULL; return p; } struct group *getgrent() { 20181ec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (group_fp == NULL) 20181f0: 03 00 80 f2 sethi %hi(0x203c800), %g1 <== NOT EXECUTED 20181f4: d0 00 62 ac ld [ %g1 + 0x2ac ], %o0 ! 203caac <== NOT EXECUTED 20181f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20181fc: 02 80 00 0d be 2018230 <== NOT EXECUTED 2018200: 21 00 80 f2 sethi %hi(0x203c800), %l0 <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 2018204: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 2018208: 92 14 23 78 or %l0, 0x378, %o1 <== NOT EXECUTED 201820c: 94 12 a2 b0 or %o2, 0x2b0, %o2 <== NOT EXECUTED 2018210: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2018214: 7f ff ff 97 call 2018070 <== NOT EXECUTED 2018218: b0 14 23 78 or %l0, 0x378, %i0 <== NOT EXECUTED 201821c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018220: 02 80 00 04 be 2018230 <== NOT EXECUTED 2018224: 01 00 00 00 nop <== NOT EXECUTED return NULL; return &grent; } 2018228: 81 c7 e0 08 ret <== NOT EXECUTED 201822c: 81 e8 00 00 restore <== NOT EXECUTED 2018230: 81 c7 e0 08 ret <== NOT EXECUTED 2018234: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020185e8 : } struct group *getgrgid( gid_t gid ) { 20185e8: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 20185ec: 13 00 80 f2 sethi %hi(0x203c800), %o1 <== NOT EXECUTED 20185f0: 91 2e 20 10 sll %i0, 0x10, %o0 <== NOT EXECUTED 20185f4: 92 12 63 78 or %o1, 0x378, %o1 <== NOT EXECUTED 20185f8: 91 32 20 10 srl %o0, 0x10, %o0 <== NOT EXECUTED 20185fc: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 2018600: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2018604: 94 12 a2 b0 or %o2, 0x2b0, %o2 <== NOT EXECUTED 2018608: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 201860c: 7f ff ff e9 call 20185b0 <== NOT EXECUTED 2018610: b0 10 20 00 clr %i0 <== NOT EXECUTED 2018614: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018618: 22 80 00 02 be,a 2018620 <== NOT EXECUTED 201861c: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 2018620: 81 c7 e0 08 ret <== NOT EXECUTED 2018624: 81 e8 00 00 restore <== NOT EXECUTED 020185b0 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 20185b0: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED 20185b4: 84 10 00 0a mov %o2, %g2 <== NOT EXECUTED 20185b8: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 20185bc: 93 2a 20 10 sll %o0, 0x10, %o1 <== NOT EXECUTED struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 20185c0: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 20185c4: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 20185c8: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED 20185cc: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED 20185d0: 98 10 00 03 mov %g3, %o4 <== NOT EXECUTED 20185d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20185d8: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20185dc: 7f ff ff bd call 20184d0 <== NOT EXECUTED 20185e0: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20185e4: 01 00 00 00 nop 02018654 : } struct group *getgrnam( const char *name ) { 2018654: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 2018658: 13 00 80 f2 sethi %hi(0x203c800), %o1 <== NOT EXECUTED 201865c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018660: 92 12 63 78 or %o1, 0x378, %o1 <== NOT EXECUTED 2018664: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 2018668: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 201866c: 94 12 a2 b0 or %o2, 0x2b0, %o2 <== NOT EXECUTED 2018670: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 2018674: 7f ff ff ed call 2018628 <== NOT EXECUTED 2018678: b0 10 20 00 clr %i0 <== NOT EXECUTED 201867c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018680: 22 80 00 02 be,a 2018688 <== NOT EXECUTED 2018684: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 2018688: 81 c7 e0 08 ret <== NOT EXECUTED 201868c: 81 e8 00 00 restore <== NOT EXECUTED 02018628 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 2018628: 82 10 00 0a mov %o2, %g1 <== NOT EXECUTED 201862c: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 2018630: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 2018634: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 2018638: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 201863c: 98 10 00 02 mov %g2, %o4 <== NOT EXECUTED 2018640: 92 10 20 00 clr %o1 <== NOT EXECUTED 2018644: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2018648: 7f ff ff a2 call 20184d0 <== NOT EXECUTED 201864c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2018650: 01 00 00 00 nop 020186d4 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 20186d4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 20186d8: 7f ff ff 32 call 20183a0 <== NOT EXECUTED 20186dc: 01 00 00 00 nop <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 20186e0: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 20186e4: 13 00 80 e8 sethi %hi(0x203a000), %o1 <== NOT EXECUTED 20186e8: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED 20186ec: 40 00 36 9f call 2026168 <== NOT EXECUTED 20186f0: 92 12 63 80 or %o1, 0x380, %o1 <== NOT EXECUTED 20186f4: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED 20186f8: 12 80 00 0b bne 2018724 <== NOT EXECUTED 20186fc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2018700: 30 80 00 27 b,a 201879c <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(pwd->pw_name, name) == 0); 2018704: 40 00 43 1b call 2029370 <== NOT EXECUTED 2018708: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 201870c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 2018710: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); } if (match) { 2018714: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018718: 12 80 00 14 bne 2018768 <== NOT EXECUTED 201871c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 2018720: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 2018724: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018728: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 201872c: 7f ff fe c3 call 2018238 <== NOT EXECUTED 2018730: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018738: 02 80 00 11 be 201877c <== NOT EXECUTED 201873c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 2018740: 32 bf ff f1 bne,a 2018704 <== NOT EXECUTED 2018744: d0 06 80 00 ld [ %i2 ], %o0 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); } else { match = (pwd->pw_uid == uid); 2018748: c2 16 a0 08 lduh [ %i2 + 8 ], %g1 <== NOT EXECUTED 201874c: 82 18 40 19 xor %g1, %i1, %g1 <== NOT EXECUTED 2018750: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 2018754: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED } if (match) { 2018758: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201875c: 02 bf ff f2 be 2018724 <== NOT EXECUTED 2018760: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED fclose(fp); 2018764: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018768: 40 00 34 82 call 2025970 <== NOT EXECUTED 201876c: b0 10 20 00 clr %i0 <== NOT EXECUTED *result = pwd; 2018770: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 2018774: 81 c7 e0 08 ret <== NOT EXECUTED 2018778: 81 e8 00 00 restore <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { errno = EINVAL; 201877c: 40 00 34 27 call 2025818 <__errno> <== NOT EXECUTED 2018780: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2018784: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2018788: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED fclose(fp); 201878c: 40 00 34 79 call 2025970 <== NOT EXECUTED 2018790: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018794: 81 c7 e0 08 ret <== NOT EXECUTED 2018798: 81 e8 00 00 restore <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; 201879c: 40 00 34 1f call 2025818 <__errno> <== NOT EXECUTED 20187a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20187a4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20187a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20187ac: 81 c7 e0 08 ret <== NOT EXECUTED 20187b0: 81 e8 00 00 restore <== NOT EXECUTED 02018354 : return NULL; return p; } struct passwd *getpwent() { 2018354: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (passwd_fp == NULL) 2018358: 03 00 80 f2 sethi %hi(0x203c800), %g1 <== NOT EXECUTED 201835c: d0 00 61 c4 ld [ %g1 + 0x1c4 ], %o0 ! 203c9c4 <== NOT EXECUTED 2018360: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018364: 02 80 00 0d be 2018398 <== NOT EXECUTED 2018368: 21 00 80 f2 sethi %hi(0x203c800), %l0 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 201836c: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 2018370: 92 14 22 90 or %l0, 0x290, %o1 <== NOT EXECUTED 2018374: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 2018378: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 201837c: 7f ff ff af call 2018238 <== NOT EXECUTED 2018380: b0 14 22 90 or %l0, 0x290, %i0 <== NOT EXECUTED 2018384: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018388: 02 80 00 04 be 2018398 <== NOT EXECUTED 201838c: 01 00 00 00 nop <== NOT EXECUTED return NULL; return &pwent; } 2018390: 81 c7 e0 08 ret <== NOT EXECUTED 2018394: 81 e8 00 00 restore <== NOT EXECUTED 2018398: 81 c7 e0 08 ret <== NOT EXECUTED 201839c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02018858 : } struct passwd *getpwnam( const char *name ) { 2018858: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 201885c: 13 00 80 f2 sethi %hi(0x203c800), %o1 <== NOT EXECUTED 2018860: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018864: 92 12 62 90 or %o1, 0x290, %o1 <== NOT EXECUTED 2018868: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 201886c: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2018870: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 2018874: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 2018878: 7f ff ff ed call 201882c <== NOT EXECUTED 201887c: b0 10 20 00 clr %i0 <== NOT EXECUTED 2018880: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018884: 22 80 00 02 be,a 201888c <== NOT EXECUTED 2018888: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 201888c: 81 c7 e0 08 ret <== NOT EXECUTED 2018890: 81 e8 00 00 restore <== NOT EXECUTED 0201882c : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 201882c: 82 10 00 0a mov %o2, %g1 <== NOT EXECUTED 2018830: 84 10 00 0b mov %o3, %g2 <== NOT EXECUTED 2018834: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 2018838: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED 201883c: 96 10 00 01 mov %g1, %o3 <== NOT EXECUTED 2018840: 98 10 00 02 mov %g2, %o4 <== NOT EXECUTED 2018844: 92 10 20 00 clr %o1 <== NOT EXECUTED 2018848: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 201884c: 7f ff ff a2 call 20186d4 <== NOT EXECUTED 2018850: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2018854: 01 00 00 00 nop 020187ec : } struct passwd *getpwuid( uid_t uid ) { 20187ec: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 20187f0: 13 00 80 f2 sethi %hi(0x203c800), %o1 <== NOT EXECUTED 20187f4: 91 2e 20 10 sll %i0, 0x10, %o0 <== NOT EXECUTED 20187f8: 92 12 62 90 or %o1, 0x290, %o1 <== NOT EXECUTED 20187fc: 91 32 20 10 srl %o0, 0x10, %o0 <== NOT EXECUTED 2018800: 15 00 80 f2 sethi %hi(0x203c800), %o2 <== NOT EXECUTED 2018804: 96 10 20 c8 mov 0xc8, %o3 <== NOT EXECUTED 2018808: 94 12 a1 c8 or %o2, 0x1c8, %o2 <== NOT EXECUTED 201880c: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED 2018810: 7f ff ff e9 call 20187b4 <== NOT EXECUTED 2018814: b0 10 20 00 clr %i0 <== NOT EXECUTED 2018818: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201881c: 22 80 00 02 be,a 2018824 <== NOT EXECUTED 2018820: f0 07 bf f4 ld [ %fp + -12 ], %i0 <== NOT EXECUTED return NULL; return p; } 2018824: 81 c7 e0 08 ret <== NOT EXECUTED 2018828: 81 e8 00 00 restore <== NOT EXECUTED 020187b4 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 20187b4: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED 20187b8: 84 10 00 0a mov %o2, %g2 <== NOT EXECUTED 20187bc: 86 10 00 0b mov %o3, %g3 <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 20187c0: 93 2a 20 10 sll %o0, 0x10, %o1 <== NOT EXECUTED struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 20187c4: 9a 10 00 0c mov %o4, %o5 <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 20187c8: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED 20187cc: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED 20187d0: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED 20187d4: 98 10 00 03 mov %g3, %o4 <== NOT EXECUTED 20187d8: 90 10 20 00 clr %o0 <== NOT EXECUTED 20187dc: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 20187e0: 7f ff ff bd call 20186d4 <== NOT EXECUTED 20187e4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 20187e8: 01 00 00 00 nop 0200c394 : int gettimeofday( struct timeval *tp, void * __tz ) { 200c394: 9d e3 bf 90 save %sp, -112, %sp /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 200c398: 80 a6 20 00 cmp %i0, 0 200c39c: 02 80 00 11 be 200c3e0 200c3a0: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 200c3a4: 7f ff d6 96 call 2001dfc 200c3a8: 01 00 00 00 nop 200c3ac: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 200c3b0: 7f ff eb 8d call 20071e4 <_TOD_Get> 200c3b4: 90 07 bf f0 add %fp, -16, %o0 _ISR_Enable(level); 200c3b8: 7f ff d6 95 call 2001e0c 200c3bc: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200c3c0: d0 07 bf f4 ld [ %fp + -12 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 200c3c4: c2 07 bf f0 ld [ %fp + -16 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 200c3c8: 92 10 23 e8 mov 0x3e8, %o1 200c3cc: 40 00 26 da call 2015f34 <.udiv> 200c3d0: c2 26 00 00 st %g1, [ %i0 ] 200c3d4: 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; } 200c3d8: 81 c7 e0 08 ret 200c3dc: 91 e8 20 00 restore %g0, 0, %o0 void * __tz ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { errno = EFAULT; 200c3e0: 40 00 0b 38 call 200f0c0 <__errno> <== NOT EXECUTED 200c3e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200c3e8: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED 200c3ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200c3f0: 81 c7 e0 08 ret <== NOT EXECUTED 200c3f4: 81 e8 00 00 restore <== NOT EXECUTED 02018894 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { 2018894: 03 00 80 ec sethi %hi(0x203b000), %g1 <== NOT EXECUTED 2018898: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 203b200 <== NOT EXECUTED return _POSIX_types_Uid; } 201889c: 81 c3 e0 08 retl <== NOT EXECUTED 20188a0: d0 10 a0 28 lduh [ %g2 + 0x28 ], %o0 <== NOT EXECUTED 02022a24 : IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) 2022a24: c4 02 20 2c ld [ %o0 + 0x2c ], %g2 rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 2022a28: 86 10 00 08 mov %o0, %g3 IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) 2022a2c: c2 00 a0 48 ld [ %g2 + 0x48 ], %g1 2022a30: 80 a0 60 01 cmp %g1, 1 2022a34: 02 80 00 04 be 2022a44 2022a38: 90 10 3f ff mov -1, %o0 return -1; /* It wasn't a directory --> return error */ iop->offset = 0; return 0; } 2022a3c: 81 c3 e0 08 retl <== NOT EXECUTED 2022a40: 01 00 00 00 nop <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 2022a44: c0 20 e0 08 clr [ %g3 + 8 ] return 0; } 2022a48: 81 c3 e0 08 retl 2022a4c: 90 10 20 00 clr %o0 02022b40 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 2022b40: 9d e3 be 88 save %sp, -376, %sp int current_entry; int first_entry; int last_entry; struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->file_info; 2022b44: c2 06 20 2c ld [ %i0 + 0x2c ], %g1 ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 2022b48: 90 10 00 1a mov %i2, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2022b4c: e2 00 60 4c ld [ %g1 + 0x4c ], %l1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2022b50: a4 00 60 50 add %g1, 0x50, %l2 struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->file_info; the_chain = &the_jnode->info.directory.Entries; if ( Chain_Is_empty( the_chain ) ) 2022b54: 80 a4 40 12 cmp %l1, %l2 2022b58: 02 80 00 34 be 2022c28 2022b5c: aa 10 20 00 clr %l5 /* Move to the first of the desired directory entries */ the_node = the_chain->first; bytes_transferred = 0; first_entry = iop->offset; 2022b60: e8 06 20 08 ld [ %i0 + 8 ], %l4 /* protect against using sizes that are not exact multiples of the */ /* -dirent- size. These could result in unexpected results */ last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); 2022b64: 40 00 47 a9 call 2034a08 <.udiv> 2022b68: 92 10 21 0c mov 0x10c, %o1 2022b6c: 83 2a 20 02 sll %o0, 2, %g1 2022b70: 85 2a 20 06 sll %o0, 6, %g2 2022b74: 82 00 40 02 add %g1, %g2, %g1 2022b78: 82 20 40 08 sub %g1, %o0, %g1 2022b7c: 83 28 60 02 sll %g1, 2, %g1 2022b80: a6 00 40 14 add %g1, %l4, %l3 /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 2022b84: 80 a4 e0 00 cmp %l3, 0 2022b88: 04 80 00 2a ble 2022c30 2022b8c: 80 a4 80 11 cmp %l2, %l1 current_entry = current_entry + sizeof(struct dirent) ){ if ( Chain_Is_tail( the_chain, the_node ) ){ 2022b90: 02 80 00 28 be 2022c30 2022b94: b4 10 20 00 clr %i2 tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; tmp_dirent.d_namlen = strlen( the_jnode->name ); strcpy( tmp_dirent.d_name, the_jnode->name ); 2022b98: ae 07 be ec add %fp, -276, %l7 2022b9c: 10 80 00 08 b 2022bbc 2022ba0: ac 07 be f8 add %fp, -264, %l6 last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 2022ba4: 80 a4 c0 1a cmp %l3, %i2 2022ba8: 04 80 00 20 ble 2022c28 2022bac: e2 04 40 00 ld [ %l1 ], %l1 current_entry = current_entry + sizeof(struct dirent) ){ if ( Chain_Is_tail( the_chain, the_node ) ){ 2022bb0: 80 a4 80 11 cmp %l2, %l1 2022bb4: 02 80 00 1d be 2022c28 2022bb8: 01 00 00 00 nop /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 2022bbc: 80 a5 00 1a cmp %l4, %i2 2022bc0: 34 bf ff f9 bg,a 2022ba4 2022bc4: b4 06 a1 0c add %i2, 0x10c, %i2 /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 2022bc8: f4 27 be f0 st %i2, [ %fp + -272 ] tmp_dirent.d_reclen = sizeof( struct dirent ); the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 2022bcc: c4 04 60 34 ld [ %l1 + 0x34 ], %g2 } if( current_entry >= first_entry ) { /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); 2022bd0: 82 10 21 0c mov 0x10c, %g1 the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; tmp_dirent.d_namlen = strlen( the_jnode->name ); 2022bd4: a0 04 60 0c add %l1, 0xc, %l0 } if( current_entry >= first_entry ) { /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); 2022bd8: c2 37 be f4 sth %g1, [ %fp + -268 ] the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 2022bdc: c4 27 be ec st %g2, [ %fp + -276 ] tmp_dirent.d_namlen = strlen( the_jnode->name ); 2022be0: 40 00 20 05 call 202abf4 2022be4: 90 10 00 10 mov %l0, %o0 strcpy( tmp_dirent.d_name, the_jnode->name ); 2022be8: 92 10 00 10 mov %l0, %o1 /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; tmp_dirent.d_reclen = sizeof( struct dirent ); the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; tmp_dirent.d_namlen = strlen( the_jnode->name ); 2022bec: d0 37 be f6 sth %o0, [ %fp + -266 ] strcpy( tmp_dirent.d_name, the_jnode->name ); 2022bf0: 40 00 1a 10 call 2029430 2022bf4: 90 10 00 16 mov %l6, %o0 memcpy( 2022bf8: 90 06 40 15 add %i1, %l5, %o0 2022bfc: 92 10 00 17 mov %l7, %o1 2022c00: 40 00 11 ba call 20272e8 2022c04: 94 10 21 0c mov 0x10c, %o2 buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 2022c08: c2 06 20 08 ld [ %i0 + 8 ], %g1 bytes_transferred = bytes_transferred + sizeof( struct dirent ); } the_node = the_node->next; 2022c0c: b4 06 a1 0c add %i2, 0x10c, %i2 memcpy( buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 2022c10: 82 00 61 0c add %g1, 0x10c, %g1 2022c14: c2 26 20 08 st %g1, [ %i0 + 8 ] bytes_transferred = bytes_transferred + sizeof( struct dirent ); 2022c18: aa 05 61 0c add %l5, 0x10c, %l5 last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 2022c1c: 80 a4 c0 1a cmp %l3, %i2 2022c20: 14 bf ff e4 bg 2022bb0 2022c24: e2 04 40 00 ld [ %l1 ], %l1 the_node = the_node->next; } /* Success */ return bytes_transferred; } 2022c28: 81 c7 e0 08 ret 2022c2c: 91 e8 00 15 restore %g0, %l5, %o0 last_entry = first_entry + (count/sizeof(struct dirent)) * sizeof(struct dirent); /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 2022c30: 10 bf ff fe b 2022c28 <== NOT EXECUTED 2022c34: aa 10 20 00 clr %l5 <== NOT EXECUTED 02022c38 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 2022c38: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 2022c3c: 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 ) ) 2022c40: c4 04 20 4c ld [ %l0 + 0x4c ], %g2 2022c44: 82 04 20 50 add %l0, 0x50, %g1 2022c48: 80 a0 80 01 cmp %g2, %g1 2022c4c: 12 80 00 36 bne 2022d24 2022c50: 01 00 00 00 nop /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 2022c54: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2022c58: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 2022c5c: 80 a4 00 02 cmp %l0, %g2 2022c60: 02 80 00 2b be 2022d0c 2022c64: 01 00 00 00 nop /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 2022c68: c2 04 20 58 ld [ %l0 + 0x58 ], %g1 2022c6c: 80 a0 60 00 cmp %g1, 0 2022c70: 12 80 00 27 bne 2022d0c 2022c74: 01 00 00 00 nop /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 2022c78: c2 04 20 08 ld [ %l0 + 8 ], %g1 2022c7c: 80 a0 60 00 cmp %g1, 0 2022c80: 22 80 00 06 be,a 2022c98 2022c84: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 Chain_Extract( (Chain_Node *) the_jnode ); 2022c88: 7f ff de 07 call 201a4a4 <_Chain_Extract> 2022c8c: 90 10 00 10 mov %l0, %o0 the_jnode->Parent = NULL; 2022c90: c0 24 20 08 clr [ %l0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 2022c94: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 2022c98: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 2022c9c: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 2022ca0: 90 07 bf f0 add %fp, -16, %o0 2022ca4: 7f ff 85 11 call 20040e8 2022ca8: c2 34 20 30 sth %g1, [ %l0 + 0x30 ] 2022cac: 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) ) { 2022cb0: 90 10 00 10 mov %l0, %o0 2022cb4: 7f ff 85 7d call 20042a8 2022cb8: c2 24 20 44 st %g1, [ %l0 + 0x44 ] 2022cbc: 80 a2 20 00 cmp %o0, 0 2022cc0: 12 80 00 11 bne 2022d04 2022cc4: 01 00 00 00 nop 2022cc8: c2 14 20 30 lduh [ %l0 + 0x30 ], %g1 2022ccc: 80 a0 60 00 cmp %g1, 0 2022cd0: 12 80 00 0d bne 2022d04 2022cd4: 03 00 80 ec sethi %hi(0x203b000), %g1 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 2022cd8: c6 00 62 00 ld [ %g1 + 0x200 ], %g3 ! 203b200 2022cdc: c4 06 00 00 ld [ %i0 ], %g2 2022ce0: c2 00 e0 04 ld [ %g3 + 4 ], %g1 2022ce4: 80 a0 40 02 cmp %g1, %g2 2022ce8: 22 80 00 02 be,a 2022cf0 2022cec: c0 20 e0 04 clr [ %g3 + 4 ] <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 2022cf0: 90 10 00 10 mov %l0, %o0 2022cf4: 7f ff 86 1d call 2004568 2022cf8: b0 10 20 00 clr %i0 2022cfc: 81 c7 e0 08 ret 2022d00: 81 e8 00 00 restore } return 0; } 2022d04: 81 c7 e0 08 ret 2022d08: 91 e8 20 00 restore %g0, 0, %o0 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) rtems_set_errno_and_return_minus_one( EBUSY ); 2022d0c: 40 00 0a c3 call 2025818 <__errno> 2022d10: b0 10 3f ff mov -1, %i0 2022d14: 82 10 20 10 mov 0x10, %g1 2022d18: c2 22 00 00 st %g1, [ %o0 ] 2022d1c: 81 c7 e0 08 ret 2022d20: 81 e8 00 00 restore /* * You cannot remove a node that still has children */ if ( ! Chain_Is_empty( &the_jnode->info.directory.Entries ) ) rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 2022d24: 40 00 0a bd call 2025818 <__errno> 2022d28: b0 10 3f ff mov -1, %i0 2022d2c: 82 10 20 5a mov 0x5a, %g1 2022d30: c2 22 00 00 st %g1, [ %o0 ] 2022d34: 81 c7 e0 08 ret 2022d38: 81 e8 00 00 restore 020183a0 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 20183a0: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 20183a4: 05 00 80 f2 sethi %hi(0x203c800), %g2 <== NOT EXECUTED 20183a8: c2 48 a1 c0 ldsb [ %g2 + 0x1c0 ], %g1 ! 203c9c0 <== NOT EXECUTED 20183ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20183b0: 02 80 00 04 be 20183c0 <== NOT EXECUTED 20183b4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20183b8: 81 c7 e0 08 ret <== NOT EXECUTED 20183bc: 81 e8 00 00 restore <== NOT EXECUTED return; etc_passwd_initted = 1; mkdir("/etc", 0777); 20183c0: 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; 20183c4: c2 28 a1 c0 stb %g1, [ %g2 + 0x1c0 ] <== NOT EXECUTED mkdir("/etc", 0777); 20183c8: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 20183cc: 40 00 01 3b call 20188b8 <== NOT EXECUTED 20183d0: 90 12 23 58 or %o0, 0x358, %o0 ! 2037f58 <_CPU_Trap_slot_template+0xe70> <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 20183d4: 31 00 80 df sethi %hi(0x2037c00), %i0 <== NOT EXECUTED 20183d8: 21 00 80 e8 sethi %hi(0x203a000), %l0 <== NOT EXECUTED 20183dc: 90 16 23 60 or %i0, 0x360, %o0 <== NOT EXECUTED 20183e0: 40 00 37 62 call 2026168 <== NOT EXECUTED 20183e4: 92 14 23 80 or %l0, 0x380, %o1 <== NOT EXECUTED 20183e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20183ec: 22 80 00 0d be,a 2018420 <== NOT EXECUTED 20183f0: 90 16 23 60 or %i0, 0x360, %o0 <== NOT EXECUTED } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 20183f4: 40 00 35 5f call 2025970 <== NOT EXECUTED 20183f8: 01 00 00 00 nop <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 20183fc: 92 14 23 80 or %l0, 0x380, %o1 <== NOT EXECUTED 2018400: 31 00 80 df sethi %hi(0x2037c00), %i0 <== NOT EXECUTED 2018404: 40 00 37 59 call 2026168 <== NOT EXECUTED 2018408: 90 16 23 d8 or %i0, 0x3d8, %o0 ! 2037fd8 <_CPU_Trap_slot_template+0xef0> <== NOT EXECUTED 201840c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018410: 22 80 00 11 be,a 2018454 <== NOT EXECUTED 2018414: 90 16 23 d8 or %i0, 0x3d8, %o0 <== NOT EXECUTED fclose(fp); 2018418: 40 00 35 56 call 2025970 <== NOT EXECUTED 201841c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 2018420: 13 00 80 dc sethi %hi(0x2037000), %o1 <== NOT EXECUTED 2018424: 40 00 37 51 call 2026168 <== NOT EXECUTED 2018428: 92 12 60 f8 or %o1, 0xf8, %o1 ! 20370f8 <_CPU_Trap_slot_template+0x10> <== NOT EXECUTED 201842c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2018430: 02 bf ff f3 be 20183fc <== NOT EXECUTED 2018434: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 2018438: 94 10 20 66 mov 0x66, %o2 <== NOT EXECUTED 201843c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 2018440: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 2018444: 40 00 3a 8f call 2026e80 <== NOT EXECUTED 2018448: 90 12 23 70 or %o0, 0x370, %o0 ! 2037f70 <_CPU_Trap_slot_template+0xe88> <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 201844c: 10 bf ff ea b 20183f4 <== NOT EXECUTED 2018450: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 2018454: 13 00 80 dc sethi %hi(0x2037000), %o1 <== NOT EXECUTED 2018458: 40 00 37 44 call 2026168 <== NOT EXECUTED 201845c: 92 12 60 f8 or %o1, 0xf8, %o1 ! 20370f8 <_CPU_Trap_slot_template+0x10> <== NOT EXECUTED 2018460: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2018464: 02 bf ff d5 be 20183b8 <== NOT EXECUTED 2018468: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 201846c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2018470: 94 10 20 2a mov 0x2a, %o2 <== NOT EXECUTED 2018474: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 2018478: 40 00 3a 82 call 2026e80 <== NOT EXECUTED 201847c: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 2018480: 40 00 35 3c call 2025970 <== NOT EXECUTED 2018484: 81 e8 00 00 restore <== NOT EXECUTED 2018488: 01 00 00 00 nop 02019a94 : int ioctl( int fd, ioctl_command_t command, ... ) { 2019a94: 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 ); 2019a98: 03 00 80 a4 sethi %hi(0x2029000), %g1 2019a9c: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20290ec int ioctl( int fd, ioctl_command_t command, ... ) { 2019aa0: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2019aa4: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2019aa8: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2019aac: 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 ); 2019ab0: 80 a6 00 02 cmp %i0, %g2 2019ab4: 1a 80 00 1b bcc 2019b20 2019ab8: 92 10 00 19 mov %i1, %o1 iop = rtems_libio_iop( fd ); 2019abc: 03 00 80 ad sethi %hi(0x202b400), %g1 2019ac0: c6 00 60 94 ld [ %g1 + 0x94 ], %g3 ! 202b494 2019ac4: 85 2e 20 02 sll %i0, 2, %g2 2019ac8: 83 2e 20 04 sll %i0, 4, %g1 2019acc: 82 20 40 02 sub %g1, %g2, %g1 2019ad0: 82 00 40 18 add %g1, %i0, %g1 2019ad4: 83 28 60 02 sll %g1, 2, %g1 2019ad8: 90 00 40 03 add %g1, %g3, %o0 rtems_libio_check_is_open(iop); 2019adc: c4 02 20 0c ld [ %o0 + 0xc ], %g2 2019ae0: 80 88 a1 00 btst 0x100, %g2 2019ae4: 02 80 00 0f be 2019b20 2019ae8: 82 07 a0 50 add %fp, 0x50, %g1 /* * Now process the ioctl(). */ if ( !iop->handlers ) 2019aec: 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 *); 2019af0: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Now process the ioctl(). */ if ( !iop->handlers ) 2019af4: 80 a0 a0 00 cmp %g2, 0 2019af8: 02 80 00 0a be 2019b20 2019afc: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->ioctl_h ) 2019b00: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2019b04: 80 a0 60 00 cmp %g1, 0 2019b08: 02 80 00 0c be 2019b38 2019b0c: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 2019b10: 9f c0 40 00 call %g1 2019b14: 01 00 00 00 nop return rc; } 2019b18: 81 c7 e0 08 ret 2019b1c: 91 e8 00 08 restore %g0, %o0, %o0 /* * Now process the ioctl(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 2019b20: 40 00 02 a0 call 201a5a0 <__errno> <== NOT EXECUTED 2019b24: 01 00 00 00 nop <== NOT EXECUTED 2019b28: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 2019b2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019b30: 10 bf ff fa b 2019b18 <== NOT EXECUTED 2019b34: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED if ( !iop->handlers->ioctl_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2019b38: 40 00 02 9a call 201a5a0 <__errno> <== NOT EXECUTED 2019b3c: 01 00 00 00 nop <== NOT EXECUTED 2019b40: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2019b44: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019b48: 10 bf ff f4 b 2019b18 <== NOT EXECUTED 2019b4c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 02003eb8 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 2003eb8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 2003ebc: c6 06 60 30 ld [ %i1 + 0x30 ], %g3 <== NOT EXECUTED 2003ec0: 80 88 e0 20 btst 0x20, %g3 <== NOT EXECUTED 2003ec4: 02 80 00 03 be 2003ed0 <== NOT EXECUTED 2003ec8: a0 10 00 18 mov %i0, %l0 <== NOT EXECUTED c &= 0x7f; 2003ecc: a0 0e 20 7f and %i0, 0x7f, %l0 <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 2003ed0: 80 88 e2 00 btst 0x200, %g3 <== NOT EXECUTED 2003ed4: 02 80 00 0b be 2003f00 <== NOT EXECUTED 2003ed8: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED c = tolower (c); 2003edc: 03 00 80 63 sethi %hi(0x2018c00), %g1 <== NOT EXECUTED 2003ee0: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 2018e30 <__ctype_ptr> <== NOT EXECUTED 2003ee4: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED 2003ee8: c2 08 80 08 ldub [ %g2 + %o0 ], %g1 <== NOT EXECUTED 2003eec: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 2003ef0: 32 80 00 02 bne,a 2003ef8 <== NOT EXECUTED 2003ef4: 90 02 20 20 add %o0, 0x20, %o0 <== NOT EXECUTED 2003ef8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED if (c == '\r') { 2003efc: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED 2003f00: 80 a0 60 0d cmp %g1, 0xd <== NOT EXECUTED 2003f04: 02 80 00 32 be 2003fcc <== NOT EXECUTED 2003f08: 80 a0 60 0a cmp %g1, 0xa <== NOT EXECUTED if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 2003f0c: 02 80 00 35 be 2003fe0 <== NOT EXECUTED 2003f10: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 2003f14: 02 80 00 1f be 2003f90 <== NOT EXECUTED 2003f18: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2003f1c: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED 2003f20: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED 2003f24: 22 80 00 1b be,a 2003f90 <== NOT EXECUTED 2003f28: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 2003f2c: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1 <== NOT EXECUTED 2003f30: a2 0c 20 ff and %l0, 0xff, %l1 <== NOT EXECUTED 2003f34: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003f38: 02 80 00 5a be 20040a0 <== NOT EXECUTED 2003f3c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 2003f40: c2 0e 60 44 ldub [ %i1 + 0x44 ], %g1 <== NOT EXECUTED 2003f44: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003f48: 02 80 00 5b be 20040b4 <== NOT EXECUTED 2003f4c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 2003f50: c2 0e 60 45 ldub [ %i1 + 0x45 ], %g1 <== NOT EXECUTED 2003f54: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003f58: 02 80 00 55 be 20040ac <== NOT EXECUTED 2003f5c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return 1; } else if (c == '\n') { 2003f60: 80 a4 60 0a cmp %l1, 0xa <== NOT EXECUTED 2003f64: 02 80 00 3e be 200405c <== NOT EXECUTED 2003f68: 80 88 a0 48 btst 0x48, %g2 <== NOT EXECUTED if (tty->termios.c_lflag & (ECHO | ECHONL)) echo (c, tty); tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) 2003f6c: c2 0e 60 4c ldub [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 2003f70: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003f74: 02 80 00 27 be 2004010 <== NOT EXECUTED 2003f78: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED 2003f7c: c2 0e 60 51 ldub [ %i1 + 0x51 ], %g1 <== NOT EXECUTED 2003f80: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003f84: 02 80 00 23 be 2004010 <== NOT EXECUTED 2003f88: 80 88 a0 08 btst 8, %g2 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 2003f8c: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED 2003f90: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED 2003f94: c2 00 a1 ec ld [ %g2 + 0x1ec ], %g1 <== NOT EXECUTED 2003f98: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2003f9c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2003fa0: 16 80 00 0e bge 2003fd8 <== NOT EXECUTED 2003fa4: 01 00 00 00 nop <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 2003fa8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 2003fac: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED 2003fb0: 12 80 00 21 bne 2004034 <== NOT EXECUTED 2003fb4: 84 00 e0 01 add %g3, 1, %g2 <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 2003fb8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 2003fbc: e0 28 40 03 stb %l0, [ %g1 + %g3 ] <== NOT EXECUTED 2003fc0: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED 2003fc4: 81 c7 e0 08 ret <== NOT EXECUTED 2003fc8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 2003fcc: 80 88 e0 80 btst 0x80, %g3 <== NOT EXECUTED 2003fd0: 02 80 00 0c be 2004000 <== NOT EXECUTED 2003fd4: 80 88 e1 00 btst 0x100, %g3 <== NOT EXECUTED * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; 2003fd8: 81 c7 e0 08 ret <== NOT EXECUTED 2003fdc: 91 e8 20 00 restore %g0, 0, %o0 <== 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)) { 2003fe0: 80 88 e0 40 btst 0x40, %g3 <== NOT EXECUTED 2003fe4: 02 bf ff cf be 2003f20 <== NOT EXECUTED 2003fe8: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 2003fec: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED 2003ff0: 02 bf ff e7 be 2003f8c <== NOT EXECUTED 2003ff4: a0 10 20 0d mov 0xd, %l0 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 2003ff8: 10 bf ff ce b 2003f30 <== NOT EXECUTED 2003ffc: c2 0e 60 43 ldub [ %i1 + 0x43 ], %g1 <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) return 0; if (tty->termios.c_iflag & ICRNL) 2004000: 32 bf ff c7 bne,a 2003f1c <== NOT EXECUTED 2004004: a0 10 20 0a mov 0xa, %l0 <== NOT EXECUTED c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 2004008: 10 bf ff c6 b 2003f20 <== NOT EXECUTED 200400c: c4 06 60 3c ld [ %i1 + 0x3c ], %g2 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL]) || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 2004010: 12 80 00 1c bne 2004080 <== NOT EXECUTED 2004014: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 2004018: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED 200401c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED 2004020: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED 2004024: e0 28 80 01 stb %l0, [ %g2 + %g1 ] <== NOT EXECUTED 2004028: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED 200402c: 81 c7 e0 08 ret <== NOT EXECUTED 2004030: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 2004034: 90 0c 20 ff and %l0, 0xff, %o0 <== NOT EXECUTED 2004038: 7f ff fe f0 call 2003bf8 <== NOT EXECUTED 200403c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2004040: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2004044: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 2004048: 84 00 e0 01 add %g3, 1, %g2 <== NOT EXECUTED 200404c: e0 28 40 03 stb %l0, [ %g1 + %g3 ] <== NOT EXECUTED 2004050: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED 2004054: 81 c7 e0 08 ret <== NOT EXECUTED 2004058: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 200405c: 12 80 00 0d bne 2004090 <== NOT EXECUTED 2004060: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 2004064: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED 2004068: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED 200406c: 86 00 60 01 add %g1, 1, %g3 <== NOT EXECUTED 2004070: e2 28 80 01 stb %l1, [ %g2 + %g1 ] <== NOT EXECUTED 2004074: c6 26 60 20 st %g3, [ %i1 + 0x20 ] <== NOT EXECUTED 2004078: 81 c7 e0 08 ret <== NOT EXECUTED 200407c: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED return 1; } else if ((c == tty->termios.c_cc[VEOL]) || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 2004080: 7f ff fe de call 2003bf8 <== NOT EXECUTED 2004084: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2004088: 10 bf ff e5 b 200401c <== NOT EXECUTED 200408c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) echo (c, tty); 2004090: 7f ff fe da call 2003bf8 <== NOT EXECUTED 2004094: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 2004098: 10 bf ff f4 b 2004068 <== NOT EXECUTED 200409c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); 20040a0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20040a4: 7f ff fe f5 call 2003c78 <== NOT EXECUTED 20040a8: b0 10 20 00 clr %i0 <== NOT EXECUTED 20040ac: 81 c7 e0 08 ret <== NOT EXECUTED 20040b0: 81 e8 00 00 restore <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); 20040b4: 7f ff fe f1 call 2003c78 <== NOT EXECUTED 20040b8: b0 10 20 00 clr %i0 <== NOT EXECUTED 20040bc: 81 c7 e0 08 ret <== NOT EXECUTED 20040c0: 81 e8 00 00 restore <== NOT EXECUTED 02024b08 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 2024b08: 9d e3 bf 88 save %sp, -120, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 2024b0c: 7f ff ff 11 call 2024750 2024b10: 01 00 00 00 nop 2024b14: 80 a2 00 18 cmp %o0, %i0 2024b18: 12 80 00 ca bne 2024e40 2024b1c: 80 a6 60 00 cmp %i1, 0 /* * Validate the signal passed. */ if ( !sig ) 2024b20: 02 80 00 ce be 2024e58 2024b24: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2024b28: 90 06 7f ff add %i1, -1, %o0 2024b2c: 80 a2 20 1f cmp %o0, 0x1f 2024b30: 18 80 00 ca bgu 2024e58 2024b34: 03 00 80 af sethi %hi(0x202bc00), %g1 /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 2024b38: a5 2e 60 02 sll %i1, 2, %l2 2024b3c: ac 10 61 78 or %g1, 0x178, %l6 2024b40: a7 2e 60 04 sll %i1, 4, %l3 2024b44: 82 24 c0 12 sub %l3, %l2, %g1 2024b48: 82 00 40 16 add %g1, %l6, %g1 2024b4c: c4 00 60 08 ld [ %g1 + 8 ], %g2 2024b50: 80 a0 a0 01 cmp %g2, 1 2024b54: 02 80 00 4f be 2024c90 2024b58: 80 a6 60 0b cmp %i1, 0xb * 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 ) { 2024b5c: 18 80 00 0c bgu 2024b8c 2024b60: 82 10 20 01 mov 1, %g1 2024b64: 83 28 40 19 sll %g1, %i1, %g1 <== NOT EXECUTED 2024b68: 80 88 69 10 btst 0x910, %g1 <== NOT EXECUTED 2024b6c: 02 80 00 08 be 2024b8c <== NOT EXECUTED 2024b70: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED case SIGFPE: case SIGILL: case SIGSEGV: return pthread_kill( pthread_self(), sig ); 2024b74: 40 00 01 75 call 2025148 <== NOT EXECUTED 2024b78: 01 00 00 00 nop <== NOT EXECUTED 2024b7c: 40 00 01 25 call 2025010 <== NOT EXECUTED 2024b80: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 2024b84: 81 c7 e0 08 ret 2024b88: 91 e8 00 08 restore %g0, %o0, %o0 /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 2024b8c: f2 27 bf ec st %i1, [ %fp + -20 ] siginfo->si_code = SI_USER; 2024b90: c2 27 bf f0 st %g1, [ %fp + -16 ] if ( !value ) { 2024b94: 80 a6 a0 00 cmp %i2, 0 2024b98: 02 80 00 46 be 2024cb0 2024b9c: b1 28 40 08 sll %g1, %o0, %i0 siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 2024ba0: c2 06 80 00 ld [ %i2 ], %g1 2024ba4: c2 27 bf f4 st %g1, [ %fp + -12 ] 2024ba8: 35 00 80 ad sethi %hi(0x202b400), %i2 2024bac: c2 06 a2 60 ld [ %i2 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 2024bb0: 82 00 60 01 inc %g1 2024bb4: c2 26 a2 60 st %g1, [ %i2 + 0x260 ] /* * 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; 2024bb8: 03 00 80 ad sethi %hi(0x202b400), %g1 2024bbc: c6 00 63 40 ld [ %g1 + 0x340 ], %g3 ! 202b740 <_Thread_Executing> api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 2024bc0: c4 00 e1 74 ld [ %g3 + 0x174 ], %g2 2024bc4: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 2024bc8: 80 ae 00 01 andncc %i0, %g1, %g0 2024bcc: 12 80 00 1a bne 2024c34 2024bd0: 03 00 80 af sethi %hi(0x202bc00), %g1 goto process_it; 2024bd4: 98 10 63 04 or %g1, 0x304, %o4 ! 202bf04 <_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 ; 2024bd8: 96 03 20 30 add %o4, 0x30, %o3 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 2024bdc: c8 03 00 00 ld [ %o4 ], %g4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 2024be0: 9a 03 20 04 add %o4, 4, %o5 !_Chain_Is_tail( the_chain, the_node ) ; 2024be4: 80 a1 00 0d cmp %g4, %o5 2024be8: 02 80 00 34 be 2024cb8 2024bec: 86 10 00 04 mov %g4, %g3 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)) { 2024bf0: c2 01 20 30 ld [ %g4 + 0x30 ], %g1 2024bf4: 80 8e 00 01 btst %i0, %g1 2024bf8: 02 80 00 0b be 2024c24 2024bfc: c4 01 21 74 ld [ %g4 + 0x174 ], %g2 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 2024c00: 10 80 00 0e b 2024c38 2024c04: 82 10 20 01 mov 1, %g1 index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 2024c08: 80 a1 00 0d cmp %g4, %o5 <== NOT EXECUTED 2024c0c: 02 80 00 2b be 2024cb8 <== NOT EXECUTED 2024c10: 86 10 00 04 mov %g4, %g3 <== NOT EXECUTED 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)) { 2024c14: c2 00 e0 30 ld [ %g3 + 0x30 ], %g1 <== NOT EXECUTED 2024c18: 80 8e 00 01 btst %i0, %g1 <== NOT EXECUTED 2024c1c: 12 80 00 06 bne 2024c34 <== NOT EXECUTED 2024c20: c4 00 e1 74 ld [ %g3 + 0x174 ], %g2 <== NOT EXECUTED 2024c24: c2 00 a0 c4 ld [ %g2 + 0xc4 ], %g1 <== NOT EXECUTED 2024c28: 80 ae 00 01 andncc %i0, %g1, %g0 <== NOT EXECUTED 2024c2c: 22 bf ff f7 be,a 2024c08 <== NOT EXECUTED 2024c30: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 2024c34: 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 ) ) { 2024c38: 90 10 00 03 mov %g3, %o0 2024c3c: 92 10 00 19 mov %i1, %o1 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 2024c40: c2 20 e0 78 st %g1, [ %g3 + 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 ) ) { 2024c44: 40 00 00 a8 call 2024ee4 <_POSIX_signals_Unblock_thread> 2024c48: 94 07 bf ec add %fp, -20, %o2 2024c4c: 80 a2 20 00 cmp %o0, 0 2024c50: 12 80 00 09 bne 2024c74 2024c54: 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 ); 2024c58: 40 00 00 93 call 2024ea4 <_POSIX_signals_Set_process_signals> 2024c5c: 90 10 00 18 mov %i0, %o0 if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 2024c60: b2 24 c0 12 sub %l3, %l2, %i1 2024c64: c2 05 80 19 ld [ %l6 + %i1 ], %g1 2024c68: 80 a0 60 02 cmp %g1, 2 2024c6c: 02 80 00 65 be 2024e00 2024c70: 11 00 80 af sethi %hi(0x202bc00), %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2024c74: c2 06 a2 60 ld [ %i2 + 0x260 ], %g1 2024c78: 82 00 7f ff add %g1, -1, %g1 2024c7c: c2 26 a2 60 st %g1, [ %i2 + 0x260 ] 2024c80: c4 06 a2 60 ld [ %i2 + 0x260 ], %g2 2024c84: 80 a0 a0 00 cmp %g2, 0 2024c88: 02 80 00 05 be 2024c9c 2024c8c: 01 00 00 00 nop _Thread_Dispatch(); 2024c90: 90 10 20 00 clr %o0 ! 0 _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 2024c94: 81 c7 e0 08 ret 2024c98: 91 e8 00 08 restore %g0, %o0, %o0 2024c9c: 7f ff ae 15 call 20104f0 <_Thread_Dispatch> 2024ca0: 01 00 00 00 nop 2024ca4: 90 10 20 00 clr %o0 ! 0 2024ca8: 81 c7 e0 08 ret 2024cac: 91 e8 00 08 restore %g0, %o0, %o0 siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 2024cb0: 10 bf ff be b 2024ba8 2024cb4: c0 27 bf f4 clr [ %fp + -12 ] index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 2024cb8: 98 03 20 0c add %o4, 0xc, %o4 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 2024cbc: 80 a3 00 0b cmp %o4, %o3 2024cc0: 32 bf ff c8 bne,a 2024be0 2024cc4: c8 03 00 00 ld [ %o4 ], %g4 2024cc8: 03 00 80 ad sethi %hi(0x202b400), %g1 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 2024ccc: 05 00 80 a4 sethi %hi(0x2029000), %g2 2024cd0: ba 10 61 c0 or %g1, 0x1c0, %i5 2024cd4: b6 10 a0 10 or %g2, 0x10, %i3 */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 2024cd8: ae 10 20 00 clr %l7 2024cdc: aa 10 20 02 mov 2, %l5 2024ce0: a8 10 21 00 mov 0x100, %l4 * 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 ) 2024ce4: 39 04 00 00 sethi %hi(0x10000000), %i4 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 2024ce8: 83 2d 60 02 sll %l5, 2, %g1 2024cec: c2 07 40 01 ld [ %i5 + %g1 ], %g1 2024cf0: 80 a0 60 00 cmp %g1, 0 2024cf4: 22 80 00 35 be,a 2024dc8 2024cf8: aa 05 60 01 inc %l5 continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 2024cfc: c2 00 60 04 ld [ %g1 + 4 ], %g1 if ( !the_info ) /* manager not installed */ 2024d00: 80 a0 60 00 cmp %g1, 0 2024d04: 22 80 00 31 be,a 2024dc8 2024d08: aa 05 60 01 inc %l5 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; 2024d0c: e2 00 60 20 ld [ %g1 + 0x20 ], %l1 assert( object_table ); /* always at least 1 entry */ 2024d10: 80 a4 60 00 cmp %l1, 0 2024d14: 02 80 00 57 be 2024e70 2024d18: e0 10 60 10 lduh [ %g1 + 0x10 ], %l0 for ( index = 1 ; index <= maximum ; index++ ) { 2024d1c: 80 a4 20 00 cmp %l0, 0 2024d20: 22 80 00 2a be,a 2024dc8 2024d24: aa 05 60 01 inc %l5 2024d28: 88 10 20 01 mov 1, %g4 the_thread = (Thread_Control *) object_table[ index ]; 2024d2c: 83 29 20 02 sll %g4, 2, %g1 2024d30: c4 00 40 11 ld [ %g1 + %l1 ], %g2 if ( !the_thread ) 2024d34: 80 a0 a0 00 cmp %g2, 0 2024d38: 22 80 00 20 be,a 2024db8 2024d3c: 88 01 20 01 inc %g4 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 2024d40: c6 00 a0 14 ld [ %g2 + 0x14 ], %g3 2024d44: 80 a0 c0 14 cmp %g3, %l4 2024d48: 38 80 00 1c bgu,a 2024db8 2024d4c: 88 01 20 01 inc %g4 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2024d50: c2 00 a1 74 ld [ %g2 + 0x174 ], %g1 if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 2024d54: 80 a0 60 00 cmp %g1, 0 2024d58: 22 80 00 18 be,a 2024db8 2024d5c: 88 01 20 01 inc %g4 <== NOT EXECUTED 2024d60: c2 00 60 c4 ld [ %g1 + 0xc4 ], %g1 2024d64: 80 ae 00 01 andncc %i0, %g1, %g0 2024d68: 22 80 00 14 be,a 2024db8 2024d6c: 88 01 20 01 inc %g4 * 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 ) { 2024d70: 80 a0 c0 14 cmp %g3, %l4 2024d74: 2a 80 00 1c bcs,a 2024de4 2024d78: a8 10 00 03 mov %g3, %l4 * 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 ) ) 2024d7c: c2 05 e0 10 ld [ %l7 + 0x10 ], %g1 <== NOT EXECUTED 2024d80: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2024d84: 22 80 00 0d be,a 2024db8 <== NOT EXECUTED 2024d88: 88 01 20 01 inc %g4 <== 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 ) ) { 2024d8c: da 00 a0 10 ld [ %g2 + 0x10 ], %o5 <== NOT EXECUTED 2024d90: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED 2024d94: 22 80 00 14 be,a 2024de4 <== NOT EXECUTED 2024d98: a8 10 00 03 mov %g3, %l4 <== 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 ) 2024d9c: 80 88 40 1c btst %g1, %i4 <== NOT EXECUTED 2024da0: 32 80 00 06 bne,a 2024db8 <== NOT EXECUTED 2024da4: 88 01 20 01 inc %g4 <== 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 ) { 2024da8: 80 8b 40 1c btst %o5, %i4 <== NOT EXECUTED 2024dac: 32 80 00 0e bne,a 2024de4 <== NOT EXECUTED 2024db0: a8 10 00 03 mov %g3, %l4 <== NOT EXECUTED maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ for ( index = 1 ; index <= maximum ; index++ ) { 2024db4: 88 01 20 01 inc %g4 2024db8: 80 a4 00 04 cmp %l0, %g4 2024dbc: 1a bf ff dd bcc 2024d30 2024dc0: 83 29 20 02 sll %g4, 2, %g1 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 2024dc4: aa 05 60 01 inc %l5 interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = 2; the_api <= OBJECTS_APIS_LAST; 2024dc8: 80 a5 60 04 cmp %l5, 4 2024dcc: 18 80 00 08 bgu 2024dec 2024dd0: 80 a5 60 01 cmp %l5, 1 the_api++ ) { if ( the_api == OBJECTS_INTERNAL_THREADS ) 2024dd4: 22 bf ff c5 be,a 2024ce8 2024dd8: aa 10 20 02 mov 2, %l5 <== NOT EXECUTED continue; if ( !_Objects_Information_table[ the_api ] ) /* API not installed */ 2024ddc: 10 bf ff c4 b 2024cec 2024de0: 83 2d 60 02 sll %l5, 2, %g1 * 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 ) { 2024de4: 10 bf ff f4 b 2024db4 2024de8: ae 10 00 02 mov %g2, %l7 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 2024dec: 80 a5 e0 00 cmp %l7, 0 2024df0: 02 bf ff 9a be 2024c58 2024df4: 86 10 00 17 mov %l7, %g3 * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = TRUE; 2024df8: 10 bf ff 90 b 2024c38 2024dfc: 82 10 20 01 mov 1, %g1 _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 2024e00: 7f ff a4 93 call 200e04c <_Chain_Get> 2024e04: 90 12 22 f8 or %o0, 0x2f8, %o0 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 2024e08: 80 a2 20 00 cmp %o0, 0 2024e0c: 02 80 00 20 be 2024e8c 2024e10: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 2024e14: 92 10 00 08 mov %o0, %o1 _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 2024e18: c2 22 20 08 st %g1, [ %o0 + 8 ] 2024e1c: c4 07 bf f0 ld [ %fp + -16 ], %g2 2024e20: c4 22 20 0c st %g2, [ %o0 + 0xc ] 2024e24: c2 07 bf f4 ld [ %fp + -12 ], %g1 2024e28: c2 22 20 10 st %g1, [ %o0 + 0x10 ] _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 2024e2c: 11 00 80 af sethi %hi(0x202bc00), %o0 2024e30: 90 12 23 48 or %o0, 0x348, %o0 ! 202bf48 <_POSIX_signals_Siginfo> 2024e34: 7f ff a4 7a call 200e01c <_Chain_Append> 2024e38: 90 06 40 08 add %i1, %o0, %o0 2024e3c: 30 bf ff 8e b,a 2024c74 /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 2024e40: 7f ff d5 d8 call 201a5a0 <__errno> 2024e44: 01 00 00 00 nop 2024e48: 82 10 20 03 mov 3, %g1 ! 3 2024e4c: c2 22 00 00 st %g1, [ %o0 ] 2024e50: 10 bf ff 4d b 2024b84 2024e54: 90 10 3f ff mov -1, %o0 if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 2024e58: 7f ff d5 d2 call 201a5a0 <__errno> 2024e5c: 01 00 00 00 nop 2024e60: 82 10 20 16 mov 0x16, %g1 ! 16 2024e64: c2 22 00 00 st %g1, [ %o0 ] 2024e68: 10 bf ff 47 b 2024b84 2024e6c: 90 10 3f ff mov -1, %o0 continue; maximum = the_info->maximum; object_table = the_info->local_table; assert( object_table ); /* always at least 1 entry */ 2024e70: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 2024e74: 92 10 20 c1 mov 0xc1, %o1 <== NOT EXECUTED 2024e78: 15 00 80 a4 sethi %hi(0x2029000), %o2 <== NOT EXECUTED 2024e7c: 7f ff 8e e4 call 2008a0c <__assert> <== NOT EXECUTED 2024e80: 94 12 a0 58 or %o2, 0x58, %o2 ! 2029058 <_RTEMS_version+0x68> <== NOT EXECUTED for ( index = 1 ; index <= maximum ; index++ ) { 2024e84: 10 bf ff a7 b 2024d20 <== NOT EXECUTED 2024e88: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { rtems_set_errno_and_return_minus_one( EAGAIN ); 2024e8c: 7f ff d5 c5 call 201a5a0 <__errno> <== NOT EXECUTED 2024e90: 01 00 00 00 nop <== NOT EXECUTED 2024e94: 82 10 20 0b mov 0xb, %g1 ! b <== NOT EXECUTED 2024e98: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2024e9c: 10 bf ff 3a b 2024b84 <== NOT EXECUTED 2024ea0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 02016edc : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 2016edc: 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())) 2016ee0: 03 00 80 66 sethi %hi(0x2019800), %g1 2016ee4: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> 2016ee8: 80 a0 a0 03 cmp %g2, 3 2016eec: 12 80 00 15 bne 2016f40 2016ef0: 21 00 80 63 sethi %hi(0x2018c00), %l0 /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 2016ef4: c4 04 22 38 ld [ %l0 + 0x238 ], %g2 ! 2018e38 <_impure_ptr> 2016ef8: 03 00 80 61 sethi %hi(0x2018400), %g1 2016efc: b0 10 61 e8 or %g1, 0x1e8, %i0 ! 20185e8 2016f00: 80 a0 80 18 cmp %g2, %i0 2016f04: 02 80 00 06 be 2016f1c 2016f08: c2 04 22 38 ld [ %l0 + 0x238 ], %g1 _wrapup_reent(&libc_global_reent); 2016f0c: 40 00 00 ab call 20171b8 <_wrapup_reent> 2016f10: 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; 2016f14: f0 24 22 38 st %i0, [ %l0 + 0x238 ] * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 2016f18: c2 04 22 38 ld [ %l0 + 0x238 ], %g1 2016f1c: 7f ff e0 bf call 200f218 2016f20: d0 00 60 04 ld [ %g1 + 4 ], %o0 fclose (stdout); 2016f24: c2 04 22 38 ld [ %l0 + 0x238 ], %g1 2016f28: 7f ff e0 bc call 200f218 2016f2c: d0 00 60 08 ld [ %g1 + 8 ], %o0 fclose (stderr); 2016f30: c2 04 22 38 ld [ %l0 + 0x238 ], %g1 2016f34: f0 00 60 0c ld [ %g1 + 0xc ], %i0 2016f38: 7f ff e0 b8 call 200f218 2016f3c: 81 e8 00 00 restore 2016f40: 81 c7 e0 08 ret <== NOT EXECUTED 2016f44: 81 e8 00 00 restore <== NOT EXECUTED 02003a7c : int link( const char *existing, const char *new ) { 2003a7c: 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 ); 2003a80: 92 10 20 00 clr %o1 2003a84: 90 10 00 18 mov %i0, %o0 2003a88: a0 07 bf e4 add %fp, -28, %l0 2003a8c: 96 10 20 01 mov 1, %o3 2003a90: 94 10 00 10 mov %l0, %o2 2003a94: 7f ff fe 88 call 20034b4 2003a98: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 2003a9c: 80 a2 20 00 cmp %o0, 0 2003aa0: 12 80 00 84 bne 2003cb0 2003aa4: 01 00 00 00 nop /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 2003aa8: c2 4e 40 00 ldsb [ %i1 ], %g1 2003aac: 80 a0 60 2f cmp %g1, 0x2f 2003ab0: 02 80 00 06 be 2003ac8 2003ab4: 80 a0 60 5c cmp %g1, 0x5c 2003ab8: 02 80 00 04 be 2003ac8 2003abc: 80 a0 60 00 cmp %g1, 0 2003ac0: 12 80 00 3a bne 2003ba8 2003ac4: 03 00 80 68 sethi %hi(0x201a000), %g1 2003ac8: 03 00 80 68 sethi %hi(0x201a000), %g1 2003acc: c6 00 62 30 ld [ %g1 + 0x230 ], %g3 ! 201a230 2003ad0: 88 10 20 01 mov 1, %g4 2003ad4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 2003ad8: c2 27 bf d4 st %g1, [ %fp + -44 ] 2003adc: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 2003ae0: c4 27 bf d8 st %g2, [ %fp + -40 ] 2003ae4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2003ae8: c2 27 bf dc st %g1, [ %fp + -36 ] 2003aec: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 2003af0: c4 27 bf e0 st %g2, [ %fp + -32 ] if ( !parent_loc.ops->evalformake_h ) { 2003af4: c2 07 bf dc ld [ %fp + -36 ], %g1 2003af8: c2 00 60 04 ld [ %g1 + 4 ], %g1 2003afc: 80 a0 60 00 cmp %g1, 0 2003b00: 02 80 00 5e be 2003c78 2003b04: 90 06 40 04 add %i1, %g4, %o0 rtems_filesystem_freenode( &existing_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 2003b08: a2 07 bf d4 add %fp, -44, %l1 2003b0c: 94 07 bf f4 add %fp, -12, %o2 2003b10: 9f c0 40 00 call %g1 2003b14: 92 10 00 11 mov %l1, %o1 if ( result != 0 ) { 2003b18: b2 92 20 00 orcc %o0, 0, %i1 2003b1c: 12 80 00 48 bne 2003c3c 2003b20: c4 07 bf e0 ld [ %fp + -32 ], %g2 /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 2003b24: c2 07 bf f0 ld [ %fp + -16 ], %g1 2003b28: 80 a0 80 01 cmp %g2, %g1 2003b2c: 12 80 00 2a bne 2003bd4 2003b30: c4 07 bf dc ld [ %fp + -36 ], %g2 rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } if ( !parent_loc.ops->link_h ) { 2003b34: c2 00 a0 08 ld [ %g2 + 8 ], %g1 2003b38: 80 a0 60 00 cmp %g1, 0 2003b3c: 02 80 00 5f be 2003cb8 2003b40: d4 07 bf f4 ld [ %fp + -12 ], %o2 rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 2003b44: 90 10 00 10 mov %l0, %o0 2003b48: 9f c0 40 00 call %g1 2003b4c: 92 10 00 11 mov %l1, %o1 rtems_filesystem_freenode( &existing_loc ); 2003b50: c2 07 bf ec ld [ %fp + -20 ], %g1 2003b54: 80 a0 60 00 cmp %g1, 0 2003b58: 02 80 00 08 be 2003b78 2003b5c: b0 10 00 08 mov %o0, %i0 2003b60: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003b64: 80 a0 60 00 cmp %g1, 0 2003b68: 22 80 00 05 be,a 2003b7c 2003b6c: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003b70: 9f c0 40 00 call %g1 2003b74: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &parent_loc ); 2003b78: c2 07 bf dc ld [ %fp + -36 ], %g1 2003b7c: 80 a0 60 00 cmp %g1, 0 2003b80: 02 80 00 4c be 2003cb0 2003b84: 01 00 00 00 nop 2003b88: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003b8c: 80 a0 60 00 cmp %g1, 0 2003b90: 02 80 00 48 be 2003cb0 2003b94: 01 00 00 00 nop 2003b98: 9f c0 40 00 call %g1 2003b9c: 90 10 00 11 mov %l1, %o0 return result; } 2003ba0: 81 c7 e0 08 ret 2003ba4: 81 e8 00 00 restore /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 2003ba8: c6 00 62 30 ld [ %g1 + 0x230 ], %g3 2003bac: 88 10 20 00 clr %g4 2003bb0: c2 00 e0 04 ld [ %g3 + 4 ], %g1 2003bb4: c2 27 bf d4 st %g1, [ %fp + -44 ] 2003bb8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 2003bbc: c4 27 bf d8 st %g2, [ %fp + -40 ] 2003bc0: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 2003bc4: c2 27 bf dc st %g1, [ %fp + -36 ] 2003bc8: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 2003bcc: 10 bf ff ca b 2003af4 2003bd0: c4 27 bf e0 st %g2, [ %fp + -32 ] * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { rtems_filesystem_freenode( &existing_loc ); 2003bd4: c2 07 bf ec ld [ %fp + -20 ], %g1 2003bd8: 80 a0 60 00 cmp %g1, 0 2003bdc: 22 80 00 09 be,a 2003c00 2003be0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003be4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003be8: 80 a0 60 00 cmp %g1, 0 2003bec: 22 80 00 05 be,a 2003c00 2003bf0: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED 2003bf4: 9f c0 40 00 call %g1 2003bf8: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &parent_loc ); 2003bfc: c2 07 bf dc ld [ %fp + -36 ], %g1 2003c00: 80 a0 60 00 cmp %g1, 0 2003c04: 02 80 00 08 be 2003c24 2003c08: 01 00 00 00 nop 2003c0c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003c10: 80 a0 60 00 cmp %g1, 0 2003c14: 02 80 00 04 be 2003c24 2003c18: 01 00 00 00 nop 2003c1c: 9f c0 40 00 call %g1 2003c20: 90 10 00 11 mov %l1, %o0 rtems_set_errno_and_return_minus_one( EXDEV ); 2003c24: 40 00 38 4f call 2011d60 <__errno> 2003c28: b0 10 3f ff mov -1, %i0 2003c2c: 82 10 20 12 mov 0x12, %g1 2003c30: c2 22 00 00 st %g1, [ %o0 ] 2003c34: 81 c7 e0 08 ret 2003c38: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); if ( result != 0 ) { rtems_filesystem_freenode( &existing_loc ); 2003c3c: c2 07 bf ec ld [ %fp + -20 ], %g1 2003c40: 80 a0 60 00 cmp %g1, 0 2003c44: 02 80 00 08 be 2003c64 2003c48: 01 00 00 00 nop 2003c4c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2003c50: 80 a0 60 00 cmp %g1, 0 2003c54: 02 80 00 04 be 2003c64 2003c58: 01 00 00 00 nop 2003c5c: 9f c0 40 00 call %g1 2003c60: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( result ); 2003c64: 40 00 38 3f call 2011d60 <__errno> 2003c68: b0 10 3f ff mov -1, %i0 2003c6c: f2 22 00 00 st %i1, [ %o0 ] 2003c70: 81 c7 e0 08 ret 2003c74: 81 e8 00 00 restore */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); if ( !parent_loc.ops->evalformake_h ) { rtems_filesystem_freenode( &existing_loc ); 2003c78: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 2003c7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003c80: 02 80 00 08 be 2003ca0 <== NOT EXECUTED 2003c84: 01 00 00 00 nop <== NOT EXECUTED 2003c88: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2003c8c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003c90: 02 80 00 04 be 2003ca0 <== NOT EXECUTED 2003c94: 01 00 00 00 nop <== NOT EXECUTED 2003c98: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003c9c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } if ( !parent_loc.ops->link_h ) { rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); 2003ca0: 40 00 38 30 call 2011d60 <__errno> <== NOT EXECUTED 2003ca4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2003ca8: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2003cac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2003cb0: 81 c7 e0 08 ret 2003cb4: 81 e8 00 00 restore rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } if ( !parent_loc.ops->link_h ) { rtems_filesystem_freenode( &existing_loc ); 2003cb8: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 2003cbc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003cc0: 02 80 00 0a be 2003ce8 <== NOT EXECUTED 2003cc4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003cc8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2003ccc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003cd0: 02 80 00 06 be 2003ce8 <== NOT EXECUTED 2003cd4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003cd8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003cdc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2003ce0: c4 07 bf dc ld [ %fp + -36 ], %g2 <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 2003ce4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003ce8: 02 bf ff ee be 2003ca0 <== NOT EXECUTED 2003cec: 01 00 00 00 nop <== NOT EXECUTED 2003cf0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2003cf4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003cf8: 02 bf ff ea be 2003ca0 <== NOT EXECUTED 2003cfc: 01 00 00 00 nop <== NOT EXECUTED 2003d00: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003d04: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2003d08: 30 bf ff e6 b,a 2003ca0 <== NOT EXECUTED 02016db8 : off_t lseek( int fd, off_t offset, int whence ) { 2016db8: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 2016dbc: 03 00 80 61 sethi %hi(0x2018400), %g1 2016dc0: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20184ec off_t lseek( int fd, off_t offset, int whence ) { 2016dc4: 92 10 00 19 mov %i1, %o1 rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 2016dc8: 80 a6 00 02 cmp %i0, %g2 2016dcc: 1a 80 00 31 bcc 2016e90 2016dd0: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 2016dd4: 03 00 80 65 sethi %hi(0x2019400), %g1 2016dd8: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 ! 2019670 2016ddc: 85 2e 20 02 sll %i0, 2, %g2 2016de0: 83 2e 20 04 sll %i0, 4, %g1 2016de4: 82 20 40 02 sub %g1, %g2, %g1 2016de8: 82 00 40 18 add %g1, %i0, %g1 2016dec: 83 28 60 02 sll %g1, 2, %g1 2016df0: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 2016df4: c4 06 20 0c ld [ %i0 + 0xc ], %g2 2016df8: 80 88 a1 00 btst 0x100, %g2 2016dfc: 02 80 00 25 be 2016e90 2016e00: 01 00 00 00 nop /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 2016e04: c4 06 20 30 ld [ %i0 + 0x30 ], %g2 2016e08: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 2016e0c: 80 a0 60 00 cmp %g1, 0 2016e10: 02 80 00 26 be 2016ea8 2016e14: 80 a6 a0 01 cmp %i2, 1 /* * Now process the lseek(). */ old_offset = iop->offset; switch ( whence ) { 2016e18: 02 80 00 14 be 2016e68 2016e1c: f4 06 20 08 ld [ %i0 + 8 ], %i2 2016e20: 80 a2 a0 02 cmp %o2, 2 2016e24: 02 80 00 0d be 2016e58 2016e28: 80 a2 a0 00 cmp %o2, 0 2016e2c: 12 80 00 12 bne 2016e74 2016e30: 01 00 00 00 nop case SEEK_SET: iop->offset = offset; 2016e34: f2 26 20 08 st %i1, [ %i0 + 8 ] /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 2016e38: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 2016e3c: 9f c0 40 00 call %g1 2016e40: 90 10 00 18 mov %i0, %o0 if ( status == (off_t) -1 ) 2016e44: 80 a2 3f ff cmp %o0, -1 2016e48: 22 80 00 02 be,a 2016e50 2016e4c: f4 26 20 08 st %i2, [ %i0 + 8 ] /* * So if the operation failed, we have to restore iop->offset. */ return status; } 2016e50: 81 c7 e0 08 ret 2016e54: 91 e8 00 08 restore %g0, %o0, %o0 case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 2016e58: c2 06 20 04 ld [ %i0 + 4 ], %g1 2016e5c: 82 06 40 01 add %i1, %g1, %g1 2016e60: 10 bf ff f6 b 2016e38 2016e64: c2 26 20 08 st %g1, [ %i0 + 8 ] case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 2016e68: 82 06 40 1a add %i1, %i2, %g1 2016e6c: 10 bf ff f3 b 2016e38 2016e70: c2 26 20 08 st %g1, [ %i0 + 8 ] case SEEK_END: iop->offset = iop->size + offset; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2016e74: 7f ff e0 93 call 200f0c0 <__errno> 2016e78: 01 00 00 00 nop 2016e7c: 82 10 20 16 mov 0x16, %g1 ! 16 2016e80: c2 22 00 00 st %g1, [ %o0 ] 2016e84: 90 10 3f ff mov -1, %o0 /* * So if the operation failed, we have to restore iop->offset. */ return status; } 2016e88: 81 c7 e0 08 ret 2016e8c: 91 e8 00 08 restore %g0, %o0, %o0 off_t old_offset; off_t status; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 2016e90: 7f ff e0 8c call 200f0c0 <__errno> <== NOT EXECUTED 2016e94: 01 00 00 00 nop <== NOT EXECUTED 2016e98: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 2016e9c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016ea0: 10 bf ff ec b 2016e50 <== NOT EXECUTED 2016ea4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2016ea8: 7f ff e0 86 call 200f0c0 <__errno> <== NOT EXECUTED 2016eac: 01 00 00 00 nop <== NOT EXECUTED 2016eb0: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2016eb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2016eb8: 10 bf ff e6 b 2016e50 <== NOT EXECUTED 2016ebc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 0200239c : #ifdef RTEMS_NEWLIB void *malloc( size_t size ) { 200239c: 9d e3 bf 98 save %sp, -104, %sp uint32_t sbrk_amount; Chain_Node *to_be_freed; MSBUMP(malloc_calls, 1); if ( !size ) 20023a0: a2 96 20 00 orcc %i0, 0, %l1 20023a4: 02 80 00 1c be 2002414 20023a8: 03 00 80 66 sethi %hi(0x2019800), %g1 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 20023ac: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> 20023b0: 80 a0 a0 03 cmp %g2, 3 20023b4: 02 80 00 13 be 2002400 20023b8: 11 00 80 65 sethi %hi(0x2019400), %o0 20023bc: 10 80 00 04 b 20023cc 20023c0: a0 12 22 d8 or %o0, 0x2d8, %l0 ! 20196d8 /* * 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); 20023c4: 7f ff ff cd call 20022f8 20023c8: 01 00 00 00 nop } /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = Chain_Get(&RTEMS_Malloc_GC_list)) != NULL) 20023cc: 40 00 12 8b call 2006df8 <_Chain_Get> 20023d0: 90 10 00 10 mov %l0, %o0 20023d4: 80 a2 20 00 cmp %o0, 0 20023d8: 12 bf ff fb bne 20023c4 20023dc: 92 10 00 11 mov %l1, %o1 */ #ifdef MALLOC_ARENA_CHECK size += sizeof(struct mallocNode) + SENTINELSIZE; #endif return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 20023e0: 21 00 80 65 sethi %hi(0x2019400), %l0 20023e4: 40 00 17 71 call 20081a8 <_Protected_heap_Allocate> 20023e8: 90 14 22 7c or %l0, 0x27c, %o0 ! 201967c if ( !return_this ) { 20023ec: b0 92 20 00 orcc %o0, 0, %i0 20023f0: 02 80 00 11 be 2002434 20023f4: 03 00 80 65 sethi %hi(0x2019400), %g1 mallocNodeHead.forw = mp; rtems_interrupt_enable(key); } #endif return return_this; } 20023f8: 81 c7 e0 08 ret 20023fc: 81 e8 00 00 restore /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) 2002400: 03 00 80 66 sethi %hi(0x2019800), %g1 2002404: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 2002408: 80 a0 a0 00 cmp %g2, 0 200240c: 02 80 00 04 be 200241c 2002410: 03 00 80 66 sethi %hi(0x2019800), %g1 mallocNodeHead.forw = mp; rtems_interrupt_enable(key); } #endif return return_this; } 2002414: 81 c7 e0 08 ret 2002418: 91 e8 20 00 restore %g0, 0, %o0 if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 200241c: c4 00 61 08 ld [ %g1 + 0x108 ], %g2 2002420: 80 a0 a0 00 cmp %g2, 0 2002424: 02 bf ff ea be 20023cc 2002428: a0 12 22 d8 or %o0, 0x2d8, %l0 MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); if ( !return_this ) { errno = ENOMEM; return (void *) 0; 200242c: 81 c7 e0 08 ret <== NOT EXECUTED 2002430: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED * Round to the "requested sbrk amount" so hopefully we won't have * to grow again for a while. This effectively does sbrk() calls * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; 2002434: e4 00 62 d4 ld [ %g1 + 0x2d4 ], %l2 <== NOT EXECUTED if ( sbrk_amount == 0 ) 2002438: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 200243c: 02 bf ff ef be 20023f8 <== NOT EXECUTED 2002440: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 2002444: 40 00 4e bc call 2015f34 <.udiv> <== NOT EXECUTED 2002448: 90 04 40 12 add %l1, %l2, %o0 <== NOT EXECUTED 200244c: 40 00 4e 80 call 2015e4c <.umul> <== NOT EXECUTED 2002450: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED if ((starting_address = (void *)sbrk(the_size)) 2002454: 40 00 51 f5 call 2016c28 <== NOT EXECUTED 2002458: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 200245c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 2002460: 02 bf ff e6 be 20023f8 <== NOT EXECUTED 2002464: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED == (void*) -1) return (void *) 0; if ( !_Protected_heap_Extend( 2002468: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 200246c: 40 00 17 ea call 2008414 <_Protected_heap_Extend> <== NOT EXECUTED 2002470: 90 14 22 7c or %l0, 0x27c, %o0 <== NOT EXECUTED 2002474: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002478: 02 80 00 0d be 20024ac <== NOT EXECUTED 200247c: 90 14 22 7c or %l0, 0x27c, %o0 <== NOT EXECUTED return (void *) 0; } MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 2002480: 40 00 17 4a call 20081a8 <_Protected_heap_Allocate> <== NOT EXECUTED 2002484: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED if ( !return_this ) { 2002488: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 200248c: 12 80 00 0e bne 20024c4 <== NOT EXECUTED 2002490: 01 00 00 00 nop <== NOT EXECUTED errno = ENOMEM; 2002494: 40 00 33 0b call 200f0c0 <__errno> <== NOT EXECUTED 2002498: 01 00 00 00 nop <== NOT EXECUTED 200249c: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 20024a0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20024a4: 81 c7 e0 08 ret <== NOT EXECUTED 20024a8: 81 e8 00 00 restore <== NOT EXECUTED == (void*) -1) return (void *) 0; if ( !_Protected_heap_Extend( &RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 20024ac: 40 00 51 df call 2016c28 <== NOT EXECUTED 20024b0: 90 20 00 12 neg %l2, %o0 <== NOT EXECUTED errno = ENOMEM; 20024b4: 40 00 33 03 call 200f0c0 <__errno> <== NOT EXECUTED 20024b8: 01 00 00 00 nop <== NOT EXECUTED 20024bc: 82 10 20 0c mov 0xc, %g1 ! c <== NOT EXECUTED 20024c0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20024c4: 81 c7 e0 08 ret <== NOT EXECUTED 20024c8: 81 e8 00 00 restore <== NOT EXECUTED 02004538 : /* * Find amount of free heap remaining */ size_t malloc_free_space( void ) { 2004538: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED Heap_Information info; _Protected_heap_Get_free_information( &RTEMS_Malloc_Heap, &info ); 200453c: 11 00 80 f5 sethi %hi(0x203d400), %o0 <== NOT EXECUTED 2004540: 92 07 bf ec add %fp, -20, %o1 <== NOT EXECUTED 2004544: 40 00 1b 90 call 200b384 <_Protected_heap_Get_free_information> <== NOT EXECUTED 2004548: 90 12 20 2c or %o0, 0x2c, %o0 <== NOT EXECUTED return (size_t) info.largest; } 200454c: f0 07 bf f0 ld [ %fp + -16 ], %i0 <== NOT EXECUTED 2004550: 81 c7 e0 08 ret <== NOT EXECUTED 2004554: 81 e8 00 00 restore <== NOT EXECUTED 0201b6cc : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 201b6cc: 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) ) { 201b6d0: 7f ff a2 f6 call 20042a8 201b6d4: 90 10 00 18 mov %i0, %o0 201b6d8: 80 a2 20 00 cmp %o0, 0 201b6dc: 12 80 00 13 bne 201b728 201b6e0: 01 00 00 00 nop 201b6e4: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 201b6e8: 80 a0 60 00 cmp %g1, 0 201b6ec: 12 80 00 0f bne 201b728 201b6f0: 03 00 80 ec sethi %hi(0x203b000), %g1 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 201b6f4: c2 00 62 00 ld [ %g1 + 0x200 ], %g1 ! 203b200 201b6f8: c4 00 60 04 ld [ %g1 + 4 ], %g2 201b6fc: 80 a0 80 18 cmp %g2, %i0 201b700: 22 80 00 02 be,a 201b708 201b704: c0 20 60 04 clr [ %g1 + 4 ] <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 201b708: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 201b70c: 80 a0 60 06 cmp %g1, 6 201b710: 02 80 00 04 be 201b720 201b714: 01 00 00 00 nop IMFS_memfile_remove( the_jnode ); 201b718: 7f ff ff 6c call 201b4c8 201b71c: 90 10 00 18 mov %i0, %o0 free( the_jnode ); 201b720: 7f ff a3 92 call 2004568 201b724: 90 10 00 18 mov %i0, %o0 } return 0; } 201b728: 81 c7 e0 08 ret 201b72c: 91 e8 20 00 restore %g0, 0, %o0 0201b44c : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 201b44c: 9d e3 bf 98 save %sp, -104, %sp /* * Perform internal consistency checks */ assert( block_table ); 201b450: 80 a6 20 00 cmp %i0, 0 201b454: 02 80 00 16 be 201b4ac 201b458: 80 a6 60 00 cmp %i1, 0 * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i 201b460: e0 06 00 00 ld [ %i0 ], %l0 201b464: a2 10 20 00 clr %l1 201b468: b4 10 20 00 clr %i2 if ( b[i] ) { 201b46c: d0 06 80 10 ld [ %i2 + %l0 ], %o0 201b470: 80 a2 20 00 cmp %o0, 0 201b474: 02 80 00 05 be 201b488 201b478: a2 04 60 01 inc %l1 memfile_free_block( b[i] ); 201b47c: 7f ff ff 1e call 201b0f4 201b480: 01 00 00 00 nop b[i] = 0; 201b484: c0 26 80 10 clr [ %i2 + %l0 ] * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i 201b490: b4 06 a0 04 add %i2, 4, %i2 201b494: e0 06 00 00 ld [ %i0 ], %l0 /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 201b498: 7f ff ff 17 call 201b0f4 201b49c: 90 10 00 10 mov %l0, %o0 *block_table = 0; 201b4a0: c0 26 00 00 clr [ %i0 ] } 201b4a4: 81 c7 e0 08 ret 201b4a8: 81 e8 00 00 restore /* * Perform internal consistency checks */ assert( block_table ); 201b4ac: 31 00 80 e0 sethi %hi(0x2038000), %i0 <== NOT EXECUTED 201b4b0: 35 00 80 e0 sethi %hi(0x2038000), %i2 <== NOT EXECUTED 201b4b4: b0 16 20 58 or %i0, 0x58, %i0 <== NOT EXECUTED 201b4b8: b4 16 a0 e0 or %i2, 0xe0, %i2 <== NOT EXECUTED 201b4bc: 7f ff a2 41 call 2003dc0 <__assert> <== NOT EXECUTED 201b4c0: 93 e8 21 b1 restore %g0, 0x1b1, %o1 <== NOT EXECUTED 201b4c4: 01 00 00 00 nop 0201ba08 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 201ba08: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 201ba0c: 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 ) 201ba10: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 201ba14: 80 a0 40 19 cmp %g1, %i1 201ba18: 16 80 00 06 bge 201ba30 201ba1c: 92 10 00 19 mov %i1, %o1 return IMFS_memfile_extend( the_jnode, length ); 201ba20: 7f ff ff 97 call 201b87c <== NOT EXECUTED 201ba24: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 201ba28: 81 c7 e0 08 ret <== NOT EXECUTED 201ba2c: 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; 201ba30: f2 24 20 4c st %i1, [ %l0 + 0x4c ] iop->size = the_jnode->info.file.size; 201ba34: f2 26 20 04 st %i1, [ %i0 + 4 ] IMFS_update_atime( the_jnode ); 201ba38: 90 07 bf f0 add %fp, -16, %o0 201ba3c: 7f ff a1 ab call 20040e8 201ba40: 92 10 20 00 clr %o1 201ba44: c2 07 bf f0 ld [ %fp + -16 ], %g1 201ba48: 90 10 20 00 clr %o0 201ba4c: c2 24 20 3c st %g1, [ %l0 + 0x3c ] return 0; } 201ba50: 81 c7 e0 08 ret 201ba54: 91 e8 00 08 restore %g0, %o0, %o0 0201ba58 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 201ba58: 9d e3 bf 98 save %sp, -104, %sp IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 201ba5c: e0 06 20 2c ld [ %i0 + 0x2c ], %l0 if (the_jnode->type == IMFS_LINEAR_FILE) { 201ba60: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 201ba64: 80 a0 60 06 cmp %g1, 6 201ba68: 02 80 00 0d be 201ba9c 201ba6c: a2 10 00 18 mov %i0, %l1 if (iop->offset > the_jnode->info.linearfile.size) iop->offset = the_jnode->info.linearfile.size; } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 201ba70: d2 06 20 08 ld [ %i0 + 8 ], %o1 201ba74: 7f ff ff 82 call 201b87c 201ba78: 90 10 00 10 mov %l0, %o0 201ba7c: 80 a2 20 00 cmp %o0, 0 201ba80: 12 80 00 0f bne 201babc 201ba84: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 201ba88: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 201ba8c: f0 06 20 08 ld [ %i0 + 8 ], %i0 201ba90: c2 24 60 04 st %g1, [ %l1 + 4 ] } return iop->offset; } 201ba94: 81 c7 e0 08 ret 201ba98: 81 e8 00 00 restore IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; if (the_jnode->type == IMFS_LINEAR_FILE) { if (iop->offset > the_jnode->info.linearfile.size) 201ba9c: d0 04 20 4c ld [ %l0 + 0x4c ], %o0 <== NOT EXECUTED 201baa0: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 201baa4: 80 a6 00 08 cmp %i0, %o0 <== NOT EXECUTED 201baa8: 04 80 00 09 ble 201bacc <== NOT EXECUTED 201baac: 01 00 00 00 nop <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 201bab0: d0 24 60 08 st %o0, [ %l1 + 8 ] <== NOT EXECUTED 201bab4: 81 c7 e0 08 ret <== NOT EXECUTED 201bab8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) rtems_set_errno_and_return_minus_one( ENOSPC ); 201babc: 40 00 27 57 call 2025818 <__errno> <== NOT EXECUTED 201bac0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201bac4: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED 201bac8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201bacc: 81 c7 e0 08 ret <== NOT EXECUTED 201bad0: 81 e8 00 00 restore <== NOT EXECUTED 0201bdc4 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 201bdc4: 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)) 201bdc8: c4 06 20 0c ld [ %i0 + 0xc ], %g2 rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 201bdcc: 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)) 201bdd0: 80 88 a2 04 btst 0x204, %g2 201bdd4: 02 80 00 06 be 201bdec 201bdd8: e0 06 20 2c ld [ %i0 + 0x2c ], %l0 201bddc: c2 04 20 48 ld [ %l0 + 0x48 ], %g1 201bde0: 80 a0 60 06 cmp %g1, 6 201bde4: 22 80 00 0b be,a 201be10 201bde8: d6 04 20 4c ld [ %l0 + 0x4c ], %o3 <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; if ((count != 0) && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 201bdec: 80 88 a2 00 btst 0x200, %g2 201bdf0: 02 80 00 04 be 201be00 201bdf4: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 iop->offset = the_jnode->info.file.size; 201bdf8: c2 24 60 08 st %g1, [ %l1 + 8 ] iop->size = the_jnode->info.file.size; 201bdfc: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 201be00: b0 10 20 00 clr %i0 201be04: c2 24 60 04 st %g1, [ %l1 + 4 ] return 0; } 201be08: 81 c7 e0 08 ret 201be0c: 81 e8 00 00 restore * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; const unsigned char *buffer = the_jnode->info.linearfile.direct; 201be10: d4 04 20 50 ld [ %l0 + 0x50 ], %o2 <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 201be14: 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; 201be18: 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; 201be1c: 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; 201be20: 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; 201be24: 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) 201be28: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED 201be2c: 12 80 00 08 bne 201be4c <== NOT EXECUTED 201be30: c2 24 20 48 st %g1, [ %l0 + 0x48 ] <== NOT EXECUTED 201be34: c4 04 60 0c ld [ %l1 + 0xc ], %g2 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 201be38: 80 88 a2 00 btst 0x200, %g2 <== NOT EXECUTED 201be3c: 02 bf ff f1 be 201be00 <== NOT EXECUTED 201be40: c2 04 20 4c ld [ %l0 + 0x4c ], %g1 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 201be44: 10 bf ff ee b 201bdfc <== NOT EXECUTED 201be48: c2 24 60 08 st %g1, [ %l1 + 8 ] <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; the_jnode->info.file.size = 0; the_jnode->info.file.indirect = 0; the_jnode->info.file.doubly_indirect = 0; the_jnode->info.file.triply_indirect = 0; if ((count != 0) 201be4c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 201be50: 92 10 20 00 clr %o1 <== NOT EXECUTED 201be54: 7f ff ff 20 call 201bad4 <== NOT EXECUTED 201be58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201be5c: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 201be60: 02 bf ff ea be 201be08 <== NOT EXECUTED 201be64: 01 00 00 00 nop <== NOT EXECUTED 201be68: 10 bf ff f4 b 201be38 <== NOT EXECUTED 201be6c: c4 04 60 0c ld [ %l1 + 0xc ], %g2 <== NOT EXECUTED 0201c184 : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 201c184: 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 ); 201c188: d2 02 20 08 ld [ %o0 + 8 ], %o1 201c18c: d0 02 20 2c ld [ %o0 + 0x2c ], %o0 ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 201c190: 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 ); 201c194: 94 10 00 01 mov %g1, %o2 201c198: 82 13 c0 00 mov %o7, %g1 201c19c: 7f ff ff 35 call 201be70 201c1a0: 9e 10 40 00 mov %g1, %o7 201c1a4: 01 00 00 00 nop <== NOT EXECUTED 0201b730 : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 201b730: 9d e3 bf 90 save %sp, -112, %sp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 201b734: 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 ) { 201b738: c2 06 20 08 ld [ %i0 + 8 ], %g1 201b73c: 80 a0 60 00 cmp %g1, 0 201b740: 22 80 00 06 be,a 201b758 201b744: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 <== NOT EXECUTED Chain_Extract( (Chain_Node *) the_jnode ); 201b748: 7f ff fb 57 call 201a4a4 <_Chain_Extract> 201b74c: 90 10 00 18 mov %i0, %o0 the_jnode->Parent = NULL; 201b750: c0 26 20 08 clr [ %i0 + 8 ] /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 201b754: c2 16 20 30 lduh [ %i0 + 0x30 ], %g1 IMFS_update_ctime( the_jnode ); 201b758: 92 10 20 00 clr %o1 /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 201b75c: 82 00 7f ff add %g1, -1, %g1 IMFS_update_ctime( the_jnode ); 201b760: 90 07 bf f0 add %fp, -16, %o0 201b764: 7f ff a2 61 call 20040e8 201b768: c2 36 20 30 sth %g1, [ %i0 + 0x30 ] 201b76c: c2 07 bf f0 ld [ %fp + -16 ], %g1 return memfile_check_rmnod( the_jnode ); 201b770: 90 10 00 18 mov %i0, %o0 201b774: 7f ff ff d6 call 201b6cc 201b778: c2 26 20 44 st %g1, [ %i0 + 0x44 ] } 201b77c: 81 c7 e0 08 ret 201b780: 91 e8 00 08 restore %g0, %o0, %o0 0200b250 : int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { return IMFS_initialize_support( 200b250: 13 00 80 62 sethi %hi(0x2018800), %o1 200b254: 15 00 80 65 sethi %hi(0x2019400), %o2 200b258: 92 12 62 44 or %o1, 0x244, %o1 200b25c: 94 12 a0 6c or %o2, 0x6c, %o2 200b260: 96 10 00 0a mov %o2, %o3 200b264: 82 13 c0 00 mov %o7, %g1 200b268: 40 00 02 ac call 200bd18 200b26c: 9e 10 40 00 mov %g1, %o7 200b270: 01 00 00 00 nop <== NOT EXECUTED 02002730 : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 2002730: 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) ) ) 2002734: 03 00 00 3c sethi %hi(0xf000), %g1 2002738: b3 2e 60 10 sll %i1, 0x10, %i1 200273c: b3 36 60 10 srl %i1, 0x10, %i1 2002740: 84 8e 40 01 andcc %i1, %g1, %g2 2002744: 02 80 00 4e be 200287c 2002748: 03 00 00 04 sethi %hi(0x1000), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( S_ISFIFO(mode) ) 200274c: 80 a0 80 01 cmp %g2, %g1 2002750: 02 80 00 18 be 20027b0 2002754: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 2002758: c2 4e 00 00 ldsb [ %i0 ], %g1 200275c: 80 a0 60 2f cmp %g1, 0x2f 2002760: 02 80 00 1a be 20027c8 2002764: 80 a0 60 5c cmp %g1, 0x5c 2002768: 02 80 00 18 be 20027c8 200276c: 80 a0 60 00 cmp %g1, 0 2002770: 02 80 00 17 be 20027cc 2002774: 03 00 80 62 sethi %hi(0x2018800), %g1 2002778: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 200277c: 88 10 20 00 clr %g4 2002780: c2 00 e0 04 ld [ %g3 + 4 ], %g1 2002784: c2 27 bf e4 st %g1, [ %fp + -28 ] 2002788: c4 00 e0 08 ld [ %g3 + 8 ], %g2 200278c: c4 27 bf e8 st %g2, [ %fp + -24 ] 2002790: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 2002794: c2 27 bf ec st %g1, [ %fp + -20 ] if ( !temp_loc.ops->evalformake_h ) { 2002798: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( S_ISFIFO(mode) ) rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 200279c: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 if ( !temp_loc.ops->evalformake_h ) { 20027a0: c2 00 60 04 ld [ %g1 + 4 ], %g1 20027a4: 80 a0 60 00 cmp %g1, 0 20027a8: 12 80 00 17 bne 2002804 20027ac: c4 27 bf f0 st %g2, [ %fp + -16 ] if ( result != 0 ) return -1; if ( !temp_loc.ops->mknod_h ) { rtems_filesystem_freenode( &temp_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); 20027b0: 40 00 32 44 call 200f0c0 <__errno> 20027b4: b0 10 3f ff mov -1, %i0 20027b8: 82 10 20 86 mov 0x86, %g1 20027bc: c2 22 00 00 st %g1, [ %o0 ] 20027c0: 81 c7 e0 08 ret 20027c4: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); if ( S_ISFIFO(mode) ) rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 20027c8: 03 00 80 62 sethi %hi(0x2018800), %g1 20027cc: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 20027d0: 88 10 20 01 mov 1, %g4 20027d4: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 20027d8: c2 27 bf e4 st %g1, [ %fp + -28 ] 20027dc: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 20027e0: c4 27 bf e8 st %g2, [ %fp + -24 ] 20027e4: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 20027e8: c2 27 bf ec st %g1, [ %fp + -20 ] if ( !temp_loc.ops->evalformake_h ) { 20027ec: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( S_ISFIFO(mode) ) rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 20027f0: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 if ( !temp_loc.ops->evalformake_h ) { 20027f4: c2 00 60 04 ld [ %g1 + 4 ], %g1 20027f8: 80 a0 60 00 cmp %g1, 0 20027fc: 02 bf ff ed be 20027b0 2002800: c4 27 bf f0 st %g2, [ %fp + -16 ] rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 2002804: 90 06 00 04 add %i0, %g4, %o0 2002808: a0 07 bf e4 add %fp, -28, %l0 200280c: 94 07 bf f4 add %fp, -12, %o2 2002810: 92 10 00 10 mov %l0, %o1 2002814: 9f c0 40 00 call %g1 2002818: b0 10 3f ff mov -1, %i0 &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 200281c: 80 a2 20 00 cmp %o0, 0 2002820: 12 bf ff e8 bne 20027c0 2002824: c2 07 bf ec ld [ %fp + -20 ], %g1 return -1; if ( !temp_loc.ops->mknod_h ) { 2002828: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 200282c: 80 a0 a0 00 cmp %g2, 0 2002830: 02 80 00 19 be 2002894 2002834: d0 07 bf f4 ld [ %fp + -12 ], %o0 rtems_filesystem_freenode( &temp_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 2002838: 92 10 00 19 mov %i1, %o1 200283c: 94 10 00 1a mov %i2, %o2 2002840: 96 10 00 1b mov %i3, %o3 2002844: 9f c0 80 00 call %g2 2002848: 98 10 00 10 mov %l0, %o4 rtems_filesystem_freenode( &temp_loc ); 200284c: c2 07 bf ec ld [ %fp + -20 ], %g1 2002850: 80 a0 60 00 cmp %g1, 0 2002854: 02 bf ff db be 20027c0 2002858: b0 10 00 08 mov %o0, %i0 200285c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2002860: 80 a0 60 00 cmp %g1, 0 2002864: 02 80 00 0a be 200288c 2002868: 01 00 00 00 nop 200286c: 9f c0 40 00 call %g1 2002870: 90 10 00 10 mov %l0, %o0 return result; } 2002874: 81 c7 e0 08 ret 2002878: 81 e8 00 00 restore int i; const char *name_start; int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) rtems_set_errno_and_return_minus_one( EINVAL ); 200287c: 40 00 32 11 call 200f0c0 <__errno> <== NOT EXECUTED 2002880: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002884: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2002888: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200288c: 81 c7 e0 08 ret 2002890: 81 e8 00 00 restore ); if ( result != 0 ) return -1; if ( !temp_loc.ops->mknod_h ) { rtems_filesystem_freenode( &temp_loc ); 2002894: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2002898: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200289c: 02 bf ff c5 be 20027b0 <== NOT EXECUTED 20028a0: 01 00 00 00 nop <== NOT EXECUTED 20028a4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20028a8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20028ac: 30 bf ff c1 b,a 20027b0 <== NOT EXECUTED 0200c754 : rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, char *device, char *mount_point ) { 200c754: 9d e3 bf 88 save %sp, -120, %sp /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 200c758: 80 a6 60 00 cmp %i1, 0 200c75c: 02 80 00 8c be 200c98c 200c760: a4 10 00 18 mov %i0, %l2 /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 200c764: 80 a6 a0 01 cmp %i2, 1 200c768: 18 80 00 89 bgu 200c98c 200c76c: 01 00 00 00 nop errno = EINVAL; return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 200c770: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 200c774: 80 a0 60 00 cmp %g1, 0 200c778: 02 80 00 4c be 200c8a8 200c77c: 80 a6 e0 00 cmp %i3, 0 /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 200c780: 02 80 00 05 be 200c794 200c784: 90 10 20 64 mov 0x64, %o0 size += strlen( device ) + 1; 200c788: 40 00 0f 2c call 2010438 <== NOT EXECUTED 200c78c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 200c790: 90 02 20 65 add %o0, 0x65, %o0 <== NOT EXECUTED temp_mt_entry = malloc( size ); 200c794: 7f ff d7 02 call 200239c 200c798: 01 00 00 00 nop if ( !temp_mt_entry ) { 200c79c: a2 92 20 00 orcc %o0, 0, %l1 200c7a0: 02 80 00 95 be 200c9f4 200c7a4: a0 10 00 11 mov %l1, %l0 errno = ENOMEM; return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; temp_mt_entry->options = options; 200c7a8: f4 24 60 28 st %i2, [ %l1 + 0x28 ] if ( device ) { 200c7ac: 80 a6 e0 00 cmp %i3, 0 200c7b0: 02 80 00 47 be 200c8cc 200c7b4: e2 24 20 24 st %l1, [ %l0 + 0x24 ] temp_mt_entry->dev = 200c7b8: 90 04 60 64 add %l1, 0x64, %o0 <== NOT EXECUTED (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); strcpy( temp_mt_entry->dev, device ); 200c7bc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 200c7c0: 40 00 0e fe call 20103b8 <== NOT EXECUTED 200c7c4: d0 24 60 60 st %o0, [ %l1 + 0x60 ] <== NOT EXECUTED /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 200c7c8: 80 a7 20 00 cmp %i4, 0 200c7cc: 02 80 00 20 be 200c84c 200c7d0: 90 10 00 1c mov %i4, %o0 if ( rtems_filesystem_evaluate_path( 200c7d4: 92 10 20 07 mov 7, %o1 200c7d8: b8 07 bf e8 add %fp, -24, %i4 200c7dc: 96 10 20 01 mov 1, %o3 200c7e0: 7f ff d6 2e call 2002098 200c7e4: 94 10 00 1c mov %i4, %o2 200c7e8: 80 a2 3f ff cmp %o0, -1 200c7ec: 02 80 00 33 be 200c8b8 200c7f0: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 200c7f4: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 200c7f8: 80 a0 60 00 cmp %g1, 0 200c7fc: 02 80 00 5a be 200c964 200c800: 01 00 00 00 nop /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 200c804: 9f c0 40 00 call %g1 200c808: 90 10 00 1c mov %i4, %o0 200c80c: 80 a2 20 01 cmp %o0, 1 200c810: 02 80 00 31 be 200c8d4 200c814: 03 00 80 67 sethi %hi(0x2019c00), %g1 errno = ENOTDIR; 200c818: 40 00 0a 2a call 200f0c0 <__errno> 200c81c: 01 00 00 00 nop 200c820: 82 10 20 14 mov 0x14, %g1 ! 14 200c824: c2 22 00 00 st %g1, [ %o0 ] return 0; cleanup_and_bail: free( temp_mt_entry ); 200c828: 90 10 00 11 mov %l1, %o0 200c82c: 7f ff d6 b3 call 20022f8 200c830: a0 10 00 1c mov %i4, %l0 if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 200c834: c2 04 20 08 ld [ %l0 + 8 ], %g1 200c838: 80 a0 60 00 cmp %g1, 0 200c83c: 32 80 00 5a bne,a 200c9a4 200c840: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200c844: 81 c7 e0 08 ret <== NOT EXECUTED 200c848: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED * This is a mount of the base file system --> The * mt_point_node.node_access will be set to null to indicate that this * is the root of the entire file system. */ temp_mt_entry->mt_fs_root.node_access = NULL; 200c84c: c0 24 60 18 clr [ %l1 + 0x18 ] temp_mt_entry->mt_fs_root.handlers = NULL; 200c850: c0 24 60 1c clr [ %l1 + 0x1c ] temp_mt_entry->mt_fs_root.ops = NULL; 200c854: c0 24 60 20 clr [ %l1 + 0x20 ] temp_mt_entry->mt_point_node.node_access = NULL; 200c858: c0 24 60 08 clr [ %l1 + 8 ] temp_mt_entry->mt_point_node.handlers = NULL; 200c85c: c0 24 60 0c clr [ %l1 + 0xc ] temp_mt_entry->mt_point_node.ops = NULL; 200c860: c0 24 60 10 clr [ %l1 + 0x10 ] temp_mt_entry->mt_point_node.mt_entry = NULL; 200c864: c0 24 60 14 clr [ %l1 + 0x14 ] 200c868: a0 10 20 00 clr %l0 } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 200c86c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 200c870: 9f c0 40 00 call %g1 200c874: 90 10 00 11 mov %l1, %o0 200c878: 80 a2 20 00 cmp %o0, 0 200c87c: 12 80 00 51 bne 200c9c0 200c880: 11 00 80 67 sethi %hi(0x2019c00), %o0 /* * Add the mount table entry to the mount table chain */ Chain_Append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); 200c884: 92 10 00 11 mov %l1, %o1 200c888: 7f ff e9 50 call 2006dc8 <_Chain_Append> 200c88c: 90 12 22 c8 or %o0, 0x2c8, %o0 if ( mt_entry ) 200c890: 80 a4 a0 00 cmp %l2, 0 200c894: 02 80 00 03 be 200c8a0 200c898: b0 10 20 00 clr %i0 *mt_entry = temp_mt_entry; 200c89c: e2 24 80 00 st %l1, [ %l2 ] 200c8a0: 81 c7 e0 08 ret 200c8a4: 81 e8 00 00 restore return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { errno = ENOTSUP; 200c8a8: 40 00 0a 06 call 200f0c0 <__errno> <== NOT EXECUTED 200c8ac: a0 10 20 00 clr %l0 <== NOT EXECUTED 200c8b0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 200c8b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 200c8b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200c8bc: 7f ff d6 8f call 20022f8 <== NOT EXECUTED 200c8c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 200c8c4: 81 c7 e0 08 ret <== NOT EXECUTED 200c8c8: 81 e8 00 00 restore <== 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; 200c8cc: 10 bf ff bf b 200c7c8 200c8d0: c0 24 60 60 clr [ %l1 + 0x60 ] /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 200c8d4: c4 00 62 c8 ld [ %g1 + 0x2c8 ], %g2 200c8d8: 82 10 62 c8 or %g1, 0x2c8, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 200c8dc: 88 00 60 04 add %g1, 4, %g4 !Chain_Is_tail( &rtems_filesystem_mount_table_control, the_node ); 200c8e0: 80 a0 80 04 cmp %g2, %g4 200c8e4: 02 80 00 0e be 200c91c 200c8e8: c6 07 bf e8 ld [ %fp + -24 ], %g3 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 ) 200c8ec: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 200c8f0: 80 a0 40 03 cmp %g1, %g3 200c8f4: 32 80 00 07 bne,a 200c910 200c8f8: c4 00 80 00 ld [ %g2 ], %g2 200c8fc: 30 80 00 1f b,a 200c978 <== NOT EXECUTED 200c900: 80 a0 40 03 cmp %g1, %g3 200c904: 02 80 00 1d be 200c978 200c908: 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 ) { 200c90c: 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 ); 200c910: 80 a0 80 04 cmp %g2, %g4 200c914: 32 bf ff fb bne,a 200c900 200c918: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 * 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; 200c91c: c2 07 bf f0 ld [ %fp + -16 ], %g1 * 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; 200c920: c6 24 60 08 st %g3, [ %l1 + 8 ] temp_mt_entry->mt_point_node.handlers = loc.handlers; 200c924: c4 07 bf ec ld [ %fp + -20 ], %g2 temp_mt_entry->mt_point_node.ops = loc.ops; temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 200c928: c6 07 bf f4 ld [ %fp + -12 ], %g3 /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ 200c92c: c8 00 60 20 ld [ %g1 + 0x20 ], %g4 * 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; 200c930: c4 24 60 0c st %g2, [ %l1 + 0xc ] temp_mt_entry->mt_point_node.ops = loc.ops; temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 200c934: c6 24 60 14 st %g3, [ %l1 + 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 ){ 200c938: 80 a1 20 00 cmp %g4, 0 200c93c: 02 80 00 0a be 200c964 200c940: c2 24 60 10 st %g1, [ %l1 + 0x10 ] errno = ENOTSUP; goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 200c944: 90 10 00 11 mov %l1, %o0 200c948: 9f c1 00 00 call %g4 200c94c: a0 10 00 1c mov %i4, %l0 200c950: 80 a2 20 00 cmp %o0, 0 200c954: 22 bf ff c7 be,a 200c870 200c958: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 return 0; cleanup_and_bail: free( temp_mt_entry ); 200c95c: 10 bf ff b4 b 200c82c <== NOT EXECUTED 200c960: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ errno = ENOTSUP; 200c964: 40 00 09 d7 call 200f0c0 <__errno> <== NOT EXECUTED 200c968: 01 00 00 00 nop <== NOT EXECUTED 200c96c: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 200c970: 10 bf ff ae b 200c828 <== NOT EXECUTED 200c974: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 200c978: 40 00 09 d2 call 200f0c0 <__errno> 200c97c: 01 00 00 00 nop 200c980: 82 10 20 10 mov 0x10, %g1 ! 10 200c984: 10 bf ff a9 b 200c828 200c988: c2 22 00 00 st %g1, [ %o0 ] * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 200c98c: 40 00 09 cd call 200f0c0 <__errno> 200c990: b0 10 3f ff mov -1, %i0 200c994: 82 10 20 16 mov 0x16, %g1 200c998: c2 22 00 00 st %g1, [ %o0 ] 200c99c: 81 c7 e0 08 ret 200c9a0: 81 e8 00 00 restore cleanup_and_bail: free( temp_mt_entry ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 200c9a4: 80 a0 60 00 cmp %g1, 0 200c9a8: 02 bf ff a7 be 200c844 200c9ac: 90 10 00 10 mov %l0, %o0 200c9b0: 9f c0 40 00 call %g1 200c9b4: b0 10 3f ff mov -1, %i0 200c9b8: 81 c7 e0 08 ret 200c9bc: 81 e8 00 00 restore temp_mt_entry->mt_point_node.mt_entry = NULL; } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 200c9c0: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 200c9c4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1 <== NOT EXECUTED 200c9c8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200c9cc: 02 80 00 04 be 200c9dc <== NOT EXECUTED 200c9d0: 01 00 00 00 nop <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 200c9d4: 9f c0 40 00 call %g1 <== NOT EXECUTED 200c9d8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 200c9dc: 7f ff d6 47 call 20022f8 <== NOT EXECUTED 200c9e0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if ( loc_to_free ) 200c9e4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 200c9e8: 32 bf ff 94 bne,a 200c838 <== NOT EXECUTED 200c9ec: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED 200c9f0: 30 bf ff 95 b,a 200c844 <== NOT EXECUTED if ( device ) size += strlen( device ) + 1; temp_mt_entry = malloc( size ); if ( !temp_mt_entry ) { errno = ENOMEM; 200c9f4: 40 00 09 b3 call 200f0c0 <__errno> <== NOT EXECUTED 200c9f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200c9fc: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED 200ca00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200ca04: 81 c7 e0 08 ret <== NOT EXECUTED 200ca08: 81 e8 00 00 restore <== NOT EXECUTED 02009e60 : */ int mq_close( mqd_t mqdes ) { 2009e60: 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 *) 2009e64: 21 00 80 94 sethi %hi(0x2025000), %l0 2009e68: 92 10 00 18 mov %i0, %o1 2009e6c: 94 07 bf f4 add %fp, -12, %o2 2009e70: 40 00 13 ea call 200ee18 <_Objects_Get> 2009e74: 90 14 22 a0 or %l0, 0x2a0, %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 ) { 2009e78: c2 07 bf f4 ld [ %fp + -12 ], %g1 2009e7c: 80 a0 60 01 cmp %g1, 1 2009e80: 02 80 00 2e be 2009f38 2009e84: b0 10 00 08 mov %o0, %i0 2009e88: 80 a0 60 01 cmp %g1, 1 2009e8c: 2a 80 00 09 bcs,a 2009eb0 2009e90: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 2009e94: 80 a0 60 02 cmp %g1, 2 2009e98: 02 80 00 2e be 2009f50 2009e9c: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2009ea0: 40 00 08 80 call 200c0a0 <== NOT EXECUTED 2009ea4: 01 00 00 00 nop <== NOT EXECUTED } 2009ea8: 81 c7 e0 08 ret <== NOT EXECUTED 2009eac: 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; 2009eb0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 _POSIX_Message_queue_Delete( the_mq ); 2009eb4: 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; 2009eb8: 82 00 7f ff add %g1, -1, %g1 _POSIX_Message_queue_Delete( the_mq ); 2009ebc: 40 00 00 2c call 2009f6c <_POSIX_Message_queue_Delete> 2009ec0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009ec4: 90 14 22 a0 or %l0, 0x2a0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2009ec8: c4 06 20 08 ld [ %i0 + 8 ], %g2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2009ecc: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2009ed0: 03 00 00 3f sethi %hi(0xfc00), %g1 2009ed4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2009ed8: 82 08 80 01 and %g2, %g1, %g1 2009edc: 80 a0 40 03 cmp %g1, %g3 2009ee0: 38 80 00 06 bgu,a 2009ef8 2009ee4: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2009ee8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2009eec: 83 28 60 02 sll %g1, 2, %g1 2009ef0: 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; 2009ef4: 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 ); 2009ef8: 40 00 13 85 call 200ed0c <_Objects_Free> 2009efc: 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 ) 2009f00: 03 00 80 93 sethi %hi(0x2024c00), %g1 2009f04: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 2009f08: 90 10 20 00 clr %o0 2009f0c: 84 00 bf ff add %g2, -1, %g2 2009f10: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 2009f14: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 2009f18: 80 a0 e0 00 cmp %g3, 0 2009f1c: 12 bf ff e3 bne 2009ea8 2009f20: 01 00 00 00 nop _Thread_Dispatch(); 2009f24: 40 00 18 b5 call 20101f8 <_Thread_Dispatch> 2009f28: 01 00 00 00 nop 2009f2c: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009f30: 81 c7 e0 08 ret 2009f34: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2009f38: 40 00 18 b0 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 2009f3c: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2009f40: 40 00 08 62 call 200c0c8 <== NOT EXECUTED 2009f44: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009f48: 81 c7 e0 08 ret <== NOT EXECUTED 2009f4c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 2009f50: 40 00 32 5b call 20168bc <__errno> 2009f54: 01 00 00 00 nop 2009f58: 82 10 20 09 mov 9, %g1 ! 9 2009f5c: c2 22 00 00 st %g1, [ %o0 ] 2009f60: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2009f64: 81 c7 e0 08 ret 2009f68: 91 e8 00 08 restore %g0, %o0, %o0 02009ffc : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 2009ffc: 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 ) 200a000: 80 a6 60 00 cmp %i1, 0 200a004: 02 80 00 36 be 200a0dc 200a008: 92 10 00 18 mov %i0, %o1 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 *) 200a00c: 11 00 80 94 sethi %hi(0x2025000), %o0 200a010: 94 07 bf f4 add %fp, -12, %o2 200a014: 40 00 13 81 call 200ee18 <_Objects_Get> 200a018: 90 12 22 a0 or %o0, 0x2a0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a01c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a020: 80 a0 60 01 cmp %g1, 1 200a024: 02 80 00 28 be 200a0c4 200a028: 01 00 00 00 nop 200a02c: 2a 80 00 09 bcs,a 200a050 200a030: c6 02 20 10 ld [ %o0 + 0x10 ], %g3 200a034: 80 a0 60 02 cmp %g1, 2 200a038: 02 80 00 1c be 200a0a8 200a03c: 01 00 00 00 nop mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200a040: 40 00 08 18 call 200c0a0 <== NOT EXECUTED 200a044: 01 00 00 00 nop <== NOT EXECUTED } 200a048: 81 c7 e0 08 ret 200a04c: 91 e8 00 08 restore %g0, %o0, %o0 * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 200a050: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 200a054: c4 26 40 00 st %g2, [ %i1 ] mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 200a058: c2 00 e0 6c ld [ %g3 + 0x6c ], %g1 200a05c: c2 26 60 08 st %g1, [ %i1 + 8 ] mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 200a060: c4 00 e0 64 ld [ %g3 + 0x64 ], %g2 200a064: c4 26 60 04 st %g2, [ %i1 + 4 ] mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 200a068: c2 00 e0 68 ld [ %g3 + 0x68 ], %g1 200a06c: 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 ) 200a070: 07 00 80 93 sethi %hi(0x2024c00), %g3 200a074: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a078: 90 10 20 00 clr %o0 200a07c: 82 00 7f ff add %g1, -1, %g1 200a080: c2 20 e0 d0 st %g1, [ %g3 + 0xd0 ] 200a084: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2 200a088: 80 a0 a0 00 cmp %g2, 0 200a08c: 12 bf ff ef bne 200a048 200a090: 01 00 00 00 nop _Thread_Dispatch(); 200a094: 40 00 18 59 call 20101f8 <_Thread_Dispatch> 200a098: 01 00 00 00 nop 200a09c: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a0a0: 81 c7 e0 08 ret 200a0a4: 91 e8 00 08 restore %g0, %o0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a0a8: 40 00 32 05 call 20168bc <__errno> 200a0ac: 01 00 00 00 nop 200a0b0: 82 10 20 09 mov 9, %g1 ! 9 200a0b4: c2 22 00 00 st %g1, [ %o0 ] 200a0b8: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a0bc: 81 c7 e0 08 ret 200a0c0: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200a0c4: 40 00 18 4d call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a0c8: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a0cc: 40 00 07 ff call 200c0c8 <== NOT EXECUTED 200a0d0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a0d4: 81 c7 e0 08 ret <== NOT EXECUTED 200a0d8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 200a0dc: 40 00 31 f8 call 20168bc <__errno> 200a0e0: 01 00 00 00 nop 200a0e4: 82 10 20 16 mov 0x16, %g1 ! 16 200a0e8: c2 22 00 00 st %g1, [ %o0 ] 200a0ec: 10 bf ff d7 b 200a048 200a0f0: 90 10 3f ff mov -1, %o0 0200a118 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 200a118: 9d e3 bf 90 save %sp, -112, %sp 200a11c: 11 00 80 94 sethi %hi(0x2025000), %o0 200a120: 92 10 00 18 mov %i0, %o1 200a124: 90 12 22 a0 or %o0, 0x2a0, %o0 200a128: 40 00 13 3c call 200ee18 <_Objects_Get> 200a12c: 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 ) { 200a130: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a134: 80 a0 60 01 cmp %g1, 1 200a138: 02 80 00 2e be 200a1f0 200a13c: 01 00 00 00 nop 200a140: 0a 80 00 09 bcs 200a164 200a144: 80 a6 60 00 cmp %i1, 0 200a148: 80 a0 60 02 cmp %g1, 2 200a14c: 02 80 00 2f be 200a208 200a150: 01 00 00 00 nop } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200a154: 40 00 07 d3 call 200c0a0 <== NOT EXECUTED 200a158: 01 00 00 00 nop <== NOT EXECUTED } 200a15c: 81 c7 e0 08 ret 200a160: 91 e8 00 08 restore %g0, %o0, %o0 return POSIX_MP_NOT_IMPLEMENTED(); rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { 200a164: 02 80 00 3e be 200a25c 200a168: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 200a16c: c2 02 20 80 ld [ %o0 + 0x80 ], %g1 200a170: 80 a0 60 00 cmp %g1, 0 200a174: 12 80 00 2c bne 200a224 200a178: 01 00 00 00 nop the_message_queue->notify_argument = the_argument; 200a17c: c0 22 20 84 clr [ %o0 + 0x84 ] rtems_set_errno_and_return_minus_one( EBUSY ); } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 200a180: c2 06 40 00 ld [ %i1 ], %g1 200a184: c2 22 20 94 st %g1, [ %o0 + 0x94 ] 200a188: c4 06 60 04 ld [ %i1 + 4 ], %g2 CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 200a18c: 03 00 80 28 sethi %hi(0x200a000), %g1 200a190: c4 22 20 98 st %g2, [ %o0 + 0x98 ] 200a194: c6 06 60 08 ld [ %i1 + 8 ], %g3 200a198: 82 10 60 f4 or %g1, 0xf4, %g1 200a19c: c6 22 20 9c st %g3, [ %o0 + 0x9c ] 200a1a0: c2 22 20 80 st %g1, [ %o0 + 0x80 ] 200a1a4: c2 06 60 0c ld [ %i1 + 0xc ], %g1 200a1a8: c2 22 20 a0 st %g1, [ %o0 + 0xa0 ] 200a1ac: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 the_message_queue->notify_argument = the_argument; 200a1b0: d0 22 20 84 st %o0, [ %o0 + 0x84 ] 200a1b4: c4 22 20 a4 st %g2, [ %o0 + 0xa4 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a1b8: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a1bc: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a1c0: 90 10 20 00 clr %o0 200a1c4: 84 00 bf ff add %g2, -1, %g2 200a1c8: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a1cc: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a1d0: 80 a0 e0 00 cmp %g3, 0 200a1d4: 12 bf ff e2 bne 200a15c 200a1d8: 01 00 00 00 nop _Thread_Dispatch(); 200a1dc: 40 00 18 07 call 20101f8 <_Thread_Dispatch> 200a1e0: 01 00 00 00 nop 200a1e4: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a1e8: 81 c7 e0 08 ret 200a1ec: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200a1f0: 40 00 18 02 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a1f4: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a1f8: 40 00 07 b4 call 200c0c8 <== NOT EXECUTED 200a1fc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a200: 81 c7 e0 08 ret <== NOT EXECUTED 200a204: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a208: 40 00 31 ad call 20168bc <__errno> 200a20c: 01 00 00 00 nop 200a210: 82 10 20 09 mov 9, %g1 ! 9 200a214: c2 22 00 00 st %g1, [ %o0 ] 200a218: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a21c: 81 c7 e0 08 ret 200a220: 91 e8 00 08 restore %g0, %o0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a224: 03 00 80 93 sethi %hi(0x2024c00), %g1 200a228: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a22c: 84 00 bf ff add %g2, -1, %g2 200a230: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] 200a234: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 200a238: 80 a0 e0 00 cmp %g3, 0 200a23c: 02 80 00 0b be 200a268 200a240: 01 00 00 00 nop the_mq = the_mq_fd->Queue; if ( notification ) { if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBUSY ); 200a244: 40 00 31 9e call 20168bc <__errno> 200a248: 01 00 00 00 nop 200a24c: 82 10 20 10 mov 0x10, %g1 ! 10 200a250: c2 22 00 00 st %g1, [ %o0 ] 200a254: 10 bf ff c2 b 200a15c 200a258: 90 10 3f ff mov -1, %o0 200a25c: c0 22 20 84 clr [ %o0 + 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; 200a260: 10 bf ff d6 b 200a1b8 200a264: c0 22 20 80 clr [ %o0 + 0x80 ] _Thread_Dispatch(); 200a268: 40 00 17 e4 call 20101f8 <_Thread_Dispatch> 200a26c: 01 00 00 00 nop 200a270: 30 bf ff f5 b,a 200a244 0200a274 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 200a274: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200a278: 21 00 80 93 sethi %hi(0x2024c00), %l0 200a27c: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a280: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 200a284: 82 00 60 01 inc %g1 200a288: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 200a28c: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 200a290: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 200a294: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a298: a2 10 00 18 mov %i0, %l1 POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 200a29c: ba 8e 62 00 andcc %i1, 0x200, %i5 200a2a0: 12 80 00 16 bne 200a2f8 200a2a4: f4 07 a0 50 ld [ %fp + 0x50 ], %i2 200a2a8: b4 10 20 00 clr %i2 */ RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd * _POSIX_Message_queue_Allocate_fd( void ) { return (POSIX_Message_queue_Control_fd *) 200a2ac: 39 00 80 94 sethi %hi(0x2025000), %i4 200a2b0: 40 00 11 89 call 200e8d4 <_Objects_Allocate> 200a2b4: 90 17 22 a0 or %i4, 0x2a0, %o0 ! 20252a0 <_POSIX_Message_queue_Information_fds> attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { 200a2b8: b0 92 20 00 orcc %o0, 0, %i0 200a2bc: 32 80 00 1a bne,a 200a324 200a2c0: f2 26 20 14 st %i1, [ %i0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a2c4: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200a2c8: 82 00 7f ff add %g1, -1, %g1 200a2cc: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a2d0: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200a2d4: 80 a0 a0 00 cmp %g2, 0 200a2d8: 02 80 00 0b be 200a304 200a2dc: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 200a2e0: 40 00 31 77 call 20168bc <__errno> <== NOT EXECUTED 200a2e4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200a2e8: 82 10 20 17 mov 0x17, %g1 <== NOT EXECUTED 200a2ec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200a2f0: 81 c7 e0 08 ret <== NOT EXECUTED 200a2f4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); attr = (struct mq_attr *) va_arg( arg, struct mq_attr * ); 200a2f8: 82 07 a0 54 add %fp, 0x54, %g1 200a2fc: 10 bf ff ec b 200a2ac 200a300: c2 27 bf f4 st %g1, [ %fp + -12 ] _Thread_Dispatch(); 200a304: 40 00 17 bd call 20101f8 <_Thread_Dispatch> 200a308: b0 10 3f ff mov -1, %i0 } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); 200a30c: 40 00 31 6c call 20168bc <__errno> 200a310: 01 00 00 00 nop 200a314: 82 10 20 17 mov 0x17, %g1 ! 17 200a318: c2 22 00 00 st %g1, [ %o0 ] 200a31c: 81 c7 e0 08 ret 200a320: 81 e8 00 00 restore } the_mq_fd->oflag = oflag; status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 200a324: 90 10 00 11 mov %l1, %o0 200a328: 40 00 26 b3 call 2013df4 <_POSIX_Message_queue_Name_to_id> 200a32c: 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 ) { 200a330: b6 92 20 00 orcc %o0, 0, %i3 200a334: 02 80 00 14 be 200a384 200a338: 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) ) ) { 200a33c: 80 a6 e0 02 cmp %i3, 2 200a340: 02 80 00 51 be 200a484 200a344: 80 a7 60 00 cmp %i5, 0 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 ); 200a348: 90 17 22 a0 or %i4, 0x2a0, %o0 200a34c: 40 00 12 70 call 200ed0c <_Objects_Free> 200a350: 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 ) 200a354: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200a358: 82 00 7f ff add %g1, -1, %g1 200a35c: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a360: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200a364: 80 a0 a0 00 cmp %g2, 0 200a368: 02 80 00 1a be 200a3d0 200a36c: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 200a370: 40 00 31 53 call 20168bc <__errno> 200a374: b0 10 3f ff mov -1, %i0 ! ffffffff 200a378: f6 22 00 00 st %i3, [ %o0 ] 200a37c: 81 c7 e0 08 ret 200a380: 81 e8 00 00 restore /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 200a384: 80 a0 6a 00 cmp %g1, 0xa00 200a388: 12 80 00 18 bne 200a3e8 200a38c: d2 07 bf f0 ld [ %fp + -16 ], %o1 200a390: 90 17 22 a0 or %i4, 0x2a0, %o0 200a394: 40 00 12 5e call 200ed0c <_Objects_Free> 200a398: 92 10 00 18 mov %i0, %o1 200a39c: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200a3a0: 82 00 7f ff add %g1, -1, %g1 200a3a4: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a3a8: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200a3ac: 80 a0 a0 00 cmp %g2, 0 200a3b0: 02 80 00 0b be 200a3dc 200a3b4: 01 00 00 00 nop _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 200a3b8: 40 00 31 41 call 20168bc <__errno> 200a3bc: b0 10 3f ff mov -1, %i0 ! ffffffff 200a3c0: 82 10 20 11 mov 0x11, %g1 200a3c4: c2 22 00 00 st %g1, [ %o0 ] 200a3c8: 81 c7 e0 08 ret 200a3cc: 81 e8 00 00 restore _Thread_Dispatch(); 200a3d0: 40 00 17 8a call 20101f8 <_Thread_Dispatch> 200a3d4: 01 00 00 00 nop 200a3d8: 30 bf ff e6 b,a 200a370 200a3dc: 40 00 17 87 call 20101f8 <_Thread_Dispatch> 200a3e0: 01 00 00 00 nop 200a3e4: 30 bf ff f5 b,a 200a3b8 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Message_queue_Control *) 200a3e8: 11 00 80 94 sethi %hi(0x2025000), %o0 <== NOT EXECUTED 200a3ec: 94 07 bf e8 add %fp, -24, %o2 <== NOT EXECUTED 200a3f0: 40 00 12 8a call 200ee18 <_Objects_Get> <== NOT EXECUTED 200a3f4: 90 12 20 e8 or %o0, 0xe8, %o0 <== 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; 200a3f8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== 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 ); 200a3fc: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED the_mq->open_count += 1; 200a400: 82 00 60 01 inc %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200a404: 88 17 22 a0 or %i4, 0x2a0, %g4 <== NOT EXECUTED 200a408: c2 22 20 1c st %g1, [ %o0 + 0x1c ] <== NOT EXECUTED 200a40c: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200a410: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200a414: 03 00 00 3f sethi %hi(0xfc00), %g1 <== NOT EXECUTED 200a418: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <== NOT EXECUTED 200a41c: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED 200a420: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200a424: 18 80 00 05 bgu 200a438 <== NOT EXECUTED 200a428: d0 26 20 10 st %o0, [ %i0 + 0x10 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200a42c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 <== NOT EXECUTED 200a430: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200a434: f0 20 80 01 st %i0, [ %g2 + %g1 ] <== NOT EXECUTED 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; 200a438: c0 26 20 0c clr [ %i0 + 0xc ] <== 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 ) 200a43c: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 <== NOT EXECUTED 200a440: 23 00 80 93 sethi %hi(0x2024c00), %l1 <== NOT EXECUTED 200a444: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200a448: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] <== NOT EXECUTED 200a44c: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 <== NOT EXECUTED 200a450: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200a454: 02 80 00 28 be 200a4f4 <== NOT EXECUTED 200a458: 01 00 00 00 nop <== NOT EXECUTED 200a45c: c2 04 60 d0 ld [ %l1 + 0xd0 ], %g1 <== NOT EXECUTED 200a460: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200a464: c2 24 60 d0 st %g1, [ %l1 + 0xd0 ] <== NOT EXECUTED 200a468: c4 04 60 d0 ld [ %l1 + 0xd0 ], %g2 <== NOT EXECUTED 200a46c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200a470: 02 80 00 1c be 200a4e0 <== NOT EXECUTED 200a474: 01 00 00 00 nop <== NOT EXECUTED &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); return (mqd_t)the_mq_fd->Object.id; 200a478: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 200a47c: 81 c7 e0 08 ret <== NOT EXECUTED 200a480: 81 e8 00 00 restore <== NOT EXECUTED /* * 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) ) ) { 200a484: 02 bf ff b2 be 200a34c 200a488: 90 17 22 a0 or %i4, 0x2a0, %o0 /* * 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( 200a48c: 90 10 00 11 mov %l1, %o0 200a490: 94 10 00 1a mov %i2, %o2 200a494: 92 10 20 01 mov 1, %o1 200a498: 40 00 25 bf call 2013b94 <_POSIX_Message_queue_Create_support> 200a49c: 96 07 bf ec add %fp, -20, %o3 /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 200a4a0: 80 a2 3f ff cmp %o0, -1 200a4a4: 12 80 00 1b bne 200a510 200a4a8: c4 07 bf ec ld [ %fp + -20 ], %g2 200a4ac: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200a4b0: 82 00 7f ff add %g1, -1, %g1 200a4b4: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a4b8: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200a4bc: 80 a0 a0 00 cmp %g2, 0 200a4c0: 02 80 00 10 be 200a500 200a4c4: 01 00 00 00 nop 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 ); 200a4c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200a4cc: 90 17 22 a0 or %i4, 0x2a0, %o0 200a4d0: 40 00 12 0f call 200ed0c <_Objects_Free> 200a4d4: b0 10 3f ff mov -1, %i0 200a4d8: 81 c7 e0 08 ret 200a4dc: 81 e8 00 00 restore _Thread_Dispatch(); 200a4e0: 40 00 17 46 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a4e4: 01 00 00 00 nop <== NOT EXECUTED 200a4e8: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED 200a4ec: 81 c7 e0 08 ret <== NOT EXECUTED 200a4f0: 81 e8 00 00 restore <== NOT EXECUTED 200a4f4: 40 00 17 41 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a4f8: 01 00 00 00 nop <== NOT EXECUTED 200a4fc: 30 bf ff d8 b,a 200a45c <== NOT EXECUTED 200a500: 40 00 17 3e call 20101f8 <_Thread_Dispatch> 200a504: 01 00 00 00 nop 200a508: 10 bf ff f1 b 200a4cc 200a50c: 92 10 00 18 mov %i0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200a510: 90 17 22 a0 or %i4, 0x2a0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200a514: c6 06 20 08 ld [ %i0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200a518: c8 12 20 10 lduh [ %o0 + 0x10 ], %g4 200a51c: 03 00 00 3f sethi %hi(0xfc00), %g1 200a520: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200a524: 82 08 c0 01 and %g3, %g1, %g1 200a528: 80 a0 40 04 cmp %g1, %g4 200a52c: 18 80 00 05 bgu 200a540 200a530: c4 26 20 10 st %g2, [ %i0 + 0x10 ] information->local_table[ index ] = the_object; 200a534: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200a538: 83 28 60 02 sll %g1, 2, %g1 200a53c: f0 20 80 01 st %i0, [ %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; 200a540: c0 26 20 0c clr [ %i0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200a544: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200a548: 82 00 7f ff add %g1, -1, %g1 200a54c: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200a550: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200a554: 80 a0 a0 00 cmp %g2, 0 200a558: 32 bf ff 66 bne,a 200a2f0 200a55c: f0 06 20 08 ld [ %i0 + 8 ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 200a560: 40 00 17 26 call 20101f8 <_Thread_Dispatch> 200a564: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; 200a568: f0 06 20 08 ld [ %i0 + 8 ], %i0 } 200a56c: 81 c7 e0 08 ret 200a570: 81 e8 00 00 restore 0200a900 : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 200a900: 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 ) 200a904: 80 a6 60 00 cmp %i1, 0 200a908: 02 80 00 3a be 200a9f0 200a90c: 92 10 00 18 mov %i0, %o1 200a910: 11 00 80 94 sethi %hi(0x2025000), %o0 200a914: 94 07 bf f4 add %fp, -12, %o2 200a918: 40 00 11 40 call 200ee18 <_Objects_Get> 200a91c: 90 12 22 a0 or %o0, 0x2a0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a920: c2 07 bf f4 ld [ %fp + -12 ], %g1 200a924: 80 a0 60 01 cmp %g1, 1 200a928: 02 80 00 2c be 200a9d8 200a92c: 01 00 00 00 nop 200a930: 1a 80 00 1d bcc 200a9a4 200a934: 80 a0 60 02 cmp %g1, 2 /* * Return the old values. */ if ( omqstat ) { 200a938: 80 a6 a0 00 cmp %i2, 0 200a93c: 02 80 00 0a be 200a964 200a940: c6 02 20 10 ld [ %o0 + 0x10 ], %g3 omqstat->mq_flags = the_mq_fd->oflag; 200a944: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200a948: c2 26 80 00 st %g1, [ %i2 ] omqstat->mq_msgsize = the_core_mq->maximum_message_size; 200a94c: c4 00 e0 6c ld [ %g3 + 0x6c ], %g2 200a950: c4 26 a0 08 st %g2, [ %i2 + 8 ] omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 200a954: c2 00 e0 64 ld [ %g3 + 0x64 ], %g1 200a958: c2 26 a0 04 st %g1, [ %i2 + 4 ] omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 200a95c: c4 00 e0 68 ld [ %g3 + 0x68 ], %g2 200a960: c4 26 a0 0c st %g2, [ %i2 + 0xc ] } the_mq_fd->oflag = mqstat->mq_flags; 200a964: c2 06 40 00 ld [ %i1 ], %g1 200a968: 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 ) 200a96c: 07 00 80 93 sethi %hi(0x2024c00), %g3 200a970: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200a974: 90 10 20 00 clr %o0 200a978: 82 00 7f ff add %g1, -1, %g1 200a97c: c2 20 e0 d0 st %g1, [ %g3 + 0xd0 ] 200a980: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2 200a984: 80 a0 a0 00 cmp %g2, 0 200a988: 12 80 00 0b bne 200a9b4 200a98c: 01 00 00 00 nop _Thread_Dispatch(); 200a990: 40 00 16 1a call 20101f8 <_Thread_Dispatch> 200a994: 01 00 00 00 nop 200a998: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a99c: 81 c7 e0 08 ret 200a9a0: 91 e8 00 08 restore %g0, %o0, %o0 if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 200a9a4: 02 80 00 06 be 200a9bc 200a9a8: 01 00 00 00 nop the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 200a9ac: 40 00 05 bd call 200c0a0 <== NOT EXECUTED 200a9b0: 01 00 00 00 nop <== NOT EXECUTED } 200a9b4: 81 c7 e0 08 ret 200a9b8: 91 e8 00 08 restore %g0, %o0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); 200a9bc: 40 00 2f c0 call 20168bc <__errno> 200a9c0: 01 00 00 00 nop 200a9c4: 82 10 20 09 mov 9, %g1 ! 9 200a9c8: c2 22 00 00 st %g1, [ %o0 ] 200a9cc: 90 10 3f ff mov -1, %o0 the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a9d0: 81 c7 e0 08 ret 200a9d4: 91 e8 00 08 restore %g0, %o0, %o0 the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EBADF ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200a9d8: 40 00 16 08 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200a9dc: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200a9e0: 40 00 05 ba call 200c0c8 <== NOT EXECUTED 200a9e4: 01 00 00 00 nop <== NOT EXECUTED the_mq_fd->oflag = mqstat->mq_flags; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200a9e8: 81 c7 e0 08 ret <== NOT EXECUTED 200a9ec: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) rtems_set_errno_and_return_minus_one( EINVAL ); 200a9f0: 40 00 2f b3 call 20168bc <__errno> 200a9f4: 01 00 00 00 nop 200a9f8: 82 10 20 16 mov 0x16, %g1 ! 16 200a9fc: c2 22 00 00 st %g1, [ %o0 ] 200aa00: 10 bf ff ed b 200a9b4 200aa04: 90 10 3f ff mov -1, %o0 0200aa08 : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200aa08: 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 ) ) { 200aa0c: 92 07 bf f4 add %fp, -12, %o1 200aa10: 40 00 00 95 call 200ac64 <_POSIX_Absolute_timeout_to_ticks> 200aa14: 90 10 00 1c mov %i4, %o0 char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 200aa18: 92 10 00 19 mov %i1, %o1 200aa1c: 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 ) ) { 200aa20: 80 a2 20 02 cmp %o0, 2 200aa24: 18 80 00 09 bgu 200aa48 200aa28: 96 10 00 1b mov %i3, %o3 200aa2c: 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( 200aa30: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED 200aa34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200aa38: 7f ff fe d5 call 200a58c <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED 200aa3c: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 200aa40: 81 c7 e0 08 ret <== NOT EXECUTED 200aa44: 91 e8 00 08 restore %g0, %o0, %o0 <== 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 ) ) { 200aa48: 80 a2 20 03 cmp %o0, 3 200aa4c: 12 bf ff fa bne 200aa34 200aa50: da 07 bf f4 ld [ %fp + -12 ], %o5 200aa54: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 200aa58: 90 10 00 18 mov %i0, %o0 200aa5c: 7f ff fe cc call 200a58c <_POSIX_Message_queue_Receive_support> 200aa60: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200aa64: 81 c7 e0 08 ret 200aa68: 91 e8 00 08 restore %g0, %o0, %o0 0200aa6c : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200aa6c: 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 ) ) { 200aa70: 92 07 bf f4 add %fp, -12, %o1 200aa74: 40 00 00 7c call 200ac64 <_POSIX_Absolute_timeout_to_ticks> 200aa78: 90 10 00 1c mov %i4, %o0 const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 200aa7c: 92 10 00 19 mov %i1, %o1 200aa80: 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 ) ) { 200aa84: 80 a2 20 02 cmp %o0, 2 200aa88: 18 80 00 09 bgu 200aaac 200aa8c: 96 10 00 1b mov %i3, %o3 200aa90: 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( 200aa94: da 07 bf f4 ld [ %fp + -12 ], %o5 <== NOT EXECUTED 200aa98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200aa9c: 7f ff ff 36 call 200a774 <_POSIX_Message_queue_Send_support> <== NOT EXECUTED 200aaa0: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 200aaa4: 81 c7 e0 08 ret <== NOT EXECUTED 200aaa8: 91 e8 00 08 restore %g0, %o0, %o0 <== 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 ) ) { 200aaac: 80 a2 20 03 cmp %o0, 3 200aab0: 12 bf ff fa bne 200aa98 200aab4: da 07 bf f4 ld [ %fp + -12 ], %o5 200aab8: b8 10 20 01 mov 1, %i4 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 200aabc: 90 10 00 18 mov %i0, %o0 200aac0: 7f ff ff 2d call 200a774 <_POSIX_Message_queue_Send_support> 200aac4: 98 10 00 1c mov %i4, %o4 msg_len, msg_prio, do_wait, ticks ); } 200aac8: 81 c7 e0 08 ret 200aacc: 91 e8 00 08 restore %g0, %o0, %o0 0200ab74 : */ int mq_unlink( const char *name ) { 200ab74: 9d e3 bf 90 save %sp, -112, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200ab78: 21 00 80 93 sethi %hi(0x2024c00), %l0 200ab7c: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200ab80: 90 10 00 18 mov %i0, %o0 200ab84: 82 00 60 01 inc %g1 200ab88: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] register POSIX_Message_queue_Control *the_mq; Objects_Id the_mq_id; _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 200ab8c: 40 00 24 9a call 2013df4 <_POSIX_Message_queue_Name_to_id> 200ab90: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 200ab94: b0 92 20 00 orcc %o0, 0, %i0 200ab98: 12 80 00 24 bne 200ac28 200ab9c: 03 00 80 94 sethi %hi(0x2025000), %g1 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 200aba0: c4 07 bf f4 ld [ %fp + -12 ], %g2 200aba4: 88 10 60 e8 or %g1, 0xe8, %g4 200aba8: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 200abac: 03 00 00 3f sethi %hi(0xfc00), %g1 200abb0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200abb4: 82 08 80 01 and %g2, %g1, %g1 200abb8: 80 a0 40 03 cmp %g1, %g3 200abbc: 18 80 00 05 bgu 200abd0 200abc0: b0 10 20 00 clr %i0 200abc4: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200abc8: 83 28 60 02 sll %g1, 2, %g1 200abcc: f0 00 80 01 ld [ %g2 + %g1 ], %i0 200abd0: d2 06 20 0c ld [ %i0 + 0xc ], %o1 _Objects_MP_Close( &_POSIX_Message_queue_Information, the_mq_id ); } #endif the_mq->linked = FALSE; 200abd4: c0 26 20 18 clr [ %i0 + 0x18 ] 200abd8: 11 00 80 93 sethi %hi(0x2024c00), %o0 200abdc: 40 00 0e 11 call 200e420 <_Heap_Free> 200abe0: 90 12 21 1c or %o0, 0x11c, %o0 ! 2024d1c <_Workspace_Area> _Workspace_Free( the_mq->Object.name ); _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 200abe4: 90 10 00 18 mov %i0, %o0 200abe8: 7f ff fc e1 call 2009f6c <_POSIX_Message_queue_Delete> 200abec: c0 26 20 0c clr [ %i0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200abf0: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200abf4: b0 10 20 00 clr %i0 200abf8: 82 00 7f ff add %g1, -1, %g1 200abfc: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200ac00: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200ac04: 80 a0 a0 00 cmp %g2, 0 200ac08: 02 80 00 04 be 200ac18 200ac0c: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 200ac10: 81 c7 e0 08 ret <== NOT EXECUTED 200ac14: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200ac18: 40 00 15 78 call 20101f8 <_Thread_Dispatch> 200ac1c: 01 00 00 00 nop 200ac20: 81 c7 e0 08 ret 200ac24: 81 e8 00 00 restore #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ac28: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200ac2c: 82 00 7f ff add %g1, -1, %g1 200ac30: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200ac34: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200ac38: 80 a0 a0 00 cmp %g2, 0 200ac3c: 02 80 00 07 be 200ac58 200ac40: 01 00 00 00 nop _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); 200ac44: 40 00 2f 1e call 20168bc <__errno> 200ac48: 01 00 00 00 nop 200ac4c: f0 22 00 00 st %i0, [ %o0 ] 200ac50: 81 c7 e0 08 ret 200ac54: 91 e8 3f ff restore %g0, -1, %o0 _Thread_Dispatch(); 200ac58: 40 00 15 68 call 20101f8 <_Thread_Dispatch> 200ac5c: 01 00 00 00 nop 200ac60: 30 bf ff f9 b,a 200ac44 02015cd0 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 2015cd0: 9d e3 bf 98 save %sp, -104, %sp Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 2015cd4: 40 00 07 04 call 20178e4 <_Timespec_Is_valid> 2015cd8: 90 10 00 18 mov %i0, %o0 2015cdc: 80 a2 20 00 cmp %o0, 0 2015ce0: 02 80 00 4d be 2015e14 2015ce4: 01 00 00 00 nop * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) 2015ce8: c2 06 00 00 ld [ %i0 ], %g1 2015cec: 80 a0 60 00 cmp %g1, 0 2015cf0: 06 80 00 49 bl 2015e14 2015cf4: 01 00 00 00 nop 2015cf8: c2 06 20 04 ld [ %i0 + 4 ], %g1 2015cfc: 80 a0 60 00 cmp %g1, 0 2015d00: 06 80 00 45 bl 2015e14 2015d04: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 2015d08: 40 00 07 08 call 2017928 <_Timespec_To_ticks> 2015d0c: 90 10 00 18 mov %i0, %o0 * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 2015d10: b0 92 20 00 orcc %o0, 0, %i0 2015d14: 02 80 00 2d be 2015dc8 2015d18: 21 00 80 ad sethi %hi(0x202b400), %l0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2015d1c: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 2015d20: 82 00 60 01 inc %g1 2015d24: c2 24 22 60 st %g1, [ %l0 + 0x260 ] /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 2015d28: 23 00 80 ad sethi %hi(0x202b400), %l1 2015d2c: d0 04 63 40 ld [ %l1 + 0x340 ], %o0 ! 202b740 <_Thread_Executing> 2015d30: 13 04 00 00 sethi %hi(0x10000000), %o1 2015d34: 7f ff ed 3e call 201122c <_Thread_Set_state> 2015d38: 92 12 60 08 or %o1, 8, %o1 ! 10000008 _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 2015d3c: d2 04 63 40 ld [ %l1 + 0x340 ], %o1 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2015d40: 03 00 80 41 sethi %hi(0x2010400), %g1 2015d44: c4 02 60 08 ld [ %o1 + 8 ], %g2 2015d48: 82 10 60 4c or %g1, 0x4c, %g1 the_watchdog->id = id; 2015d4c: c4 22 60 68 st %g2, [ %o1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2015d50: c2 22 60 64 st %g1, [ %o1 + 0x64 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2015d54: f0 22 60 54 st %i0, [ %o1 + 0x54 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2015d58: c0 22 60 50 clr [ %o1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2015d5c: c0 22 60 6c clr [ %o1 + 0x6c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2015d60: 11 00 80 ad sethi %hi(0x202b400), %o0 2015d64: 92 02 60 48 add %o1, 0x48, %o1 2015d68: 7f ff ef 6b call 2011b14 <_Watchdog_Insert> 2015d6c: 90 12 23 60 or %o0, 0x360, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2015d70: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 2015d74: 82 00 7f ff add %g1, -1, %g1 2015d78: c2 24 22 60 st %g1, [ %l0 + 0x260 ] 2015d7c: c4 04 22 60 ld [ %l0 + 0x260 ], %g2 2015d80: 80 a0 a0 00 cmp %g2, 0 2015d84: 02 80 00 2a be 2015e2c 2015d88: 01 00 00 00 nop _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { 2015d8c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2015d90: 02 80 00 0c be 2015dc0 2015d94: c2 04 63 40 ld [ %l1 + 0x340 ], %g1 ticks -= _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 2015d98: 92 10 00 19 mov %i1, %o1 _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { ticks -= 2015d9c: c4 00 60 5c ld [ %g1 + 0x5c ], %g2 2015da0: e0 00 60 60 ld [ %g1 + 0x60 ], %l0 2015da4: a0 24 00 02 sub %l0, %g2, %l0 2015da8: a0 26 00 10 sub %i0, %l0, %l0 _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 2015dac: 40 00 06 b9 call 2017890 <_Timespec_From_ticks> 2015db0: 90 10 00 10 mov %l0, %o0 /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 2015db4: 80 a4 20 00 cmp %l0, 0 2015db8: 12 80 00 25 bne 2015e4c 2015dbc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 2015dc0: 81 c7 e0 08 ret 2015dc4: 91 e8 20 00 restore %g0, 0, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2015dc8: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 2015dcc: 82 00 60 01 inc %g1 2015dd0: c2 24 22 60 st %g1, [ %l0 + 0x260 ] * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); 2015dd4: 7f ff ee 23 call 2011660 <_Thread_Yield_processor> 2015dd8: 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 ) 2015ddc: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 2015de0: 82 00 7f ff add %g1, -1, %g1 2015de4: c2 24 22 60 st %g1, [ %l0 + 0x260 ] 2015de8: c4 04 22 60 ld [ %l0 + 0x260 ], %g2 2015dec: 80 a0 a0 00 cmp %g2, 0 2015df0: 02 80 00 13 be 2015e3c 2015df4: 01 00 00 00 nop _Thread_Enable_dispatch(); if ( rmtp ) { 2015df8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2015dfc: 02 bf ff f1 be 2015dc0 2015e00: 01 00 00 00 nop rmtp->tv_sec = 0; rmtp->tv_nsec = 0; 2015e04: c0 26 60 04 clr [ %i1 + 4 ] if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); _Thread_Enable_dispatch(); if ( rmtp ) { rmtp->tv_sec = 0; 2015e08: c0 26 40 00 clr [ %i1 ] rmtp->tv_nsec = 0; 2015e0c: 81 c7 e0 08 ret 2015e10: 91 e8 20 00 restore %g0, 0, %o0 * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); 2015e14: 40 00 11 e3 call 201a5a0 <__errno> 2015e18: b0 10 3f ff mov -1, %i0 2015e1c: 82 10 20 16 mov 0x16, %g1 2015e20: c2 22 00 00 st %g1, [ %o0 ] 2015e24: 81 c7 e0 08 ret 2015e28: 81 e8 00 00 restore _Thread_Dispatch(); 2015e2c: 7f ff e9 b1 call 20104f0 <_Thread_Dispatch> 2015e30: 01 00 00 00 nop _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); /* calculate time remaining */ if ( rmtp ) { 2015e34: 10 bf ff d7 b 2015d90 2015e38: 80 a6 60 00 cmp %i1, 0 2015e3c: 7f ff e9 ad call 20104f0 <_Thread_Dispatch> 2015e40: 01 00 00 00 nop if ( !ticks ) { _Thread_Disable_dispatch(); _Thread_Yield_processor(); _Thread_Enable_dispatch(); if ( rmtp ) { 2015e44: 10 bf ff ee b 2015dfc 2015e48: 80 a6 60 00 cmp %i1, 0 /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 2015e4c: 40 00 11 d5 call 201a5a0 <__errno> 2015e50: b0 10 3f ff mov -1, %i0 2015e54: 82 10 20 04 mov 4, %g1 2015e58: c2 22 00 00 st %g1, [ %o0 ] 2015e5c: 81 c7 e0 08 ret 2015e60: 81 e8 00 00 restore 02002940 : */ int newlib_free_buffers( FILE *fp ) { 2002940: 9d e3 bf 98 save %sp, -104, %sp switch ( fileno(fp) ) { 2002944: 40 00 32 af call 200f400 2002948: 90 10 00 18 mov %i0, %o0 200294c: 80 a2 20 02 cmp %o0, 2 2002950: 28 80 00 06 bleu,a 2002968 2002954: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 2002958: 40 00 32 30 call 200f218 <== NOT EXECUTED 200295c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } return 0; } 2002960: 81 c7 e0 08 ret 2002964: 91 e8 20 00 restore %g0, 0, %o0 { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 2002968: 80 88 60 80 btst 0x80, %g1 200296c: 02 bf ff fd be 2002960 2002970: 01 00 00 00 nop free( fp->_bf._base ); 2002974: 7f ff fe 61 call 20022f8 2002978: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 fp->_flags &= ~__SMBF; 200297c: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 fp->_bf._base = fp->_p = (unsigned char *) NULL; 2002980: c0 26 20 10 clr [ %i0 + 0x10 ] case 0: case 1: case 2: if (fp->_flags & __SMBF) { free( fp->_bf._base ); fp->_flags &= ~__SMBF; 2002984: 82 08 7f 7f and %g1, -129, %g1 fp->_bf._base = fp->_p = (unsigned char *) NULL; 2002988: c0 26 00 00 clr [ %i0 ] case 0: case 1: case 2: if (fp->_flags & __SMBF) { free( fp->_bf._base ); fp->_flags &= ~__SMBF; 200298c: c2 36 20 0c sth %g1, [ %i0 + 0xc ] break; default: fclose(fp); } return 0; } 2002990: 81 c7 e0 08 ret 2002994: 91 e8 20 00 restore %g0, 0, %o0 020029bc : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 20029bc: 9d e3 bf 98 save %sp, -104, %sp rtems_device_driver status; if ( !initialized ) { 20029c0: 05 00 80 75 sethi %hi(0x201d400), %g2 20029c4: c2 48 a2 74 ldsb [ %g2 + 0x274 ], %g1 ! 201d674 20029c8: 80 a0 60 00 cmp %g1, 0 20029cc: 02 80 00 04 be 20029dc 20029d0: 82 10 20 01 mov 1, %g1 NULL_major = major; } return RTEMS_SUCCESSFUL; } 20029d4: 81 c7 e0 08 ret 20029d8: 91 e8 20 00 restore %g0, 0, %o0 rtems_device_driver status; if ( !initialized ) { initialized = 1; status = rtems_io_register_name( 20029dc: 11 00 80 6b sethi %hi(0x201ac00), %o0 ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 20029e0: c2 28 a2 74 stb %g1, [ %g2 + 0x274 ] status = rtems_io_register_name( 20029e4: 90 12 21 c8 or %o0, 0x1c8, %o0 20029e8: 92 10 00 18 mov %i0, %o1 20029ec: 40 00 00 50 call 2002b2c 20029f0: 94 10 20 00 clr %o2 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 20029f4: 80 a2 20 00 cmp %o0, 0 20029f8: 12 80 00 05 bne 2002a0c 20029fc: 03 00 80 76 sethi %hi(0x201d800), %g1 rtems_fatal_error_occurred(status); NULL_major = major; 2002a00: f0 20 61 dc st %i0, [ %g1 + 0x1dc ] ! 201d9dc } return RTEMS_SUCCESSFUL; } 2002a04: 81 c7 e0 08 ret 2002a08: 91 e8 20 00 restore %g0, 0, %o0 major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); 2002a0c: 40 00 13 af call 20078c8 <== NOT EXECUTED 2002a10: 01 00 00 00 nop <== NOT EXECUTED NULL_major = major; 2002a14: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED 2002a18: 10 bf ff fb b 2002a04 <== NOT EXECUTED 2002a1c: f0 20 61 dc st %i0, [ %g1 + 0x1dc ] ! 201d9dc <== NOT EXECUTED 02002998 : void *pargp ) { rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 2002998: 80 a2 a0 00 cmp %o2, 0 200299c: 02 80 00 04 be 20029ac 20029a0: 01 00 00 00 nop rw_args->bytes_moved = rw_args->count; 20029a4: c2 02 a0 0c ld [ %o2 + 0xc ], %g1 <== NOT EXECUTED 20029a8: c2 22 a0 14 st %g1, [ %o2 + 0x14 ] <== NOT EXECUTED return NULL_SUCCESSFUL; } 20029ac: 81 c3 e0 08 retl 20029b0: 90 10 20 00 clr %o0 02002bc4 : int open( const char *pathname, int flags, ... ) { 2002bc4: 9d e3 bf 80 save %sp, -128, %sp 2002bc8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 2002bcc: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 2002bd0: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 2002bd4: f4 27 a0 4c st %i2, [ %fp + 0x4c ] /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 2002bd8: 82 06 60 01 add %i1, 1, %g1 if ( ( status & _FREAD ) == _FREAD ) eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 2002bdc: 80 88 60 02 btst 2, %g1 * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; if ( ( status & _FREAD ) == _FREAD ) 2002be0: 82 08 60 01 and %g1, 1, %g1 eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 2002be4: 02 80 00 03 be 2002bf0 2002be8: a1 28 60 02 sll %g1, 2, %l0 eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 2002bec: a0 14 20 02 or %l0, 2, %l0 va_start(ap, flags); mode = va_arg( ap, int ); 2002bf0: 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 ) { 2002bf4: 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(); 2002bf8: 40 00 26 7a call 200c5e0 2002bfc: c2 27 bf f4 st %g1, [ %fp + -12 ] if ( iop == 0 ) { 2002c00: ba 92 20 00 orcc %o0, 0, %i5 2002c04: 02 80 00 62 be 2002d8c 2002c08: 92 10 00 10 mov %l0, %o1 /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 2002c0c: b6 07 bf e4 add %fp, -28, %i3 2002c10: 90 10 00 18 mov %i0, %o0 2002c14: 94 10 00 1b mov %i3, %o2 2002c18: 7f ff fd 20 call 2002098 2002c1c: 96 10 20 01 mov 1, %o3 pathname, eval_flags, &loc, TRUE ); if ( status == -1 ) { 2002c20: 80 a2 3f ff cmp %o0, -1 2002c24: 02 80 00 73 be 2002df0 2002c28: 82 0e 6a 00 and %i1, 0xa00, %g1 if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 2002c2c: a0 10 00 1b mov %i3, %l0 2002c30: 80 a0 6a 00 cmp %g1, 0xa00 2002c34: 02 80 00 62 be 2002dbc 2002c38: 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; 2002c3c: c2 07 bf e8 ld [ %fp + -24 ], %g1 iop->file_info = loc.node_access; 2002c40: c4 07 bf e4 ld [ %fp + -28 ], %g2 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 2002c44: c2 27 60 30 st %g1, [ %i5 + 0x30 ] iop->file_info = loc.node_access; 2002c48: c4 27 60 2c st %g2, [ %i5 + 0x2c ] iop->flags |= rtems_libio_fcntl_flags( flags ); 2002c4c: e0 07 60 0c ld [ %i5 + 0xc ], %l0 2002c50: 40 00 26 a2 call 200c6d8 2002c54: 90 10 00 19 mov %i1, %o0 iop->pathinfo = loc; 2002c58: c2 07 bf e4 ld [ %fp + -28 ], %g1 if ( !iop->handlers->open_h ) { 2002c5c: c4 07 60 30 ld [ %i5 + 0x30 ], %g2 */ iop->handlers = loc.handlers; iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); iop->pathinfo = loc; 2002c60: c2 27 60 10 st %g1, [ %i5 + 0x10 ] 2002c64: c2 07 bf e8 ld [ %fp + -24 ], %g1 if ( !iop->handlers->open_h ) { 2002c68: c4 00 80 00 ld [ %g2 ], %g2 */ iop->handlers = loc.handlers; iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); iop->pathinfo = loc; 2002c6c: c2 27 60 14 st %g1, [ %i5 + 0x14 ] 2002c70: c2 07 bf ec ld [ %fp + -20 ], %g1 * returned by successful path evaluation. */ iop->handlers = loc.handlers; iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); 2002c74: 90 12 00 10 or %o0, %l0, %o0 iop->pathinfo = loc; 2002c78: c2 27 60 18 st %g1, [ %i5 + 0x18 ] 2002c7c: c2 07 bf f0 ld [ %fp + -16 ], %g1 * returned by successful path evaluation. */ iop->handlers = loc.handlers; iop->file_info = loc.node_access; iop->flags |= rtems_libio_fcntl_flags( flags ); 2002c80: d0 27 60 0c st %o0, [ %i5 + 0xc ] iop->pathinfo = loc; if ( !iop->handlers->open_h ) { 2002c84: 80 a0 a0 00 cmp %g2, 0 2002c88: 02 80 00 54 be 2002dd8 2002c8c: c2 27 60 1c st %g1, [ %i5 + 0x1c ] rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 2002c90: 92 10 00 18 mov %i0, %o1 2002c94: 96 10 00 1a mov %i2, %o3 2002c98: 90 10 00 1d mov %i5, %o0 2002c9c: 9f c0 80 00 call %g2 2002ca0: 94 10 00 19 mov %i1, %o2 if ( rc ) 2002ca4: b8 92 20 00 orcc %o0, 0, %i4 2002ca8: 12 80 00 29 bne 2002d4c 2002cac: 80 8e 64 00 btst 0x400, %i1 /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 2002cb0: 02 80 00 16 be 2002d08 2002cb4: 21 00 80 65 sethi %hi(0x2019400), %l0 rc = ftruncate( iop - rtems_libio_iops, 0 ); 2002cb8: c4 04 22 70 ld [ %l0 + 0x270 ], %g2 ! 2019670 2002cbc: 92 10 20 00 clr %o1 2002cc0: 84 27 40 02 sub %i5, %g2, %g2 2002cc4: 85 38 a0 02 sra %g2, 2, %g2 2002cc8: 87 28 a0 02 sll %g2, 2, %g3 2002ccc: 83 28 a0 06 sll %g2, 6, %g1 2002cd0: 82 20 40 03 sub %g1, %g3, %g1 2002cd4: 91 28 60 06 sll %g1, 6, %o0 2002cd8: 90 22 00 01 sub %o0, %g1, %o0 2002cdc: 87 2a 20 0c sll %o0, 0xc, %g3 2002ce0: 90 02 00 03 add %o0, %g3, %o0 2002ce4: 90 02 00 02 add %o0, %g2, %o0 2002ce8: 91 2a 20 04 sll %o0, 4, %o0 2002cec: 90 22 00 02 sub %o0, %g2, %o0 2002cf0: 91 2a 20 02 sll %o0, 2, %o0 2002cf4: 40 00 25 59 call 200c258 2002cf8: 90 20 80 08 sub %g2, %o0, %o0 if ( rc ) { 2002cfc: b8 92 20 00 orcc %o0, 0, %i4 2002d00: 12 80 00 5a bne 2002e68 2002d04: 01 00 00 00 nop if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 2002d08: c6 04 22 70 ld [ %l0 + 0x270 ], %g3 2002d0c: 86 27 40 03 sub %i5, %g3, %g3 2002d10: 87 38 e0 02 sra %g3, 2, %g3 2002d14: 89 28 e0 02 sll %g3, 2, %g4 2002d18: 85 28 e0 06 sll %g3, 6, %g2 2002d1c: 84 20 80 04 sub %g2, %g4, %g2 2002d20: 83 28 a0 06 sll %g2, 6, %g1 2002d24: 82 20 40 02 sub %g1, %g2, %g1 2002d28: 89 28 60 0c sll %g1, 0xc, %g4 2002d2c: 82 00 40 04 add %g1, %g4, %g1 2002d30: 82 00 40 03 add %g1, %g3, %g1 2002d34: 83 28 60 04 sll %g1, 4, %g1 2002d38: 82 20 40 03 sub %g1, %g3, %g1 2002d3c: 83 28 60 02 sll %g1, 2, %g1 2002d40: b0 20 c0 01 sub %g3, %g1, %i0 2002d44: 81 c7 e0 08 ret 2002d48: 81 e8 00 00 restore /* * Single exit and clean up path. */ done: va_end(ap); 2002d4c: a0 10 00 1b mov %i3, %l0 <== NOT EXECUTED if ( rc ) { if ( iop ) rtems_libio_free( iop ); 2002d50: 40 00 26 0d call 200c584 <== NOT EXECUTED 2002d54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED if ( loc_to_free ) 2002d58: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2002d5c: 02 80 00 0c be 2002d8c 2002d60: 01 00 00 00 nop rtems_filesystem_freenode( loc_to_free ); 2002d64: c2 04 20 08 ld [ %l0 + 8 ], %g1 2002d68: 80 a0 60 00 cmp %g1, 0 2002d6c: 02 80 00 08 be 2002d8c 2002d70: 01 00 00 00 nop 2002d74: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2002d78: 80 a0 60 00 cmp %g1, 0 2002d7c: 02 80 00 04 be 2002d8c 2002d80: 01 00 00 00 nop 2002d84: 9f c0 40 00 call %g1 2002d88: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( rc ); 2002d8c: 40 00 30 cd call 200f0c0 <__errno> 2002d90: b0 10 3f ff mov -1, %i0 2002d94: f8 22 00 00 st %i4, [ %o0 ] 2002d98: 81 c7 e0 08 ret 2002d9c: 81 e8 00 00 restore } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; 2002da0: 40 00 30 c8 call 200f0c0 <__errno> 2002da4: 01 00 00 00 nop 2002da8: f8 02 00 00 ld [ %o0 ], %i4 */ done: va_end(ap); if ( rc ) { 2002dac: 80 a7 20 00 cmp %i4, 0 2002db0: 02 bf ff d6 be 2002d08 2002db4: 21 00 80 65 sethi %hi(0x2019400), %l0 2002db8: a0 10 20 00 clr %l0 if ( iop ) 2002dbc: 80 a7 60 00 cmp %i5, 0 2002dc0: 22 bf ff e7 be,a 2002d5c 2002dc4: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED rtems_libio_free( iop ); 2002dc8: 40 00 25 ef call 200c584 2002dcc: 90 10 00 1d mov %i5, %o0 if ( loc_to_free ) 2002dd0: 10 bf ff e3 b 2002d5c 2002dd4: 80 a4 20 00 cmp %l0, 0 rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 2002dd8: a0 10 00 1b mov %i3, %l0 <== NOT EXECUTED done: va_end(ap); if ( rc ) { if ( iop ) 2002ddc: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 2002de0: 12 bf ff fa bne 2002dc8 <== NOT EXECUTED 2002de4: b8 10 20 86 mov 0x86, %i4 <== NOT EXECUTED rtems_libio_free( iop ); if ( loc_to_free ) 2002de8: 10 bf ff dd b 2002d5c <== NOT EXECUTED 2002dec: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED status = rtems_filesystem_evaluate_path( pathname, eval_flags, &loc, TRUE ); if ( status == -1 ) { if ( errno != ENOENT ) { 2002df0: 40 00 30 b4 call 200f0c0 <__errno> 2002df4: 01 00 00 00 nop 2002df8: c2 02 00 00 ld [ %o0 ], %g1 2002dfc: 80 a0 60 02 cmp %g1, 2 2002e00: 12 bf ff e8 bne 2002da0 2002e04: 80 8e 62 00 btst 0x200, %i1 rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 2002e08: a0 10 20 00 clr %l0 2002e0c: 02 bf ff ec be 2002dbc 2002e10: 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 ); 2002e14: 13 3f ff e0 sethi %hi(0xffff8000), %o1 2002e18: 90 10 00 18 mov %i0, %o0 2002e1c: 92 16 80 09 or %i2, %o1, %o1 2002e20: 94 10 20 00 clr %o2 2002e24: 93 2a 60 10 sll %o1, 0x10, %o1 2002e28: 96 10 20 00 clr %o3 2002e2c: 7f ff fe 41 call 2002730 2002e30: 93 32 60 10 srl %o1, 0x10, %o1 if ( rc ) { 2002e34: 80 a2 20 00 cmp %o0, 0 2002e38: 12 bf ff da bne 2002da0 2002e3c: 90 10 00 18 mov %i0, %o0 rc = errno; goto done; } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, TRUE ); 2002e40: 92 10 20 00 clr %o1 2002e44: 94 10 00 1b mov %i3, %o2 2002e48: 96 10 20 01 mov 1, %o3 2002e4c: 7f ff fc 93 call 2002098 2002e50: a0 10 20 00 clr %l0 if ( status != 0 ) { /* The file did not exist */ 2002e54: 80 a2 20 00 cmp %o0, 0 2002e58: 12 bf ff d9 bne 2002dbc 2002e5c: 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; 2002e60: 10 bf ff 78 b 2002c40 2002e64: c2 07 bf e8 ld [ %fp + -24 ], %g1 */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; 2002e68: 40 00 30 96 call 200f0c0 <__errno> <== NOT EXECUTED 2002e6c: 01 00 00 00 nop <== NOT EXECUTED 2002e70: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2002e74: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2002e78: 12 80 00 15 bne 2002ecc <== NOT EXECUTED 2002e7c: 01 00 00 00 nop <== NOT EXECUTED close( iop - rtems_libio_iops ); 2002e80: c4 04 22 70 ld [ %l0 + 0x270 ], %g2 <== NOT EXECUTED 2002e84: 84 27 40 02 sub %i5, %g2, %g2 <== NOT EXECUTED 2002e88: 85 38 a0 02 sra %g2, 2, %g2 <== NOT EXECUTED 2002e8c: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED 2002e90: 83 28 a0 06 sll %g2, 6, %g1 <== NOT EXECUTED 2002e94: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 2002e98: 91 28 60 06 sll %g1, 6, %o0 <== NOT EXECUTED 2002e9c: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED 2002ea0: 87 2a 20 0c sll %o0, 0xc, %g3 <== NOT EXECUTED 2002ea4: ba 10 20 00 clr %i5 <== NOT EXECUTED 2002ea8: 90 02 00 03 add %o0, %g3, %o0 <== NOT EXECUTED 2002eac: 90 02 00 02 add %o0, %g2, %o0 <== NOT EXECUTED 2002eb0: 91 2a 20 04 sll %o0, 4, %o0 <== NOT EXECUTED 2002eb4: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED 2002eb8: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED 2002ebc: 40 00 24 b6 call 200c194 <== NOT EXECUTED 2002ec0: 90 20 80 08 sub %g2, %o0, %o0 <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 2002ec4: 10 bf ff bb b 2002db0 <== NOT EXECUTED 2002ec8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; 2002ecc: 40 00 30 7d call 200f0c0 <__errno> <== NOT EXECUTED 2002ed0: 01 00 00 00 nop <== NOT EXECUTED 2002ed4: 10 bf ff eb b 2002e80 <== NOT EXECUTED 2002ed8: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED 02002b48 : /* * This is a replaceable stub */ void open_dev_console(void) { 2002b48: 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) { 2002b4c: 31 00 80 5d sethi %hi(0x2017400), %i0 2002b50: 92 10 20 00 clr %o1 2002b54: 90 16 21 b0 or %i0, 0x1b0, %o0 2002b58: 40 00 00 1b call 2002bc4 2002b5c: 94 10 20 00 clr %o2 2002b60: 80 a2 3f ff cmp %o0, -1 2002b64: 02 80 00 0f be 2002ba0 2002b68: 90 16 21 b0 or %i0, 0x1b0, %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) 2002b6c: 92 10 20 01 mov 1, %o1 2002b70: 40 00 00 15 call 2002bc4 2002b74: 94 10 20 00 clr %o2 2002b78: 80 a2 3f ff cmp %o0, -1 2002b7c: 02 80 00 0e be 2002bb4 2002b80: 11 14 d5 11 sethi %hi(0x53544400), %o0 rtems_fatal_error_occurred( error_code | '1' ); if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 2002b84: 90 16 21 b0 or %i0, 0x1b0, %o0 2002b88: 92 10 20 01 mov 1, %o1 2002b8c: 40 00 00 0e call 2002bc4 2002b90: 94 10 20 00 clr %o2 2002b94: 80 a2 3f ff cmp %o0, -1 2002b98: 02 80 00 04 be 2002ba8 2002b9c: 31 14 d5 11 sethi %hi(0x53544400), %i0 2002ba0: 81 c7 e0 08 ret 2002ba4: 81 e8 00 00 restore rtems_fatal_error_occurred( error_code | '2' ); 2002ba8: b0 16 20 32 or %i0, 0x32, %i0 <== NOT EXECUTED 2002bac: 40 00 0f b1 call 2006a70 <== NOT EXECUTED 2002bb0: 81 e8 00 00 restore <== NOT EXECUTED /* * But if we find /dev/console once, we better find it twice more * or something is REALLY wrong. */ if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1) rtems_fatal_error_occurred( error_code | '1' ); 2002bb4: 40 00 0f af call 2006a70 <== NOT EXECUTED 2002bb8: 90 12 20 31 or %o0, 0x31, %o0 <== NOT EXECUTED if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 2002bbc: 10 bf ff f3 b 2002b88 <== NOT EXECUTED 2002bc0: 90 16 21 b0 or %i0, 0x1b0, %o0 <== NOT EXECUTED 02018964 : * open a directory. */ DIR * opendir(name) const char *name; { 2018964: 9d e3 bf 98 save %sp, -104, %sp register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 2018968: 92 10 20 00 clr %o1 201896c: 90 10 00 18 mov %i0, %o0 2018970: 7f ff b1 e7 call 200510c 2018974: b0 10 20 00 clr %i0 2018978: 80 a2 3f ff cmp %o0, -1 201897c: 02 80 00 18 be 20189dc 2018980: a0 10 00 08 mov %o0, %l0 return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 2018984: 92 10 20 02 mov 2, %o1 2018988: 40 00 29 57 call 2022ee4 201898c: 94 10 20 01 mov 1, %o2 2018990: 80 a2 3f ff cmp %o0, -1 2018994: 02 80 00 15 be 20189e8 2018998: 90 10 00 10 mov %l0, %o0 201899c: 7f ff af 1c call 200460c 20189a0: 90 10 20 18 mov 0x18, %o0 20189a4: 80 a2 20 00 cmp %o0, 0 20189a8: 22 80 00 10 be,a 20189e8 20189ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20189b0: 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); 20189b4: 7f ff af 16 call 200460c 20189b8: 90 10 22 00 mov 0x200, %o0 dirp->dd_len = 512; 20189bc: 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); 20189c0: d0 26 20 0c st %o0, [ %i0 + 0xc ] dirp->dd_len = 512; if (dirp->dd_buf == NULL) { 20189c4: 80 a2 20 00 cmp %o0, 0 20189c8: 02 80 00 07 be 20189e4 20189cc: c2 26 20 10 st %g1, [ %i0 + 0x10 ] close (fd); return NULL; } dirp->dd_fd = fd; 20189d0: e0 26 00 00 st %l0, [ %i0 ] dirp->dd_loc = 0; 20189d4: c0 26 20 04 clr [ %i0 + 4 ] dirp->dd_seek = 0; 20189d8: c0 26 20 14 clr [ %i0 + 0x14 ] /* * Set up seek point for rewinddir. */ return dirp; } 20189dc: 81 c7 e0 08 ret 20189e0: 81 e8 00 00 restore */ dirp->dd_buf = malloc (512); dirp->dd_len = 512; if (dirp->dd_buf == NULL) { close (fd); 20189e4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20189e8: 7f ff ad 01 call 2003dec <== NOT EXECUTED 20189ec: b0 10 20 00 clr %i0 <== NOT EXECUTED 20189f0: 81 c7 e0 08 ret <== NOT EXECUTED 20189f4: 81 e8 00 00 restore <== NOT EXECUTED 02003a74 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 2003a74: 9d e3 bf 98 save %sp, -104, %sp int i; if (tty->termios.c_oflag & OPOST) { 2003a78: c6 06 60 34 ld [ %i1 + 0x34 ], %g3 2003a7c: 80 88 e0 01 btst 1, %g3 2003a80: 02 80 00 10 be 2003ac0 2003a84: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] switch (c) { 2003a88: b0 0e 20 ff and %i0, 0xff, %i0 2003a8c: 80 a6 20 09 cmp %i0, 9 2003a90: 22 80 00 28 be,a 2003b30 2003a94: c8 06 60 28 ld [ %i1 + 0x28 ], %g4 2003a98: 18 80 00 10 bgu 2003ad8 2003a9c: 80 a6 20 0a cmp %i0, 0xa 2003aa0: 80 a6 20 08 cmp %i0, 8 <== NOT EXECUTED 2003aa4: 12 80 00 11 bne 2003ae8 <== NOT EXECUTED 2003aa8: 80 88 e0 02 btst 2, %g3 <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 2003aac: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED 2003ab0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003ab4: 04 80 00 03 ble 2003ac0 <== NOT EXECUTED 2003ab8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED tty->column--; 2003abc: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED if (!iscntrl(c)) tty->column++; break; } } rtems_termios_puts (&c, 1, tty); 2003ac0: 94 10 00 19 mov %i1, %o2 2003ac4: 90 07 a0 44 add %fp, 0x44, %o0 2003ac8: 7f ff ff 96 call 2003920 2003acc: 92 10 20 01 mov 1, %o1 2003ad0: 81 c7 e0 08 ret 2003ad4: 81 e8 00 00 restore oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 2003ad8: 02 80 00 24 be 2003b68 2003adc: 80 a6 20 0d cmp %i0, 0xd 2003ae0: 02 80 00 2f be 2003b9c 2003ae4: 80 88 e0 02 btst 2, %g3 if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 2003ae8: 02 80 00 08 be 2003b08 2003aec: 07 00 80 63 sethi %hi(0x2018c00), %g3 c = toupper(c); 2003af0: c4 00 e2 30 ld [ %g3 + 0x230 ], %g2 ! 2018e30 <__ctype_ptr> <== NOT EXECUTED 2003af4: c2 08 80 18 ldub [ %g2 + %i0 ], %g1 <== NOT EXECUTED 2003af8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 2003afc: 32 80 00 02 bne,a 2003b04 <== NOT EXECUTED 2003b00: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED 2003b04: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED if (!iscntrl(c)) 2003b08: c2 00 e2 30 ld [ %g3 + 0x230 ], %g1 2003b0c: c4 0f a0 44 ldub [ %fp + 0x44 ], %g2 2003b10: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 2003b14: 80 88 e0 20 btst 0x20, %g3 2003b18: 12 bf ff eb bne 2003ac4 2003b1c: 94 10 00 19 mov %i1, %o2 tty->column++; 2003b20: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 2003b24: 82 00 60 01 inc %g1 2003b28: 10 bf ff e7 b 2003ac4 2003b2c: c2 26 60 28 st %g1, [ %i1 + 0x28 ] tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { 2003b30: 05 00 00 06 sethi %hi(0x1800), %g2 2003b34: 82 08 c0 02 and %g3, %g2, %g1 } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 2003b38: 86 09 20 07 and %g4, 7, %g3 if ((tty->termios.c_oflag & TABDLY) == XTABS) { 2003b3c: 80 a0 40 02 cmp %g1, %g2 } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 2003b40: 82 10 20 08 mov 8, %g1 if ((tty->termios.c_oflag & TABDLY) == XTABS) { 2003b44: 02 80 00 25 be 2003bd8 2003b48: 92 20 40 03 sub %g1, %g3, %o1 tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 2003b4c: 82 02 40 04 add %o1, %g4, %g1 <== NOT EXECUTED if (!iscntrl(c)) tty->column++; break; } } rtems_termios_puts (&c, 1, tty); 2003b50: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 2003b54: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED if (!iscntrl(c)) tty->column++; break; } } rtems_termios_puts (&c, 1, tty); 2003b58: 90 07 a0 44 add %fp, 0x44, %o0 <== NOT EXECUTED 2003b5c: 7f ff ff 71 call 2003920 <== NOT EXECUTED 2003b60: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2003b64: 30 80 00 23 b,a 2003bf0 <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { switch (c) { case '\n': if (tty->termios.c_oflag & ONLRET) 2003b68: 80 88 e0 20 btst 0x20, %g3 2003b6c: 32 80 00 02 bne,a 2003b74 2003b70: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED tty->column = 0; if (tty->termios.c_oflag & ONLCR) { 2003b74: 80 88 e0 04 btst 4, %g3 2003b78: 02 bf ff d3 be 2003ac4 2003b7c: 94 10 00 19 mov %i1, %o2 rtems_termios_puts ("\r", 1, tty); 2003b80: 11 00 80 5e sethi %hi(0x2017800), %o0 2003b84: 92 10 20 01 mov 1, %o1 2003b88: 90 12 21 78 or %o0, 0x178, %o0 2003b8c: 7f ff ff 65 call 2003920 2003b90: 94 10 00 19 mov %i1, %o2 tty->column = 0; 2003b94: 10 bf ff cb b 2003ac0 2003b98: c0 26 60 28 clr [ %i1 + 0x28 ] } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 2003b9c: 80 88 e0 10 btst 0x10, %g3 <== NOT EXECUTED 2003ba0: 02 80 00 06 be 2003bb8 <== NOT EXECUTED 2003ba4: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED 2003ba8: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED 2003bac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003bb0: 02 bf ff c8 be 2003ad0 <== NOT EXECUTED 2003bb4: 80 88 e0 08 btst 8, %g3 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 2003bb8: 22 bf ff c2 be,a 2003ac0 <== NOT EXECUTED 2003bbc: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED c = '\n'; 2003bc0: 82 10 20 0a mov 0xa, %g1 <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 2003bc4: 80 88 e0 20 btst 0x20, %g3 <== NOT EXECUTED 2003bc8: 02 bf ff be be 2003ac0 <== NOT EXECUTED 2003bcc: c2 2f a0 44 stb %g1, [ %fp + 0x44 ] <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 2003bd0: 10 bf ff bc b 2003ac0 <== NOT EXECUTED 2003bd4: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; 2003bd8: 82 02 40 04 add %o1, %g4, %g1 rtems_termios_puts ( " ", i, tty); 2003bdc: 94 10 00 19 mov %i1, %o2 break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; 2003be0: c2 26 60 28 st %g1, [ %i1 + 0x28 ] rtems_termios_puts ( " ", i, tty); 2003be4: 11 00 80 5e sethi %hi(0x2017800), %o0 2003be8: 7f ff ff 4e call 2003920 2003bec: 90 12 21 80 or %o0, 0x180, %o0 ! 2017980 2003bf0: 81 c7 e0 08 ret 2003bf4: 81 e8 00 00 restore 02005cb8 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 2005cb8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 2005cbc: 80 a6 20 00 cmp %i0, 0 2005cc0: 02 80 00 23 be 2005d4c 2005cc4: 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( 2005cc8: d2 06 00 00 ld [ %i0 ], %o1 2005ccc: 31 00 80 6d sethi %hi(0x201b400), %i0 2005cd0: 40 00 0d 55 call 2009224 <_Objects_Get> 2005cd4: 90 16 21 90 or %i0, 0x190, %o0 ! 201b590 <_POSIX_Barrier_Information> return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 2005cd8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cdc: 80 a0 60 00 cmp %g1, 0 2005ce0: 12 80 00 14 bne 2005d30 2005ce4: 92 10 00 08 mov %o0, %o1 case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 2005ce8: c2 02 20 58 ld [ %o0 + 0x58 ], %g1 2005cec: 80 a0 60 00 cmp %g1, 0 2005cf0: 02 80 00 1a be 2005d58 2005cf4: 90 16 21 90 or %i0, 0x190, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005cf8: 03 00 80 6c sethi %hi(0x201b000), %g1 2005cfc: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201b0e0 <_Thread_Dispatch_disable_level> 2005d00: 90 10 20 10 mov 0x10, %o0 2005d04: 84 00 bf ff add %g2, -1, %g2 2005d08: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 2005d0c: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 2005d10: 80 a0 e0 00 cmp %g3, 0 2005d14: 12 80 00 0c bne 2005d44 2005d18: 01 00 00 00 nop _Thread_Dispatch(); 2005d1c: 40 00 12 3a call 200a604 <_Thread_Dispatch> 2005d20: 01 00 00 00 nop 2005d24: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005d28: 81 c7 e0 08 ret 2005d2c: 91 e8 00 08 restore %g0, %o0, %o0 if ( !barrier ) return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 2005d30: 80 a0 60 02 cmp %g1, 2 2005d34: 08 80 00 07 bleu 2005d50 2005d38: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005d3c: 40 00 02 45 call 2006650 <== NOT EXECUTED 2005d40: 01 00 00 00 nop <== NOT EXECUTED } 2005d44: 81 c7 e0 08 ret 2005d48: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005d4c: 90 10 20 16 mov 0x16, %o0 } 2005d50: 81 c7 e0 08 ret 2005d54: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005d58: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005d5c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005d60: 05 00 00 3f sethi %hi(0xfc00), %g2 2005d64: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005d68: 82 08 40 02 and %g1, %g2, %g1 2005d6c: 80 a0 40 03 cmp %g1, %g3 2005d70: 18 80 00 04 bgu 2005d80 2005d74: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 2005d78: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005d7c: 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 ); 2005d80: 40 00 0c e6 call 2009118 <_Objects_Free> 2005d84: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005d88: 03 00 80 6c sethi %hi(0x201b000), %g1 2005d8c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201b0e0 <_Thread_Dispatch_disable_level> 2005d90: 90 10 20 00 clr %o0 2005d94: 84 00 bf ff add %g2, -1, %g2 2005d98: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 2005d9c: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 2005da0: 80 a0 e0 00 cmp %g3, 0 2005da4: 12 bf ff e8 bne 2005d44 2005da8: 01 00 00 00 nop _Thread_Dispatch(); 2005dac: 40 00 12 16 call 200a604 <_Thread_Dispatch> 2005db0: 01 00 00 00 nop 2005db4: 10 bf ff e4 b 2005d44 2005db8: 90 10 20 00 clr %o0 ! 0 02005dbc : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 2005dbc: 9d e3 bf 88 save %sp, -120, %sp const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 2005dc0: 80 a6 20 00 cmp %i0, 0 2005dc4: 02 80 00 27 be 2005e60 2005dc8: a0 10 00 19 mov %i1, %l0 return EINVAL; if ( count == 0 ) 2005dcc: 80 a6 a0 00 cmp %i2, 0 2005dd0: 02 80 00 24 be 2005e60 2005dd4: 80 a6 60 00 cmp %i1, 0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 2005dd8: 22 80 00 25 be,a 2005e6c 2005ddc: a0 07 bf e8 add %fp, -24, %l0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2005de0: c2 04 00 00 ld [ %l0 ], %g1 2005de4: 80 a0 60 00 cmp %g1, 0 2005de8: 22 80 00 1c be,a 2005e58 2005dec: b0 10 20 16 mov 0x16, %i0 return EINVAL; switch ( the_attr->process_shared ) { 2005df0: c2 04 20 04 ld [ %l0 + 4 ], %g1 2005df4: 80 a0 60 00 cmp %g1, 0 2005df8: 32 80 00 18 bne,a 2005e58 2005dfc: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005e00: 33 00 80 6c sethi %hi(0x201b000), %i1 2005e04: c2 06 60 e0 ld [ %i1 + 0xe0 ], %g1 ! 201b0e0 <_Thread_Dispatch_disable_level> /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; the_attributes.maximum_count = count; 2005e08: f4 27 bf f4 st %i2, [ %fp + -12 ] 2005e0c: 82 00 60 01 inc %g1 } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 2005e10: c0 27 bf f0 clr [ %fp + -16 ] 2005e14: c2 26 60 e0 st %g1, [ %i1 + 0xe0 ] * 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 *) 2005e18: 35 00 80 6d sethi %hi(0x201b400), %i2 2005e1c: 40 00 0b b1 call 2008ce0 <_Objects_Allocate> 2005e20: 90 16 a1 90 or %i2, 0x190, %o0 ! 201b590 <_POSIX_Barrier_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 2005e24: a0 92 20 00 orcc %o0, 0, %l0 2005e28: 12 80 00 15 bne 2005e7c 2005e2c: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005e30: c2 06 60 e0 ld [ %i1 + 0xe0 ], %g1 2005e34: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 2005e38: 82 00 7f ff add %g1, -1, %g1 2005e3c: c2 26 60 e0 st %g1, [ %i1 + 0xe0 ] 2005e40: c4 06 60 e0 ld [ %i1 + 0xe0 ], %g2 2005e44: 80 a0 a0 00 cmp %g2, 0 2005e48: 12 80 00 07 bne 2005e64 2005e4c: 01 00 00 00 nop 2005e50: 40 00 11 ed call 200a604 <_Thread_Dispatch> 2005e54: 01 00 00 00 nop 2005e58: 81 c7 e0 08 ret 2005e5c: 81 e8 00 00 restore 2005e60: b0 10 20 16 mov 0x16, %i0 * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; } 2005e64: 81 c7 e0 08 ret 2005e68: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 2005e6c: 7f ff ff 7d call 2005c60 2005e70: 90 10 00 10 mov %l0, %o0 } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 2005e74: 10 bf ff dc b 2005de4 2005e78: c2 04 00 00 ld [ %l0 ], %g1 if ( !the_barrier ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 2005e7c: 40 00 08 d8 call 20081dc <_CORE_barrier_Initialize> 2005e80: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e84: 90 16 a1 90 or %i2, 0x190, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005e88: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005e8c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005e90: 03 00 00 3f sethi %hi(0xfc00), %g1 2005e94: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005e98: 82 08 c0 01 and %g3, %g1, %g1 2005e9c: 80 a0 40 02 cmp %g1, %g2 2005ea0: 38 80 00 06 bgu,a 2005eb8 2005ea4: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005ea8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005eac: 83 28 60 02 sll %g1, 2, %g1 2005eb0: e0 20 80 01 st %l0, [ %g2 + %g1 ] ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 2005eb4: c6 26 00 00 st %g3, [ %i0 ] 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; 2005eb8: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005ebc: c2 06 60 e0 ld [ %i1 + 0xe0 ], %g1 2005ec0: 10 bf ff de b 2005e38 2005ec4: b0 10 20 00 clr %i0 02005ec8 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 2005ec8: 9d e3 bf 90 save %sp, -112, %sp POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 2005ecc: 80 a6 20 00 cmp %i0, 0 2005ed0: 02 80 00 24 be 2005f60 2005ed4: 11 00 80 6d sethi %hi(0x201b400), %o0 RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get ( pthread_barrier_t *barrier, Objects_Locations *location ) { return (POSIX_Barrier_Control *) _Objects_Get( 2005ed8: d2 06 00 00 ld [ %i0 ], %o1 2005edc: 94 07 bf f4 add %fp, -12, %o2 2005ee0: 40 00 0c d1 call 2009224 <_Objects_Get> 2005ee4: 90 12 21 90 or %o0, 0x190, %o0 return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 2005ee8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005eec: 80 a0 60 00 cmp %g1, 0 2005ef0: 22 80 00 09 be,a 2005f14 2005ef4: d2 02 20 08 ld [ %o0 + 8 ], %o1 2005ef8: 80 a0 60 02 cmp %g1, 2 2005efc: 08 80 00 1a bleu 2005f64 2005f00: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2005f04: 40 00 01 d3 call 2006650 <== NOT EXECUTED 2005f08: 01 00 00 00 nop <== NOT EXECUTED } 2005f0c: 81 c7 e0 08 ret <== NOT EXECUTED 2005f10: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_barrier_Wait( 2005f14: 94 10 20 01 mov 1, %o2 2005f18: 90 02 20 10 add %o0, 0x10, %o0 2005f1c: 96 10 20 00 clr %o3 2005f20: 40 00 08 bb call 200820c <_CORE_barrier_Wait> 2005f24: 98 10 20 00 clr %o4 2005f28: 03 00 80 6c sethi %hi(0x201b000), %g1 2005f2c: c4 00 60 e0 ld [ %g1 + 0xe0 ], %g2 ! 201b0e0 <_Thread_Dispatch_disable_level> 2005f30: 84 00 bf ff add %g2, -1, %g2 2005f34: c4 20 60 e0 st %g2, [ %g1 + 0xe0 ] 2005f38: c6 00 60 e0 ld [ %g1 + 0xe0 ], %g3 2005f3c: 80 a0 e0 00 cmp %g3, 0 2005f40: 02 80 00 0b be 2005f6c 2005f44: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 2005f48: 03 00 80 6c sethi %hi(0x201b000), %g1 <== NOT EXECUTED 2005f4c: c4 00 61 c0 ld [ %g1 + 0x1c0 ], %g2 ! 201b1c0 <_Thread_Executing> 2005f50: 40 00 20 97 call 200e1ac <_POSIX_Barrier_Translate_core_barrier_return_code> 2005f54: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2005f58: 81 c7 e0 08 ret 2005f5c: 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(); 2005f60: 90 10 20 16 mov 0x16, %o0 } 2005f64: 81 c7 e0 08 ret 2005f68: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2005f6c: 40 00 11 a6 call 200a604 <_Thread_Dispatch> 2005f70: 01 00 00 00 nop TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 2005f74: 10 bf ff f6 b 2005f4c 2005f78: 03 00 80 6c sethi %hi(0x201b000), %g1 020053a0 : */ int pthread_cancel( pthread_t thread ) { 20053a0: 9d e3 bf 90 save %sp, -112, %sp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 20053a4: 03 00 80 60 sethi %hi(0x2018000), %g1 20053a8: c4 00 61 18 ld [ %g1 + 0x118 ], %g2 ! 2018118 <_ISR_Nest_level> */ int pthread_cancel( pthread_t thread ) { 20053ac: 92 10 00 18 mov %i0, %o1 /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 20053b0: 80 a0 a0 00 cmp %g2, 0 20053b4: 12 80 00 11 bne 20053f8 20053b8: 90 10 20 47 mov 0x47, %o0 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 20053bc: 11 00 80 60 sethi %hi(0x2018000), %o0 20053c0: 94 07 bf f4 add %fp, -12, %o2 20053c4: 40 00 0d a9 call 2008a68 <_Objects_Get> 20053c8: 90 12 23 38 or %o0, 0x338, %o0 return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 20053cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20053d0: 80 a0 60 01 cmp %g1, 1 20053d4: 02 80 00 22 be 200545c 20053d8: 01 00 00 00 nop 20053dc: 2a 80 00 09 bcs,a 2005400 20053e0: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 20053e4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20053e8: 02 80 00 04 be 20053f8 <== NOT EXECUTED 20053ec: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20053f0: 40 00 02 d9 call 2005f54 <== NOT EXECUTED 20053f4: 01 00 00 00 nop <== NOT EXECUTED } 20053f8: 81 c7 e0 08 ret <== NOT EXECUTED 20053fc: 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; 2005400: 82 10 20 01 mov 1, %g1 if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005404: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 2005408: 80 a0 a0 00 cmp %g2, 0 200540c: 12 80 00 06 bne 2005424 2005410: c2 20 e0 d4 st %g1, [ %g3 + 0xd4 ] 2005414: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 2005418: 80 a0 60 01 cmp %g1, 1 200541c: 02 80 00 14 be 200546c 2005420: 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 ) 2005424: 03 00 80 60 sethi %hi(0x2018000), %g1 2005428: c4 00 60 50 ld [ %g1 + 0x50 ], %g2 ! 2018050 <_Thread_Dispatch_disable_level> 200542c: 90 10 20 00 clr %o0 2005430: 84 00 bf ff add %g2, -1, %g2 2005434: c4 20 60 50 st %g2, [ %g1 + 0x50 ] 2005438: c6 00 60 50 ld [ %g1 + 0x50 ], %g3 200543c: 80 a0 e0 00 cmp %g3, 0 2005440: 12 bf ff ee bne 20053f8 2005444: 01 00 00 00 nop _Thread_Dispatch(); 2005448: 40 00 12 80 call 2009e48 <_Thread_Dispatch> 200544c: 01 00 00 00 nop 2005450: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005454: 81 c7 e0 08 ret 2005458: 91 e8 00 08 restore %g0, %o0, %o0 the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_ERROR: return EINVAL; case OBJECTS_REMOTE: return POSIX_MP_NOT_IMPLEMENTED(); 200545c: 40 00 02 c8 call 2005f7c <== NOT EXECUTED 2005460: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005464: 81 c7 e0 08 ret <== NOT EXECUTED 2005468: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED thread_support->cancelation_requested = 1; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS ) { _POSIX_Threads_cancel_run( the_thread ); 200546c: 40 00 00 03 call 2005478 <_POSIX_Threads_cancel_run> 2005470: 01 00 00 00 nop 2005474: 30 bf ff ec b,a 2005424 02006664 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 2006664: 9d e3 bf 90 save %sp, -112, %sp ) { Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 2006668: 80 a6 20 00 cmp %i0, 0 200666c: 32 80 00 05 bne,a 2006680 2006670: d2 06 00 00 ld [ %i0 ], %o1 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006674: 90 10 20 16 mov 0x16, %o0 } 2006678: 81 c7 e0 08 ret 200667c: 91 e8 00 08 restore %g0, %o0, %o0 *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 2006680: 80 a2 7f ff cmp %o1, -1 2006684: 02 80 00 3d be 2006778 2006688: 90 10 00 18 mov %i0, %o0 /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 200668c: 21 00 80 66 sethi %hi(0x2019800), %l0 2006690: 94 07 bf f4 add %fp, -12, %o2 2006694: 40 00 10 01 call 200a698 <_Objects_Get> 2006698: 90 14 23 3c or %l0, 0x33c, %o0 { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 200669c: c2 07 bf f4 ld [ %fp + -12 ], %g1 20066a0: 80 a0 60 00 cmp %g1, 0 20066a4: 12 80 00 14 bne 20066f4 20066a8: b0 10 00 08 mov %o0, %i0 return EINVAL; case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 20066ac: 40 00 17 92 call 200c4f4 <_Thread_queue_First> 20066b0: 90 02 20 18 add %o0, 0x18, %o0 20066b4: 80 a2 20 00 cmp %o0, 0 20066b8: 02 80 00 15 be 200670c 20066bc: 90 14 23 3c or %l0, 0x33c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20066c0: 03 00 80 65 sethi %hi(0x2019400), %g1 20066c4: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20195f0 <_Thread_Dispatch_disable_level> 20066c8: 90 10 20 10 mov 0x10, %o0 20066cc: 84 00 bf ff add %g2, -1, %g2 20066d0: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 20066d4: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 20066d8: 80 a0 e0 00 cmp %g3, 0 20066dc: 12 bf ff e7 bne 2006678 20066e0: 01 00 00 00 nop _Thread_Dispatch(); 20066e4: 40 00 14 e5 call 200ba78 <_Thread_Dispatch> 20066e8: 01 00 00 00 nop 20066ec: 10 bf ff e3 b 2006678 20066f0: 90 10 20 10 mov 0x10, %o0 ! 10 { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 20066f4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20066f8: 28 bf ff e0 bleu,a 2006678 <== NOT EXECUTED 20066fc: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006700: 40 00 05 3f call 2007bfc <== NOT EXECUTED 2006704: 01 00 00 00 nop <== NOT EXECUTED 2006708: 30 bf ff dc b,a 2006678 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200670c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006710: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2006714: 05 00 00 3f sethi %hi(0xfc00), %g2 2006718: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200671c: 82 08 40 02 and %g1, %g2, %g1 2006720: 80 a0 40 03 cmp %g1, %g3 2006724: 38 80 00 06 bgu,a 200673c 2006728: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200672c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006730: 83 28 60 02 sll %g1, 2, %g1 2006734: 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; 2006738: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free ( POSIX_Condition_variables_Control *the_condition_variable ) { _Objects_Free( 200673c: 40 00 0f 94 call 200a58c <_Objects_Free> 2006740: 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 ) 2006744: 03 00 80 65 sethi %hi(0x2019400), %g1 2006748: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20195f0 <_Thread_Dispatch_disable_level> 200674c: 90 10 20 00 clr %o0 2006750: 84 00 bf ff add %g2, -1, %g2 2006754: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 2006758: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 200675c: 80 a0 e0 00 cmp %g3, 0 2006760: 12 bf ff c6 bne 2006678 2006764: 01 00 00 00 nop _Thread_Dispatch(); 2006768: 40 00 14 c4 call 200ba78 <_Thread_Dispatch> 200676c: 01 00 00 00 nop 2006770: 10 bf ff c2 b 2006678 2006774: 90 10 20 00 clr %o0 ! 0 if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 2006778: 40 00 00 07 call 2006794 <== NOT EXECUTED 200677c: 92 10 20 00 clr %o1 <== NOT EXECUTED if ( status ) { 2006780: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2006784: 12 bf ff bd bne 2006678 <== NOT EXECUTED 2006788: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 200678c: 10 bf ff c0 b 200668c <== NOT EXECUTED 2006790: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 02006794 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 2006794: 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; 2006798: 03 00 80 5d sethi %hi(0x2017400), %g1 int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 200679c: a6 10 00 18 mov %i0, %l3 POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 20067a0: 80 a6 60 00 cmp %i1, 0 20067a4: 02 80 00 03 be 20067b0 20067a8: a0 10 63 7c or %g1, 0x37c, %l0 20067ac: a0 10 00 19 mov %i1, %l0 /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 20067b0: c2 04 20 04 ld [ %l0 + 4 ], %g1 20067b4: 80 a0 60 01 cmp %g1, 1 20067b8: 02 80 00 3d be 20068ac 20067bc: 01 00 00 00 nop return POSIX_MP_NOT_IMPLEMENTED(); if ( !the_attr->is_initialized ) 20067c0: c2 04 00 00 ld [ %l0 ], %g1 20067c4: 80 a0 60 00 cmp %g1, 0 20067c8: 02 80 00 16 be 2006820 20067cc: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20067d0: 23 00 80 65 sethi %hi(0x2019400), %l1 20067d4: c2 04 61 f0 ld [ %l1 + 0x1f0 ], %g1 ! 20195f0 <_Thread_Dispatch_disable_level> 20067d8: 82 00 60 01 inc %g1 20067dc: c2 24 61 f0 st %g1, [ %l1 + 0x1f0 ] */ RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) 20067e0: 25 00 80 66 sethi %hi(0x2019800), %l2 20067e4: 40 00 0e 5c call 200a154 <_Objects_Allocate> 20067e8: 90 14 a3 3c or %l2, 0x33c, %o0 ! 2019b3c <_POSIX_Condition_variables_Information> _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 20067ec: b2 92 20 00 orcc %o0, 0, %i1 20067f0: 32 80 00 0e bne,a 2006828 20067f4: c2 04 20 04 ld [ %l0 + 4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20067f8: c2 04 61 f0 ld [ %l1 + 0x1f0 ], %g1 20067fc: b0 10 20 0c mov 0xc, %i0 2006800: 82 00 7f ff add %g1, -1, %g1 2006804: c2 24 61 f0 st %g1, [ %l1 + 0x1f0 ] 2006808: c4 04 61 f0 ld [ %l1 + 0x1f0 ], %g2 200680c: 80 a0 a0 00 cmp %g2, 0 2006810: 12 80 00 25 bne 20068a4 2006814: 01 00 00 00 nop _Thread_Dispatch(); 2006818: 40 00 14 98 call 200ba78 <_Thread_Dispatch> 200681c: 01 00 00 00 nop 2006820: 81 c7 e0 08 ret 2006824: 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( 2006828: 90 06 60 18 add %i1, 0x18, %o0 _Thread_Enable_dispatch(); return EAGAIN; } #endif the_cond->process_shared = the_attr->process_shared; 200682c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 2006830: c0 26 60 14 clr [ %i1 + 0x14 ] /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 2006834: 92 10 20 00 clr %o1 2006838: 94 10 28 00 mov 0x800, %o2 200683c: 40 00 17 58 call 200c59c <_Thread_queue_Initialize> 2006840: 96 10 20 74 mov 0x74, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006844: 90 14 a3 3c or %l2, 0x33c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2006848: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200684c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2006850: 03 00 00 3f sethi %hi(0xfc00), %g1 2006854: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006858: 82 08 c0 01 and %g3, %g1, %g1 200685c: 80 a0 40 02 cmp %g1, %g2 2006860: 38 80 00 06 bgu,a 2006878 2006864: c6 24 c0 00 st %g3, [ %l3 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2006868: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200686c: 83 28 60 02 sll %g1, 2, %g1 2006870: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 2006874: c6 24 c0 00 st %g3, [ %l3 ] 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; 2006878: c0 26 60 0c clr [ %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 ) 200687c: c2 04 61 f0 ld [ %l1 + 0x1f0 ], %g1 2006880: b0 10 20 00 clr %i0 2006884: 82 00 7f ff add %g1, -1, %g1 2006888: c2 24 61 f0 st %g1, [ %l1 + 0x1f0 ] 200688c: c4 04 61 f0 ld [ %l1 + 0x1f0 ], %g2 2006890: 80 a0 a0 00 cmp %g2, 0 2006894: 12 80 00 04 bne 20068a4 2006898: 01 00 00 00 nop _Thread_Dispatch(); 200689c: 40 00 14 77 call 200ba78 <_Thread_Dispatch> 20068a0: 01 00 00 00 nop #endif _Thread_Enable_dispatch(); return 0; } 20068a4: 81 c7 e0 08 ret 20068a8: 81 e8 00 00 restore /* * XXX: Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return POSIX_MP_NOT_IMPLEMENTED(); 20068ac: 40 00 04 de call 2007c24 <== NOT EXECUTED 20068b0: 81 e8 00 00 restore <== NOT EXECUTED 20068b4: 01 00 00 00 nop 02006610 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 2006610: 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; 2006614: 03 00 80 6d sethi %hi(0x201b400), %g1 pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 2006618: 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; 200661c: 80 a6 60 00 cmp %i1, 0 2006620: 02 80 00 03 be 200662c 2006624: a2 10 63 e8 or %g1, 0x3e8, %l1 2006628: a2 10 00 19 mov %i1, %l1 if ( !the_attr->is_initialized ) 200662c: c2 04 40 00 ld [ %l1 ], %g1 2006630: 80 a0 60 00 cmp %g1, 0 2006634: 02 80 00 10 be 2006674 2006638: 01 00 00 00 nop /* * 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 ) ) 200663c: c2 04 60 04 ld [ %l1 + 4 ], %g1 2006640: 80 a0 60 00 cmp %g1, 0 2006644: 22 80 00 07 be,a 2006660 2006648: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 200664c: c2 04 60 08 ld [ %l1 + 8 ], %g1 2006650: 80 a0 6f ff cmp %g1, 0xfff 2006654: 08 80 00 08 bleu 2006674 2006658: 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 ) { 200665c: c2 04 60 10 ld [ %l1 + 0x10 ], %g1 <== NOT EXECUTED 2006660: 80 a0 60 01 cmp %g1, 1 2006664: 02 80 00 34 be 2006734 2006668: 80 a0 60 02 cmp %g1, 2 200666c: 22 80 00 04 be,a 200667c 2006670: c4 04 60 18 ld [ %l1 + 0x18 ], %g2 2006674: 81 c7 e0 08 ret 2006678: 91 e8 20 16 restore %g0, 0x16, %o0 schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 200667c: f2 04 60 14 ld [ %l1 + 0x14 ], %i1 schedparam = the_attr->schedparam; 2006680: c4 27 bf e0 st %g2, [ %fp + -32 ] 2006684: c2 04 60 1c ld [ %l1 + 0x1c ], %g1 2006688: c2 27 bf e4 st %g1, [ %fp + -28 ] 200668c: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 2006690: c4 27 bf e8 st %g2, [ %fp + -24 ] 2006694: c2 04 60 24 ld [ %l1 + 0x24 ], %g1 2006698: c2 27 bf ec st %g1, [ %fp + -20 ] 200669c: c4 04 60 28 ld [ %l1 + 0x28 ], %g2 20066a0: c4 27 bf f0 st %g2, [ %fp + -16 ] 20066a4: c2 04 60 2c ld [ %l1 + 0x2c ], %g1 20066a8: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 20066ac: c2 04 60 0c ld [ %l1 + 0xc ], %g1 20066b0: 80 a0 60 00 cmp %g1, 0 20066b4: 12 80 00 1e bne 200672c 20066b8: b0 10 20 86 mov 0x86, %i0 /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 20066bc: e6 07 bf e0 ld [ %fp + -32 ], %l3 20066c0: 82 04 ff ff add %l3, -1, %g1 20066c4: 80 a0 60 fd cmp %g1, 0xfd 20066c8: 18 bf ff eb bgu 2006674 20066cc: 80 a6 60 01 cmp %i1, 1 */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20066d0: 02 80 00 41 be 20067d4 20066d4: a8 10 20 00 clr %l4 20066d8: 04 80 00 41 ble 20067dc 20066dc: 80 a6 60 02 cmp %i1, 2 20066e0: 02 80 00 26 be 2006778 20066e4: 80 a6 60 03 cmp %i1, 3 20066e8: 12 bf ff e3 bne 2006674 20066ec: 01 00 00 00 nop 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 ) < 20066f0: 40 00 17 9b call 200c55c <_Timespec_To_ticks> 20066f4: 90 07 bf e8 add %fp, -24, %o0 20066f8: a0 10 00 08 mov %o0, %l0 20066fc: 40 00 17 98 call 200c55c <_Timespec_To_ticks> 2006700: 90 07 bf f0 add %fp, -16, %o0 2006704: 80 a4 00 08 cmp %l0, %o0 2006708: 0a bf ff db bcs 2006674 200670c: 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 ) ) 2006710: 82 00 7f ff add %g1, -1, %g1 2006714: 80 a0 60 fd cmp %g1, 0xfd 2006718: 18 bf ff d7 bgu 2006674 200671c: 03 00 80 1b sethi %hi(0x2006c00), %g1 2006720: a8 10 20 03 mov 3, %l4 2006724: 10 80 00 17 b 2006780 2006728: b0 10 61 9c or %g1, 0x19c, %i0 *thread = the_thread->Object.id; _Thread_Enable_dispatch(); return 0; } 200672c: 81 c7 e0 08 ret 2006730: 81 e8 00 00 restore * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2006734: 03 00 80 76 sethi %hi(0x201d800), %g1 2006738: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 201d820 <_Thread_Executing> 200673c: c6 00 a1 74 ld [ %g2 + 0x174 ], %g3 schedpolicy = api->schedpolicy; schedparam = api->schedparam; 2006740: c8 00 e0 80 ld [ %g3 + 0x80 ], %g4 */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; schedpolicy = api->schedpolicy; 2006744: f2 00 e0 7c ld [ %g3 + 0x7c ], %i1 schedparam = api->schedparam; 2006748: c8 27 bf e0 st %g4, [ %fp + -32 ] 200674c: c2 00 e0 84 ld [ %g3 + 0x84 ], %g1 2006750: c2 27 bf e4 st %g1, [ %fp + -28 ] 2006754: c4 00 e0 88 ld [ %g3 + 0x88 ], %g2 2006758: c4 27 bf e8 st %g2, [ %fp + -24 ] 200675c: c2 00 e0 8c ld [ %g3 + 0x8c ], %g1 2006760: c2 27 bf ec st %g1, [ %fp + -20 ] 2006764: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 2006768: c4 27 bf f0 st %g2, [ %fp + -16 ] 200676c: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 2006770: 10 bf ff cf b 20066ac 2006774: c2 27 bf f4 st %g1, [ %fp + -12 ] */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 2006778: a8 10 20 02 mov 2, %l4 <== NOT EXECUTED 200677c: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006780: 25 00 80 75 sethi %hi(0x201d400), %l2 2006784: c2 04 a3 40 ld [ %l2 + 0x340 ], %g1 ! 201d740 <_Thread_Dispatch_disable_level> 2006788: 82 00 60 01 inc %g1 200678c: c2 24 a3 40 st %g1, [ %l2 + 0x340 ] * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 2006790: 2b 00 80 76 sethi %hi(0x201d800), %l5 2006794: 40 00 0c 4d call 20098c8 <_Objects_Allocate> 2006798: 90 15 62 28 or %l5, 0x228, %o0 ! 201da28 <_POSIX_Threads_Information> * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 200679c: a0 92 20 00 orcc %o0, 0, %l0 20067a0: 32 80 00 14 bne,a 20067f0 20067a4: d4 04 60 04 ld [ %l1 + 4 ], %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20067a8: c2 04 a3 40 ld [ %l2 + 0x340 ], %g1 20067ac: 82 00 7f ff add %g1, -1, %g1 20067b0: c2 24 a3 40 st %g1, [ %l2 + 0x340 ] 20067b4: c4 04 a3 40 ld [ %l2 + 0x340 ], %g2 20067b8: 80 a0 a0 00 cmp %g2, 0 20067bc: 12 bf ff dc bne 200672c 20067c0: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 20067c4: 40 00 12 8a call 200b1ec <_Thread_Dispatch> 20067c8: 01 00 00 00 nop 20067cc: 81 c7 e0 08 ret 20067d0: 81 e8 00 00 restore */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 20067d4: 10 bf ff eb b 2006780 20067d8: b0 10 20 00 clr %i0 20067dc: 80 a6 60 00 cmp %i1, 0 20067e0: a8 10 20 01 mov 1, %l4 20067e4: 02 bf ff e7 be 2006780 20067e8: b0 10 20 00 clr %i0 20067ec: 30 bf ff a2 b,a 2006674 /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 20067f0: d6 04 60 08 ld [ %l1 + 8 ], %o3 20067f4: 9a 10 20 ff mov 0xff, %o5 20067f8: e8 23 a0 60 st %l4, [ %sp + 0x60 ] 20067fc: f0 23 a0 64 st %i0, [ %sp + 0x64 ] 2006800: c0 23 a0 68 clr [ %sp + 0x68 ] 2006804: c0 23 a0 6c clr [ %sp + 0x6c ] 2006808: 9a 23 40 13 sub %o5, %l3, %o5 200680c: a8 10 20 01 mov 1, %l4 2006810: 90 15 62 28 or %l5, 0x228, %o0 2006814: e8 23 a0 5c st %l4, [ %sp + 0x5c ] 2006818: 92 10 00 10 mov %l0, %o1 200681c: 40 00 12 ef call 200b3d8 <_Thread_Initialize> 2006820: 98 10 20 01 mov 1, %o4 budget_callout, 0, /* isr level */ NULL /* posix threads don't have a name */ ); if ( !status ) { 2006824: 80 a2 20 00 cmp %o0, 0 2006828: 12 80 00 05 bne 200683c 200682c: 90 15 62 28 or %l5, 0x228, %o0 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 2006830: 40 00 0d 34 call 2009d00 <_Objects_Free> 2006834: 92 10 00 10 mov %l0, %o1 2006838: 30 bf ff dc b,a 20067a8 /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 200683c: e6 04 21 74 ld [ %l0 + 0x174 ], %l3 api->Attributes = *the_attr; 2006840: 92 10 00 11 mov %l1, %o1 2006844: 94 10 20 38 mov 0x38, %o2 2006848: 40 00 2a ff call 2011444 200684c: 90 10 00 13 mov %l3, %o0 api->detachstate = the_attr->detachstate; 2006850: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 api->schedpolicy = schedpolicy; 2006854: f2 24 e0 7c st %i1, [ %l3 + 0x7c ] api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; 2006858: c2 24 e0 38 st %g1, [ %l3 + 0x38 ] api->schedpolicy = schedpolicy; api->schedparam = schedparam; 200685c: c2 07 bf e0 ld [ %fp + -32 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006860: 94 10 00 1a mov %i2, %o2 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006864: c2 24 e0 80 st %g1, [ %l3 + 0x80 ] 2006868: c2 07 bf e4 ld [ %fp + -28 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 200686c: 96 10 00 1b mov %i3, %o3 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006870: c2 24 e0 84 st %g1, [ %l3 + 0x84 ] 2006874: c2 07 bf e8 ld [ %fp + -24 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006878: 90 10 00 10 mov %l0, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 200687c: c2 24 e0 88 st %g1, [ %l3 + 0x88 ] 2006880: c2 07 bf ec ld [ %fp + -20 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006884: 92 10 20 01 mov 1, %o1 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006888: c2 24 e0 8c st %g1, [ %l3 + 0x8c ] 200688c: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 2006890: 98 10 20 00 clr %o4 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->Attributes = *the_attr; api->detachstate = the_attr->detachstate; api->schedpolicy = schedpolicy; api->schedparam = schedparam; 2006894: c2 24 e0 90 st %g1, [ %l3 + 0x90 ] 2006898: c4 07 bf f4 ld [ %fp + -12 ], %g2 200689c: c4 24 e0 94 st %g2, [ %l3 + 0x94 ] /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 20068a0: 40 00 16 72 call 200c268 <_Thread_Start> 20068a4: e8 24 20 78 st %l4, [ %l0 + 0x78 ] start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 20068a8: 80 a6 60 03 cmp %i1, 3 20068ac: 02 80 00 12 be 20068f4 20068b0: a2 10 00 08 mov %o0, %l1 /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 20068b4: 80 a4 60 00 cmp %l1, 0 20068b8: 12 80 00 18 bne 2006918 20068bc: 90 15 62 28 or %l5, 0x228, %o0 20068c0: 40 00 0d 10 call 2009d00 <_Objects_Free> <== NOT EXECUTED 20068c4: 92 10 00 10 mov %l0, %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 ) 20068c8: c2 04 a3 40 ld [ %l2 + 0x340 ], %g1 <== NOT EXECUTED 20068cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20068d0: c2 24 a3 40 st %g1, [ %l2 + 0x340 ] <== NOT EXECUTED 20068d4: c4 04 a3 40 ld [ %l2 + 0x340 ], %g2 <== NOT EXECUTED 20068d8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20068dc: 12 bf ff 66 bne 2006674 <== NOT EXECUTED 20068e0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20068e4: 40 00 12 42 call 200b1ec <_Thread_Dispatch> <== NOT EXECUTED 20068e8: b0 10 20 16 mov 0x16, %i0 ! 16 <== NOT EXECUTED 20068ec: 81 c7 e0 08 ret <== NOT EXECUTED 20068f0: 81 e8 00 00 restore <== NOT EXECUTED arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 20068f4: 40 00 17 1a call 200c55c <_Timespec_To_ticks> 20068f8: 90 04 e0 88 add %l3, 0x88, %o0 20068fc: 92 04 e0 9c add %l3, 0x9c, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006900: d0 24 e0 a8 st %o0, [ %l3 + 0xa8 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006904: 11 00 80 76 sethi %hi(0x201d800), %o0 2006908: 40 00 18 28 call 200c9a8 <_Watchdog_Insert> 200690c: 90 12 20 40 or %o0, 0x40, %o0 ! 201d840 <_Watchdog_Ticks_chain> /* * _Thread_Start only fails if the thread was in the incorrect state */ if ( !status ) { 2006910: 10 bf ff ea b 20068b8 2006914: 80 a4 60 00 cmp %l1, 0 /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 2006918: c2 04 20 08 ld [ %l0 + 8 ], %g1 200691c: c2 25 80 00 st %g1, [ %l6 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006920: c2 04 a3 40 ld [ %l2 + 0x340 ], %g1 2006924: b0 10 20 00 clr %i0 2006928: 82 00 7f ff add %g1, -1, %g1 200692c: c2 24 a3 40 st %g1, [ %l2 + 0x340 ] 2006930: c4 04 a3 40 ld [ %l2 + 0x340 ], %g2 2006934: 80 a0 a0 00 cmp %g2, 0 2006938: 12 80 00 04 bne 2006948 200693c: 01 00 00 00 nop _Thread_Dispatch(); 2006940: 40 00 12 2b call 200b1ec <_Thread_Dispatch> 2006944: 01 00 00 00 nop 2006948: 81 c7 e0 08 ret 200694c: 81 e8 00 00 restore 02005cd0 : #include int pthread_detach( pthread_t thread ) { 2005cd0: 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 *) 2005cd4: 11 00 80 60 sethi %hi(0x2018000), %o0 2005cd8: 92 10 00 18 mov %i0, %o1 2005cdc: 90 12 21 98 or %o0, 0x198, %o0 2005ce0: 40 00 0c 93 call 2008f2c <_Objects_Get> 2005ce4: 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 ) { 2005ce8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cec: 80 a0 60 00 cmp %g1, 0 2005cf0: 12 80 00 0f bne 2005d2c 2005cf4: 80 a0 60 02 cmp %g1, 2 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 2005cf8: c2 02 21 74 ld [ %o0 + 0x174 ], %g1 2005cfc: 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 ) 2005d00: 07 00 80 5f sethi %hi(0x2017c00), %g3 2005d04: c2 00 e2 b0 ld [ %g3 + 0x2b0 ], %g1 ! 2017eb0 <_Thread_Dispatch_disable_level> 2005d08: 90 10 20 00 clr %o0 2005d0c: 82 00 7f ff add %g1, -1, %g1 2005d10: c2 20 e2 b0 st %g1, [ %g3 + 0x2b0 ] 2005d14: c4 00 e2 b0 ld [ %g3 + 0x2b0 ], %g2 2005d18: 80 a0 a0 00 cmp %g2, 0 2005d1c: 02 80 00 0a be 2005d44 2005d20: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005d24: 81 c7 e0 08 ret 2005d28: 91 e8 00 08 restore %g0, %o0, %o0 register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2005d2c: 08 bf ff fe bleu 2005d24 2005d30: 90 10 20 03 mov 3, %o0 api->detachstate = PTHREAD_CREATE_DETACHED; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005d34: 40 00 01 c6 call 200644c <== NOT EXECUTED 2005d38: 01 00 00 00 nop <== NOT EXECUTED } 2005d3c: 81 c7 e0 08 ret <== NOT EXECUTED 2005d40: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2005d44: 40 00 11 72 call 200a30c <_Thread_Dispatch> 2005d48: 01 00 00 00 nop 2005d4c: 90 10 20 00 clr %o0 ! 0 2005d50: 81 c7 e0 08 ret 2005d54: 91 e8 00 08 restore %g0, %o0, %o0 0200e918 : #include void pthread_exit( void *value_ptr ) { 200e918: 9d e3 bf 98 save %sp, -104, %sp Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); 200e91c: 25 00 80 66 sethi %hi(0x2019800), %l2 200e920: c2 04 a1 20 ld [ %l2 + 0x120 ], %g1 ! 2019920 <_Thread_Executing> 200e924: 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 ]; 200e928: 03 00 80 65 sethi %hi(0x2019400), %g1 200e92c: 85 30 e0 16 srl %g3, 0x16, %g2 200e930: 82 10 63 a0 or %g1, 0x3a0, %g1 200e934: 84 08 a0 1c and %g2, 0x1c, %g2 200e938: c8 00 40 02 ld [ %g1 + %g2 ], %g4 200e93c: 87 30 e0 1b srl %g3, 0x1b, %g3 200e940: 87 28 e0 02 sll %g3, 2, %g3 200e944: e2 01 00 03 ld [ %g4 + %g3 ], %l1 /* This should never happen if _Thread_Get() works right */ assert( the_information ); 200e948: 80 a4 60 00 cmp %l1, 0 200e94c: 22 80 00 19 be,a 200e9b0 200e950: 11 00 80 5f sethi %hi(0x2017c00), %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e954: 21 00 80 66 sethi %hi(0x2019800), %l0 200e958: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 200e95c: 82 00 60 01 inc %g1 200e960: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _Thread_Disable_dispatch(); _Thread_Executing->Wait.return_argument = value_ptr; 200e964: d2 04 a1 20 ld [ %l2 + 0x120 ], %o1 _Thread_Close( the_information, _Thread_Executing ); 200e968: 90 10 00 11 mov %l1, %o0 200e96c: 7f ff e9 c2 call 2009074 <_Thread_Close> 200e970: 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 ); 200e974: d2 04 a1 20 ld [ %l2 + 0x120 ], %o1 200e978: 11 00 80 66 sethi %hi(0x2019800), %o0 200e97c: 7f ff e4 d1 call 2007cc0 <_Objects_Free> 200e980: 90 12 23 28 or %o0, 0x328, %o0 ! 2019b28 <_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 ) 200e984: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 200e988: 82 00 7f ff add %g1, -1, %g1 200e98c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 200e990: c4 04 20 40 ld [ %l0 + 0x40 ], %g2 200e994: 80 a0 a0 00 cmp %g2, 0 200e998: 02 80 00 04 be 200e9a8 200e99c: 01 00 00 00 nop 200e9a0: 81 c7 e0 08 ret <== NOT EXECUTED 200e9a4: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200e9a8: 7f ff ea 3d call 200929c <_Thread_Dispatch> 200e9ac: 81 e8 00 00 restore Objects_Information *the_information; the_information = _Objects_Get_information( _Thread_Executing->Object.id ); /* This should never happen if _Thread_Get() works right */ assert( the_information ); 200e9b0: 15 00 80 5f sethi %hi(0x2017c00), %o2 <== NOT EXECUTED 200e9b4: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED 200e9b8: 94 12 a1 f8 or %o2, 0x1f8, %o2 <== NOT EXECUTED 200e9bc: 7f ff cd 7c call 2001fac <__assert> <== NOT EXECUTED 200e9c0: 92 10 20 25 mov 0x25, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200e9c4: 10 bf ff e5 b 200e958 <== NOT EXECUTED 200e9c8: 21 00 80 66 sethi %hi(0x2019800), %l0 <== NOT EXECUTED 0200835c : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 200835c: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 2008360: 80 a6 60 00 cmp %i1, 0 2008364: 02 80 00 33 be 2008430 2008368: 92 10 00 18 mov %i0, %o1 200836c: 80 a6 a0 00 cmp %i2, 0 2008370: 02 80 00 30 be 2008430 2008374: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2008378: 11 00 80 6d sethi %hi(0x201b400), %o0 200837c: 40 00 0c af call 200b638 <_Objects_Get> 2008380: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 201b7d8 <_POSIX_Threads_Information> return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008384: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008388: 80 a0 60 00 cmp %g1, 0 200838c: 22 80 00 09 be,a 20083b0 2008390: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 2008394: 80 a0 60 02 cmp %g1, 2 2008398: 08 80 00 04 bleu 20083a8 200839c: 90 10 20 03 mov 3, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20083a0: 40 00 01 ee call 2008b58 <== NOT EXECUTED 20083a4: 01 00 00 00 nop <== NOT EXECUTED } 20083a8: 81 c7 e0 08 ret 20083ac: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( policy ) *policy = api->schedpolicy; 20083b0: c2 00 e0 7c ld [ %g3 + 0x7c ], %g1 20083b4: c2 26 40 00 st %g1, [ %i1 ] if ( param ) { *param = api->schedparam; 20083b8: c4 00 e0 80 ld [ %g3 + 0x80 ], %g2 20083bc: c4 26 80 00 st %g2, [ %i2 ] 20083c0: c2 00 e0 84 ld [ %g3 + 0x84 ], %g1 20083c4: c2 26 a0 04 st %g1, [ %i2 + 4 ] 20083c8: c4 00 e0 88 ld [ %g3 + 0x88 ], %g2 20083cc: c4 26 a0 08 st %g2, [ %i2 + 8 ] 20083d0: c2 00 e0 8c ld [ %g3 + 0x8c ], %g1 20083d4: c2 26 a0 0c st %g1, [ %i2 + 0xc ] 20083d8: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 20083dc: c4 26 a0 10 st %g2, [ %i2 + 0x10 ] 20083e0: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 20083e4: c2 26 a0 14 st %g1, [ %i2 + 0x14 ] param->sched_priority = 20083e8: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 20083ec: 82 10 20 ff mov 0xff, %g1 20083f0: 82 20 40 02 sub %g1, %g2, %g1 20083f4: 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 ) 20083f8: 07 00 80 6d sethi %hi(0x201b400), %g3 20083fc: c2 00 e0 f0 ld [ %g3 + 0xf0 ], %g1 ! 201b4f0 <_Thread_Dispatch_disable_level> 2008400: 90 10 20 00 clr %o0 2008404: 82 00 7f ff add %g1, -1, %g1 2008408: c2 20 e0 f0 st %g1, [ %g3 + 0xf0 ] 200840c: c4 00 e0 f0 ld [ %g3 + 0xf0 ], %g2 2008410: 80 a0 a0 00 cmp %g2, 0 2008414: 12 bf ff e5 bne 20083a8 2008418: 01 00 00 00 nop _Thread_Dispatch(); 200841c: 40 00 11 7f call 200ca18 <_Thread_Dispatch> 2008420: 01 00 00 00 nop 2008424: 90 10 20 00 clr %o0 ! 0 return 0; } return POSIX_BOTTOM_REACHED(); } 2008428: 81 c7 e0 08 ret 200842c: 91 e8 00 08 restore %g0, %o0, %o0 { Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 2008430: 10 bf ff de b 20083a8 2008434: 90 10 20 16 mov 0x16, %o0 02005cbc : */ void *pthread_getspecific( pthread_key_t key ) { 2005cbc: 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 *) 2005cc0: 11 00 80 61 sethi %hi(0x2018400), %o0 2005cc4: 92 10 00 18 mov %i0, %o1 2005cc8: 90 12 21 f0 or %o0, 0x1f0, %o0 2005ccc: 40 00 0d 4b call 20091f8 <_Objects_Get> 2005cd0: 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 ) { 2005cd4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cd8: 80 a0 60 00 cmp %g1, 0 2005cdc: 12 80 00 18 bne 2005d3c 2005ce0: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return NULL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 2005ce4: 03 00 80 60 sethi %hi(0x2018000), %g1 2005ce8: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20181d0 <_Thread_Executing> 2005cec: c6 00 a0 08 ld [ %g2 + 8 ], %g3 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 2005cf0: 05 00 00 3f sethi %hi(0xfc00), %g2 2005cf4: 83 30 e0 16 srl %g3, 0x16, %g1 2005cf8: 82 08 60 1c and %g1, 0x1c, %g1 2005cfc: 82 00 40 08 add %g1, %o0, %g1 2005d00: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 2005d04: 84 10 a3 ff or %g2, 0x3ff, %g2 2005d08: 86 08 c0 02 and %g3, %g2, %g3 2005d0c: 87 28 e0 02 sll %g3, 2, %g3 2005d10: f0 01 00 03 ld [ %g4 + %g3 ], %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005d14: 05 00 80 60 sethi %hi(0x2018000), %g2 2005d18: c2 00 a0 f0 ld [ %g2 + 0xf0 ], %g1 ! 20180f0 <_Thread_Dispatch_disable_level> 2005d1c: 82 00 7f ff add %g1, -1, %g1 2005d20: c2 20 a0 f0 st %g1, [ %g2 + 0xf0 ] 2005d24: c6 00 a0 f0 ld [ %g2 + 0xf0 ], %g3 2005d28: 80 a0 e0 00 cmp %g3, 0 2005d2c: 02 80 00 0a be 2005d54 2005d30: 01 00 00 00 nop _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); return (void *)NULL; } 2005d34: 81 c7 e0 08 ret 2005d38: 81 e8 00 00 restore uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 2005d3c: 08 bf ff fe bleu 2005d34 2005d40: b0 10 20 00 clr %i0 index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; _Thread_Enable_dispatch(); return key_data; } (void) POSIX_BOTTOM_REACHED(); 2005d44: 40 00 02 75 call 2006718 <== NOT EXECUTED 2005d48: 01 00 00 00 nop <== NOT EXECUTED return (void *)NULL; } 2005d4c: 81 c7 e0 08 ret <== NOT EXECUTED 2005d50: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2005d54: 40 00 12 21 call 200a5d8 <_Thread_Dispatch> 2005d58: 01 00 00 00 nop 2005d5c: 81 c7 e0 08 ret 2005d60: 81 e8 00 00 restore 0200782c : int pthread_join( pthread_t thread, void **value_ptr ) { 200782c: 9d e3 bf 90 save %sp, -112, %sp 2007830: 11 00 80 6a sethi %hi(0x201a800), %o0 2007834: 92 10 00 18 mov %i0, %o1 2007838: 90 12 20 d8 or %o0, 0xd8, %o0 200783c: 40 00 0c 64 call 200a9cc <_Objects_Get> 2007840: 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 ) { 2007844: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007848: 80 a0 60 00 cmp %g1, 0 200784c: 12 80 00 15 bne 20078a0 2007850: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2007854: c6 02 21 74 ld [ %o0 + 0x174 ], %g3 if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 2007858: c2 00 e0 38 ld [ %g3 + 0x38 ], %g1 200785c: 80 a0 60 00 cmp %g1, 0 2007860: 12 80 00 16 bne 20078b8 2007864: 03 00 80 69 sethi %hi(0x201a400), %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007868: 03 00 80 69 sethi %hi(0x201a400), %g1 200786c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 201a5f0 <_Thread_Dispatch_disable_level> 2007870: 90 10 20 16 mov 0x16, %o0 2007874: 84 00 bf ff add %g2, -1, %g2 2007878: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 200787c: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 2007880: 80 a0 e0 00 cmp %g3, 0 2007884: 12 80 00 05 bne 2007898 2007888: 01 00 00 00 nop _Thread_Dispatch(); 200788c: 40 00 11 48 call 200bdac <_Thread_Dispatch> 2007890: 01 00 00 00 nop 2007894: 90 10 20 16 mov 0x16, %o0 ! 16 *value_ptr = return_pointer; return 0; } return POSIX_BOTTOM_REACHED(); } 2007898: 81 c7 e0 08 ret 200789c: 91 e8 00 08 restore %g0, %o0, %o0 POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 20078a0: 08 bf ff fe bleu 2007898 20078a4: 90 10 20 03 mov 3, %o0 if ( value_ptr ) *value_ptr = return_pointer; return 0; } return POSIX_BOTTOM_REACHED(); 20078a8: 40 00 01 91 call 2007eec <== NOT EXECUTED 20078ac: 01 00 00 00 nop <== NOT EXECUTED } 20078b0: 81 c7 e0 08 ret <== NOT EXECUTED 20078b4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Thread_Is_executing ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Executing ); 20078b8: c4 00 62 d0 ld [ %g1 + 0x2d0 ], %g2 if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 20078bc: 80 a2 00 02 cmp %o0, %g2 20078c0: 12 80 00 0f bne 20078fc 20078c4: 82 07 bf f0 add %fp, -16, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20078c8: 03 00 80 69 sethi %hi(0x201a400), %g1 20078cc: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 201a5f0 <_Thread_Dispatch_disable_level> 20078d0: 90 10 20 2d mov 0x2d, %o0 20078d4: 84 00 bf ff add %g2, -1, %g2 20078d8: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ] 20078dc: c6 00 61 f0 ld [ %g1 + 0x1f0 ], %g3 20078e0: 80 a0 e0 00 cmp %g3, 0 20078e4: 12 bf ff ed bne 2007898 20078e8: 01 00 00 00 nop _Thread_Dispatch(); 20078ec: 40 00 11 30 call 200bdac <_Thread_Dispatch> 20078f0: 01 00 00 00 nop 20078f4: 10 bf ff e9 b 2007898 20078f8: 90 10 20 2d mov 0x2d, %o0 ! 2d /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 20078fc: c2 20 a0 28 st %g1, [ %g2 + 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; 2007900: 84 10 20 01 mov 1, %g2 _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 2007904: 90 00 e0 3c add %g3, 0x3c, %o0 2007908: c4 20 e0 6c st %g2, [ %g3 + 0x6c ] 200790c: 92 10 20 00 clr %o1 2007910: 15 00 80 32 sethi %hi(0x200c800), %o2 2007914: 40 00 12 bf call 200c410 <_Thread_queue_Enqueue_with_handler> 2007918: 94 12 a1 50 or %o2, 0x150, %o2 ! 200c950 <_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 ) 200791c: 05 00 80 69 sethi %hi(0x201a400), %g2 2007920: c2 00 a1 f0 ld [ %g2 + 0x1f0 ], %g1 ! 201a5f0 <_Thread_Dispatch_disable_level> 2007924: 82 00 7f ff add %g1, -1, %g1 2007928: c2 20 a1 f0 st %g1, [ %g2 + 0x1f0 ] 200792c: c6 00 a1 f0 ld [ %g2 + 0x1f0 ], %g3 2007930: 80 a0 e0 00 cmp %g3, 0 2007934: 12 80 00 05 bne 2007948 2007938: 80 a6 60 00 cmp %i1, 0 _Thread_Dispatch(); 200793c: 40 00 11 1c call 200bdac <_Thread_Dispatch> 2007940: 01 00 00 00 nop _Thread_Enable_dispatch(); if ( value_ptr ) 2007944: 80 a6 60 00 cmp %i1, 0 2007948: 02 bf ff d4 be 2007898 200794c: 90 10 20 00 clr %o0 *value_ptr = return_pointer; 2007950: c2 07 bf f0 ld [ %fp + -16 ], %g1 2007954: 10 bf ff d1 b 2007898 2007958: c2 26 40 00 st %g1, [ %i1 ] 02005a2c : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 2005a2c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005a30: 25 00 80 60 sethi %hi(0x2018000), %l2 2005a34: c2 04 a0 f0 ld [ %l2 + 0xf0 ], %g1 ! 20180f0 <_Thread_Dispatch_disable_level> 2005a38: 82 00 60 01 inc %g1 2005a3c: c2 24 a0 f0 st %g1, [ %l2 + 0xf0 ] * _POSIX_Keys_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 2005a40: 29 00 80 61 sethi %hi(0x2018400), %l4 2005a44: 40 00 0c 9c call 2008cb4 <_Objects_Allocate> 2005a48: 90 15 21 f0 or %l4, 0x1f0, %o0 ! 20185f0 <_POSIX_Keys_Information> _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 2005a4c: a0 92 20 00 orcc %o0, 0, %l0 2005a50: 32 80 00 0e bne,a 2005a88 2005a54: f2 24 20 14 st %i1, [ %l0 + 0x14 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005a58: c2 04 a0 f0 ld [ %l2 + 0xf0 ], %g1 2005a5c: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 2005a60: 82 00 7f ff add %g1, -1, %g1 2005a64: c2 24 a0 f0 st %g1, [ %l2 + 0xf0 ] 2005a68: c4 04 a0 f0 ld [ %l2 + 0xf0 ], %g2 2005a6c: 80 a0 a0 00 cmp %g2, 0 2005a70: 12 80 00 3d bne 2005b64 2005a74: 01 00 00 00 nop 2005a78: 40 00 12 d8 call 200a5d8 <_Thread_Dispatch> 2005a7c: 01 00 00 00 nop 2005a80: 81 c7 e0 08 ret 2005a84: 81 e8 00 00 restore 2005a88: 03 00 80 60 sethi %hi(0x2018000), %g1 RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2005a8c: 2f 00 80 60 sethi %hi(0x2018000), %l7 2005a90: ac 10 60 50 or %g1, 0x50, %l6 _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 2005a94: b2 10 00 10 mov %l0, %i1 2005a98: a6 10 20 01 mov 1, %l3 2005a9c: aa 15 e1 3c or %l7, 0x13c, %l5 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] && 2005aa0: 83 2c e0 02 sll %l3, 2, %g1 2005aa4: c2 00 40 16 ld [ %g1 + %l6 ], %g1 2005aa8: 80 a0 60 00 cmp %g1, 0 2005aac: 02 80 00 30 be 2005b6c 2005ab0: 90 10 00 15 mov %l5, %o0 2005ab4: c2 00 60 04 ld [ %g1 + 4 ], %g1 2005ab8: 80 a0 60 00 cmp %g1, 0 2005abc: 22 80 00 0d be,a 2005af0 2005ac0: c0 26 60 1c clr [ %i1 + 0x1c ] <== NOT EXECUTED _Objects_Information_table[ the_api ][ 1 ] ) { bytes_to_allocate = sizeof( void * ) * 2005ac4: c2 10 60 10 lduh [ %g1 + 0x10 ], %g1 2005ac8: 82 00 60 01 inc %g1 2005acc: a3 28 60 02 sll %g1, 2, %l1 2005ad0: 40 00 0b 1a call 2008738 <_Heap_Allocate> 2005ad4: 92 10 00 11 mov %l1, %o1 (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { 2005ad8: 82 92 20 00 orcc %o0, 0, %g1 2005adc: 02 80 00 26 be 2005b74 2005ae0: 94 10 00 11 mov %l1, %o2 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 2005ae4: c2 26 60 1c st %g1, [ %i1 + 0x1c ] memset( table, '\0', bytes_to_allocate ); 2005ae8: 40 00 2c 30 call 2010ba8 2005aec: 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++ ) { 2005af0: 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; 2005af4: 80 a4 e0 05 cmp %l3, 5 2005af8: 12 bf ff ea bne 2005aa0 2005afc: b2 06 60 04 add %i1, 4, %i1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005b00: 90 15 21 f0 or %l4, 0x1f0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005b04: c8 04 20 08 ld [ %l0 + 8 ], %g4 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005b08: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 } } the_key->is_active = TRUE; 2005b0c: 84 10 20 01 mov 1, %g2 2005b10: 03 00 00 3f sethi %hi(0xfc00), %g1 2005b14: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005b18: 82 09 00 01 and %g4, %g1, %g1 2005b1c: 80 a0 40 03 cmp %g1, %g3 2005b20: 18 80 00 05 bgu 2005b34 2005b24: c4 24 20 10 st %g2, [ %l0 + 0x10 ] information->local_table[ index ] = the_object; 2005b28: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005b2c: 83 28 60 02 sll %g1, 2, %g1 2005b30: e0 20 80 01 st %l0, [ %g2 + %g1 ] _Objects_Open( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 2005b34: c8 26 00 00 st %g4, [ %i0 ] 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; 2005b38: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005b3c: c2 04 a0 f0 ld [ %l2 + 0xf0 ], %g1 2005b40: b0 10 20 00 clr %i0 2005b44: 82 00 7f ff add %g1, -1, %g1 2005b48: c2 24 a0 f0 st %g1, [ %l2 + 0xf0 ] 2005b4c: c4 04 a0 f0 ld [ %l2 + 0xf0 ], %g2 2005b50: 80 a0 a0 00 cmp %g2, 0 2005b54: 12 80 00 04 bne 2005b64 2005b58: 01 00 00 00 nop _Thread_Dispatch(); 2005b5c: 40 00 12 9f call 200a5d8 <_Thread_Dispatch> 2005b60: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 2005b64: 81 c7 e0 08 ret 2005b68: 81 e8 00 00 restore } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 2005b6c: 10 bf ff e1 b 2005af0 2005b70: c0 26 60 1c clr [ %i1 + 0x1c ] bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 2005b74: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED 2005b78: 02 80 00 0d be 2005bac <== NOT EXECUTED 2005b7c: 90 15 21 f0 or %l4, 0x1f0, %o0 <== NOT EXECUTED 2005b80: 83 2c e0 02 sll %l3, 2, %g1 <== NOT EXECUTED 2005b84: b2 15 e1 3c or %l7, 0x13c, %i1 <== NOT EXECUTED 2005b88: 82 00 60 18 add %g1, 0x18, %g1 <== NOT EXECUTED 2005b8c: a2 04 00 01 add %l0, %g1, %l1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 2005b90: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED 2005b94: 40 00 0b 1b call 2008800 <_Heap_Free> <== NOT EXECUTED 2005b98: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2005b9c: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED 2005ba0: 12 bf ff fc bne 2005b90 <== NOT EXECUTED 2005ba4: a2 04 7f fc add %l1, -4, %l1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _POSIX_Keys_Free ( POSIX_Keys_Control *the_key ) { _Objects_Free( &_POSIX_Keys_Information, &the_key->Object ); 2005ba8: 90 15 21 f0 or %l4, 0x1f0, %o0 <== NOT EXECUTED 2005bac: 40 00 0d 50 call 20090ec <_Objects_Free> <== NOT EXECUTED 2005bb0: 92 10 00 10 mov %l0, %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 ) 2005bb4: c2 04 a0 f0 ld [ %l2 + 0xf0 ], %g1 <== NOT EXECUTED 2005bb8: 10 bf ff aa b 2005a60 <== NOT EXECUTED 2005bbc: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED 02005bc0 : */ int pthread_key_delete( pthread_key_t key ) { 2005bc0: 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 *) 2005bc4: 23 00 80 61 sethi %hi(0x2018400), %l1 2005bc8: 92 10 00 18 mov %i0, %o1 2005bcc: 94 07 bf f4 add %fp, -12, %o2 2005bd0: 40 00 0d 8a call 20091f8 <_Objects_Get> 2005bd4: 90 14 61 f0 or %l1, 0x1f0, %o0 register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 2005bd8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005bdc: 80 a0 60 00 cmp %g1, 0 2005be0: 12 80 00 28 bne 2005c80 2005be4: a0 10 00 08 mov %o0, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005be8: c6 02 20 08 ld [ %o0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005bec: 88 14 61 f0 or %l1, 0x1f0, %g4 2005bf0: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 2005bf4: 03 00 00 3f sethi %hi(0xfc00), %g1 2005bf8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005bfc: 82 08 c0 01 and %g3, %g1, %g1 2005c00: 80 a0 40 02 cmp %g1, %g2 2005c04: 28 80 00 26 bleu,a 2005c9c 2005c08: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 2005c0c: 03 00 80 60 sethi %hi(0x2018000), %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; 2005c10: 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; 2005c14: c0 24 20 10 clr [ %l0 + 0x10 ] 2005c18: a4 10 61 3c or %g1, 0x13c, %l2 2005c1c: b0 10 20 00 clr %i0 for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 2005c20: 82 04 00 18 add %l0, %i0, %g1 2005c24: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 2005c28: 80 a2 60 00 cmp %o1, 0 2005c2c: 02 80 00 04 be 2005c3c 2005c30: b0 06 20 04 add %i0, 4, %i0 2005c34: 40 00 0a f3 call 2008800 <_Heap_Free> 2005c38: 90 10 00 12 mov %l2, %o0 _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 2005c3c: 80 a6 20 10 cmp %i0, 0x10 2005c40: 12 bf ff f9 bne 2005c24 2005c44: 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 ); 2005c48: 90 14 61 f0 or %l1, 0x1f0, %o0 2005c4c: 40 00 0d 28 call 20090ec <_Objects_Free> 2005c50: 92 10 00 10 mov %l0, %o1 2005c54: 03 00 80 60 sethi %hi(0x2018000), %g1 2005c58: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 20180f0 <_Thread_Dispatch_disable_level> 2005c5c: 90 10 20 00 clr %o0 2005c60: 84 00 bf ff add %g2, -1, %g2 2005c64: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 2005c68: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 2005c6c: 80 a0 e0 00 cmp %g3, 0 2005c70: 02 80 00 0e be 2005ca8 2005c74: 01 00 00 00 nop _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005c78: 81 c7 e0 08 ret 2005c7c: 91 e8 00 08 restore %g0, %o0, %o0 register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 2005c80: 80 a0 60 02 cmp %g1, 2 2005c84: 08 bf ff fd bleu 2005c78 2005c88: 90 10 20 16 mov 0x16, %o0 _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005c8c: 40 00 02 a3 call 2006718 <== NOT EXECUTED 2005c90: 01 00 00 00 nop <== NOT EXECUTED } 2005c94: 81 c7 e0 08 ret <== NOT EXECUTED 2005c98: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) information->local_table[ index ] = the_object; 2005c9c: 83 28 60 02 sll %g1, 2, %g1 2005ca0: 10 bf ff db b 2005c0c 2005ca4: c0 20 80 01 clr [ %g2 + %g1 ] _Thread_Dispatch(); 2005ca8: 40 00 12 4c call 200a5d8 <_Thread_Dispatch> 2005cac: 01 00 00 00 nop 2005cb0: 90 10 20 00 clr %o0 ! 0 2005cb4: 81 c7 e0 08 ret 2005cb8: 91 e8 00 08 restore %g0, %o0, %o0 02025010 : int pthread_kill( pthread_t thread, int sig ) { 2025010: 9d e3 bf 90 save %sp, -112, %sp POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 2025014: 80 a6 60 00 cmp %i1, 0 2025018: 02 80 00 46 be 2025130 202501c: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2025020: a0 06 7f ff add %i1, -1, %l0 2025024: 80 a4 20 1f cmp %l0, 0x1f 2025028: 18 80 00 42 bgu 2025130 202502c: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Get ( pthread_t id, Objects_Locations *location ) { return (Thread_Control *) 2025030: 11 00 80 ae sethi %hi(0x202b800), %o0 2025034: 7f ff a7 fb call 200f020 <_Objects_Get> 2025038: 90 12 21 94 or %o0, 0x194, %o0 ! 202b994 <_POSIX_Threads_Information> 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 ) { 202503c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2025040: 80 a0 60 00 cmp %g1, 0 2025044: 02 80 00 0c be 2025074 2025048: b0 10 00 08 mov %o0, %i0 202504c: 80 a0 60 02 cmp %g1, 2 2025050: 18 80 00 34 bgu 2025120 2025054: 01 00 00 00 nop case OBJECTS_ERROR: case OBJECTS_REMOTE: rtems_set_errno_and_return_minus_one( ESRCH ); 2025058: 7f ff d5 52 call 201a5a0 <__errno> 202505c: 01 00 00 00 nop 2025060: 82 10 20 03 mov 3, %g1 ! 3 2025064: c2 22 00 00 st %g1, [ %o0 ] 2025068: 90 10 3f ff mov -1, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 202506c: 81 c7 e0 08 ret 2025070: 91 e8 00 08 restore %g0, %o0, %o0 api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 2025074: 87 2e 60 02 sll %i1, 2, %g3 2025078: 85 2e 60 04 sll %i1, 4, %g2 202507c: 03 00 80 af sethi %hi(0x202bc00), %g1 2025080: 84 20 80 03 sub %g2, %g3, %g2 2025084: 82 10 61 78 or %g1, 0x178, %g1 2025088: 84 00 80 01 add %g2, %g1, %g2 202508c: c6 00 a0 08 ld [ %g2 + 8 ], %g3 2025090: 80 a0 e0 01 cmp %g3, 1 2025094: 02 80 00 15 be 20250e8 2025098: c8 02 21 74 ld [ %o0 + 0x174 ], %g4 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 202509c: c4 01 20 c8 ld [ %g4 + 0xc8 ], %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20250a0: 92 10 00 19 mov %i1, %o1 return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 20250a4: b2 10 20 01 mov 1, %i1 20250a8: 83 2e 40 10 sll %i1, %l0, %g1 20250ac: 84 10 80 01 or %g2, %g1, %g2 (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 20250b0: 94 10 20 00 clr %o2 20250b4: 7f ff ff 8c call 2024ee4 <_POSIX_signals_Unblock_thread> 20250b8: c4 21 20 c8 st %g2, [ %g4 + 0xc8 ] the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 20250bc: 03 00 80 ad sethi %hi(0x202b400), %g1 20250c0: c4 00 63 28 ld [ %g1 + 0x328 ], %g2 ! 202b728 <_ISR_Nest_level> 20250c4: 80 a0 a0 00 cmp %g2, 0 20250c8: 02 80 00 08 be 20250e8 20250cc: f2 26 20 78 st %i1, [ %i0 + 0x78 ] 20250d0: 03 00 80 ad sethi %hi(0x202b400), %g1 20250d4: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 202b740 <_Thread_Executing> 20250d8: 80 a6 00 02 cmp %i0, %g2 20250dc: 12 80 00 03 bne 20250e8 20250e0: 03 00 80 ad sethi %hi(0x202b400), %g1 _ISR_Signals_to_thread_executing = TRUE; 20250e4: f2 20 63 e8 st %i1, [ %g1 + 0x3e8 ] ! 202b7e8 <_ISR_Signals_to_thread_executing> <== 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 ) 20250e8: 03 00 80 ad sethi %hi(0x202b400), %g1 20250ec: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 202b660 <_Thread_Dispatch_disable_level> } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20250f0: 90 10 20 00 clr %o0 20250f4: 84 00 bf ff add %g2, -1, %g2 20250f8: c4 20 62 60 st %g2, [ %g1 + 0x260 ] 20250fc: c6 00 62 60 ld [ %g1 + 0x260 ], %g3 2025100: 80 a0 e0 00 cmp %g3, 0 2025104: 12 bf ff da bne 202506c 2025108: 01 00 00 00 nop _Thread_Dispatch(); 202510c: 7f ff ac f9 call 20104f0 <_Thread_Dispatch> 2025110: 01 00 00 00 nop 2025114: 90 10 20 00 clr %o0 ! 0 } 2025118: 81 c7 e0 08 ret 202511c: 91 e8 00 08 restore %g0, %o0, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2025120: 40 00 00 18 call 2025180 <== NOT EXECUTED 2025124: 01 00 00 00 nop <== NOT EXECUTED } 2025128: 81 c7 e0 08 ret <== NOT EXECUTED 202512c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if ( !sig ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) rtems_set_errno_and_return_minus_one( EINVAL ); 2025130: 7f ff d5 1c call 201a5a0 <__errno> 2025134: 01 00 00 00 nop 2025138: 82 10 20 16 mov 0x16, %g1 ! 16 202513c: c2 22 00 00 st %g1, [ %o0 ] 2025140: 10 bf ff cb b 202506c 2025144: 90 10 3f ff mov -1, %o0 02007678 : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 2007678: 9d e3 bf 90 save %sp, -112, %sp Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 200767c: 80 a6 20 00 cmp %i0, 0 2007680: 32 80 00 05 bne,a 2007694 2007684: d2 06 00 00 ld [ %i0 ], %o1 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007688: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 200768c: 81 c7 e0 08 ret 2007690: 91 e8 00 08 restore %g0, %o0, %o0 2007694: 80 a2 7f ff cmp %o1, -1 2007698: 02 80 00 40 be 2007798 200769c: 90 10 00 18 mov %i0, %o0 return (POSIX_Mutex_Control *) 20076a0: 21 00 80 6e sethi %hi(0x201b800), %l0 20076a4: 94 07 bf f4 add %fp, -12, %o2 20076a8: 40 00 0f e4 call 200b638 <_Objects_Get> 20076ac: 90 14 21 54 or %l0, 0x154, %o0 { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20076b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20076b4: 80 a0 60 00 cmp %g1, 0 20076b8: 12 80 00 13 bne 2007704 20076bc: b0 10 00 08 mov %o0, %i0 /* * 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 ) ) { 20076c0: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 20076c4: 80 a0 60 00 cmp %g1, 0 20076c8: 32 80 00 15 bne,a 200771c 20076cc: a0 14 21 54 or %l0, 0x154, %l0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20076d0: 03 00 80 6d sethi %hi(0x201b400), %g1 20076d4: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 201b4f0 <_Thread_Dispatch_disable_level> 20076d8: 90 10 20 10 mov 0x10, %o0 20076dc: 84 00 bf ff add %g2, -1, %g2 20076e0: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 20076e4: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 20076e8: 80 a0 e0 00 cmp %g3, 0 20076ec: 12 bf ff e8 bne 200768c 20076f0: 01 00 00 00 nop _Thread_Dispatch(); 20076f4: 40 00 14 c9 call 200ca18 <_Thread_Dispatch> 20076f8: 01 00 00 00 nop 20076fc: 10 bf ff e4 b 200768c 2007700: 90 10 20 10 mov 0x10, %o0 ! 10 { register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007704: 80 a0 60 02 cmp %g1, 2 2007708: 28 bf ff e1 bleu,a 200768c 200770c: 90 10 20 16 mov 0x16, %o0 } #endif _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007710: 40 00 05 12 call 2008b58 <== NOT EXECUTED 2007714: 01 00 00 00 nop <== NOT EXECUTED 2007718: 30 bf ff dd b,a 200768c <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200771c: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2007720: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2007724: 05 00 00 3f sethi %hi(0xfc00), %g2 2007728: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200772c: 82 08 40 02 and %g1, %g2, %g1 2007730: 80 a0 40 03 cmp %g1, %g3 2007734: 18 80 00 05 bgu 2007748 2007738: 94 10 20 16 mov 0x16, %o2 information->local_table[ index ] = the_object; 200773c: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2007740: 83 28 60 02 sll %g1, 2, %g1 2007744: c0 20 80 01 clr [ %g2 + %g1 ] return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); _CORE_mutex_Flush( 2007748: 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; 200774c: c0 26 20 0c clr [ %i0 + 0xc ] 2007750: 40 00 0b ae call 200a608 <_CORE_mutex_Flush> 2007754: 92 10 20 00 clr %o1 RTEMS_INLINE_ROUTINE void _POSIX_Mutex_Free ( POSIX_Mutex_Control *the_mutex ) { _Objects_Free( &_POSIX_Mutex_Information, &the_mutex->Object ); 2007758: 90 10 00 10 mov %l0, %o0 200775c: 40 00 0f 74 call 200b52c <_Objects_Free> 2007760: 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 ) 2007764: 03 00 80 6d sethi %hi(0x201b400), %g1 2007768: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 201b4f0 <_Thread_Dispatch_disable_level> 200776c: 90 10 20 00 clr %o0 2007770: 84 00 bf ff add %g2, -1, %g2 2007774: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 2007778: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 200777c: 80 a0 e0 00 cmp %g3, 0 2007780: 12 bf ff c3 bne 200768c 2007784: 01 00 00 00 nop _Thread_Dispatch(); 2007788: 40 00 14 a4 call 200ca18 <_Thread_Dispatch> 200778c: 01 00 00 00 nop 2007790: 10 bf ff bf b 200768c 2007794: 90 10 20 00 clr %o0 ! 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007798: 40 00 00 38 call 2007878 <== NOT EXECUTED 200779c: 92 10 20 00 clr %o1 <== NOT EXECUTED 20077a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20077a4: 12 bf ff ba bne 200768c <== NOT EXECUTED 20077a8: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 20077ac: 10 bf ff bd b 20076a0 <== NOT EXECUTED 20077b0: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 020077b4 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 20077b4: 9d e3 bf 90 save %sp, -112, %sp register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 20077b8: 80 a6 60 00 cmp %i1, 0 20077bc: 02 80 00 04 be 20077cc 20077c0: 80 a6 20 00 cmp %i0, 0 20077c4: 32 80 00 05 bne,a 20077d8 20077c8: d2 06 00 00 ld [ %i0 ], %o1 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20077cc: 90 10 20 16 mov 0x16, %o0 } 20077d0: 81 c7 e0 08 ret 20077d4: 91 e8 00 08 restore %g0, %o0, %o0 20077d8: 80 a2 7f ff cmp %o1, -1 20077dc: 22 80 00 20 be,a 200785c 20077e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 20077e4: 11 00 80 6e sethi %hi(0x201b800), %o0 20077e8: 94 07 bf f4 add %fp, -12, %o2 20077ec: 40 00 0f 93 call 200b638 <_Objects_Get> 20077f0: 90 12 21 54 or %o0, 0x154, %o0 if ( !prioceiling ) return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 20077f4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20077f8: 80 a0 60 00 cmp %g1, 0 20077fc: 12 80 00 13 bne 2007848 2007800: 80 a0 60 02 cmp %g1, 2 return POSIX_MP_NOT_IMPLEMENTED(); /* XXX feels questionable */ #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 2007804: c4 02 20 60 ld [ %o0 + 0x60 ], %g2 2007808: 82 10 20 ff mov 0xff, %g1 200780c: 82 20 40 02 sub %g1, %g2, %g1 2007810: 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 ) 2007814: 07 00 80 6d sethi %hi(0x201b400), %g3 2007818: c2 00 e0 f0 ld [ %g3 + 0xf0 ], %g1 ! 201b4f0 <_Thread_Dispatch_disable_level> 200781c: 90 10 20 00 clr %o0 2007820: 82 00 7f ff add %g1, -1, %g1 2007824: c2 20 e0 f0 st %g1, [ %g3 + 0xf0 ] 2007828: c4 00 e0 f0 ld [ %g3 + 0xf0 ], %g2 200782c: 80 a0 a0 00 cmp %g2, 0 2007830: 12 bf ff e8 bne 20077d0 2007834: 01 00 00 00 nop _Thread_Dispatch(); 2007838: 40 00 14 78 call 200ca18 <_Thread_Dispatch> 200783c: 01 00 00 00 nop 2007840: 10 bf ff e4 b 20077d0 2007844: 90 10 20 00 clr %o0 ! 0 if ( !prioceiling ) return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007848: 28 bf ff e2 bleu,a 20077d0 200784c: 90 10 20 16 mov 0x16, %o0 the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007850: 40 00 04 c2 call 2008b58 <== NOT EXECUTED 2007854: 01 00 00 00 nop <== NOT EXECUTED 2007858: 30 bf ff de b,a 20077d0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 200785c: 40 00 00 07 call 2007878 <== NOT EXECUTED 2007860: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007864: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007868: 32 bf ff da bne,a 20077d0 <== NOT EXECUTED 200786c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2007870: 10 bf ff dd b 20077e4 <== NOT EXECUTED 2007874: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 02007878 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 2007878: 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; 200787c: 03 00 80 65 sethi %hi(0x2019400), %g1 2007880: 80 a6 60 00 cmp %i1, 0 2007884: 02 80 00 03 be 2007890 2007888: a0 10 62 2c or %g1, 0x22c, %l0 200788c: a0 10 00 19 mov %i1, %l0 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 2007890: 80 a6 20 00 cmp %i0, 0 2007894: 22 80 00 2c be,a 2007944 2007898: b0 10 20 16 mov 0x16, %i0 return EBUSY; } } #endif if ( !the_attr->is_initialized ) 200789c: c2 04 00 00 ld [ %l0 ], %g1 20078a0: 80 a0 60 00 cmp %g1, 0 20078a4: 22 80 00 28 be,a 2007944 20078a8: b0 10 20 16 mov 0x16, %i0 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 20078ac: c2 04 20 04 ld [ %l0 + 4 ], %g1 20078b0: 80 a0 60 00 cmp %g1, 0 20078b4: 12 80 00 2b bne 2007960 20078b8: 11 00 80 65 sethi %hi(0x2019400), %o0 /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 20078bc: c2 04 20 0c ld [ %l0 + 0xc ], %g1 20078c0: 80 a0 60 01 cmp %g1, 1 20078c4: 02 80 00 07 be 20078e0 20078c8: a4 10 20 02 mov 2, %l2 20078cc: 80 a0 60 02 cmp %g1, 2 20078d0: 02 80 00 22 be 2007958 20078d4: 80 a0 60 00 cmp %g1, 0 20078d8: 12 80 00 1d bne 200794c 20078dc: a4 10 20 00 clr %l2 break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 20078e0: c2 04 20 08 ld [ %l0 + 8 ], %g1 20078e4: 82 00 7f ff add %g1, -1, %g1 20078e8: 80 a0 60 fd cmp %g1, 0xfd 20078ec: 38 80 00 16 bgu,a 2007944 20078f0: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20078f4: 23 00 80 6d sethi %hi(0x201b400), %l1 20078f8: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 ! 201b4f0 <_Thread_Dispatch_disable_level> 20078fc: 82 00 60 01 inc %g1 2007900: c2 24 60 f0 st %g1, [ %l1 + 0xf0 ] * _POSIX_Mutex_Allocate */ RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Allocate( void ) { return (POSIX_Mutex_Control *) _Objects_Allocate( &_POSIX_Mutex_Information ); 2007904: 27 00 80 6e sethi %hi(0x201b800), %l3 2007908: 40 00 0d fb call 200b0f4 <_Objects_Allocate> 200790c: 90 14 e1 54 or %l3, 0x154, %o0 ! 201b954 <_POSIX_Mutex_Information> _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 2007910: b2 92 20 00 orcc %o0, 0, %i1 2007914: 32 80 00 1e bne,a 200798c 2007918: c2 04 20 04 ld [ %l0 + 4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200791c: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 2007920: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 2007924: 82 00 7f ff add %g1, -1, %g1 2007928: c2 24 60 f0 st %g1, [ %l1 + 0xf0 ] 200792c: c4 04 60 f0 ld [ %l1 + 0xf0 ], %g2 2007930: 80 a0 a0 00 cmp %g2, 0 2007934: 12 80 00 07 bne 2007950 2007938: 01 00 00 00 nop 200793c: 40 00 14 37 call 200ca18 <_Thread_Dispatch> 2007940: 01 00 00 00 nop 2007944: 81 c7 e0 08 ret 2007948: 81 e8 00 00 restore 200794c: b0 10 20 16 mov 0x16, %i0 ); #endif _Thread_Enable_dispatch(); return 0; } 2007950: 81 c7 e0 08 ret 2007954: 81 e8 00 00 restore /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 2007958: 10 bf ff e2 b 20078e0 200795c: a4 10 20 03 mov 3, %l2 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 2007960: 15 00 80 65 sethi %hi(0x2019400), %o2 <== NOT EXECUTED 2007964: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED 2007968: 94 12 a2 88 or %o2, 0x288, %o2 <== NOT EXECUTED 200796c: 7f ff f1 bf call 2004068 <__assert> <== NOT EXECUTED 2007970: 92 10 20 64 mov 0x64, %o1 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 2007974: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 2007978: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 200797c: 12 bf ff d5 bne 20078d0 <== NOT EXECUTED 2007980: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007984: 10 bf ff d7 b 20078e0 <== NOT EXECUTED 2007988: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } #endif the_mutex->process_shared = the_attr->process_shared; 200798c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) 2007990: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 2007994: 80 a0 a0 00 cmp %g2, 0 2007998: 32 80 00 04 bne,a 20079a8 200799c: c0 26 60 54 clr [ %i1 + 0x54 ] <== NOT EXECUTED the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; 20079a0: 82 10 20 01 mov 1, %g1 20079a4: c2 26 60 54 st %g1, [ %i1 + 0x54 ] the_mutex_attr->only_owner_release = TRUE; the_mutex_attr->priority_ceiling = 20079a8: c6 04 20 08 ld [ %l0 + 8 ], %g3 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; 20079ac: 84 10 20 01 mov 1, %g2 the_mutex_attr->priority_ceiling = 20079b0: 82 10 20 ff mov 0xff, %g1 20079b4: 82 20 40 03 sub %g1, %g3, %g1 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; 20079b8: c4 26 60 58 st %g2, [ %i1 + 0x58 ] the_mutex_attr->priority_ceiling = 20079bc: c2 26 60 60 st %g1, [ %i1 + 0x60 ] _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 20079c0: e4 26 60 5c st %l2, [ %i1 + 0x5c ] /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 20079c4: 90 06 60 14 add %i1, 0x14, %o0 20079c8: 92 06 60 54 add %i1, 0x54, %o1 20079cc: 40 00 0b 13 call 200a618 <_CORE_mutex_Initialize> 20079d0: 94 10 20 01 mov 1, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20079d4: 90 14 e1 54 or %l3, 0x154, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 20079d8: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20079dc: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 20079e0: 03 00 00 3f sethi %hi(0xfc00), %g1 20079e4: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20079e8: 82 08 c0 01 and %g3, %g1, %g1 20079ec: 80 a0 40 02 cmp %g1, %g2 20079f0: 38 80 00 06 bgu,a 2007a08 20079f4: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 20079f8: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20079fc: 83 28 60 02 sll %g1, 2, %g1 2007a00: 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; 2007a04: c6 26 00 00 st %g3, [ %i0 ] 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; 2007a08: c0 26 60 0c clr [ %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 ) 2007a0c: c2 04 60 f0 ld [ %l1 + 0xf0 ], %g1 2007a10: 10 bf ff c5 b 2007924 2007a14: b0 10 20 00 clr %i0 02007ccc : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 2007ccc: 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 ) 2007cd0: 80 a6 a0 00 cmp %i2, 0 2007cd4: 02 80 00 06 be 2007cec 2007cd8: a0 10 00 18 mov %i0, %l0 return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 2007cdc: 82 06 7f ff add %i1, -1, %g1 2007ce0: 80 a0 60 fd cmp %g1, 0xfd 2007ce4: 08 80 00 04 bleu 2007cf4 2007ce8: 01 00 00 00 nop ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007cec: 81 c7 e0 08 ret 2007cf0: 91 e8 20 16 restore %g0, 0x16, %o0 /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 2007cf4: 7f ff ff 49 call 2007a18 2007cf8: 90 10 00 18 mov %i0, %o0 if ( status ) 2007cfc: b0 92 20 00 orcc %o0, 0, %i0 2007d00: 12 80 00 24 bne 2007d90 2007d04: 80 a4 20 00 cmp %l0, 0 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007d08: 22 80 00 22 be,a 2007d90 2007d0c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED 2007d10: d2 04 00 00 ld [ %l0 ], %o1 2007d14: 80 a2 7f ff cmp %o1, -1 2007d18: 22 80 00 26 be,a 2007db0 2007d1c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007d20: 11 00 80 6e sethi %hi(0x201b800), %o0 2007d24: 94 07 bf f4 add %fp, -12, %o2 2007d28: 40 00 0e 44 call 200b638 <_Objects_Get> 2007d2c: 90 12 21 54 or %o0, 0x154, %o0 return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007d30: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d34: 80 a0 60 00 cmp %g1, 0 2007d38: 12 80 00 18 bne 2007d98 2007d3c: 80 a0 60 02 cmp %g1, 2 return EINVAL; #endif case OBJECTS_ERROR: return EINVAL; /* impossible to get here */ case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 2007d40: c6 02 20 60 ld [ %o0 + 0x60 ], %g3 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 2007d44: 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( 2007d48: 82 10 20 ff mov 0xff, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 2007d4c: 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( 2007d50: 82 20 40 03 sub %g1, %g3, %g1 the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 2007d54: 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( 2007d58: c2 26 80 00 st %g1, [ %i2 ] the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; _CORE_mutex_Surrender( 2007d5c: 94 10 20 00 clr %o2 2007d60: 40 00 0a 8b call 200a78c <_CORE_mutex_Surrender> 2007d64: 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 ) 2007d68: 05 00 80 6d sethi %hi(0x201b400), %g2 2007d6c: c2 00 a0 f0 ld [ %g2 + 0xf0 ], %g1 ! 201b4f0 <_Thread_Dispatch_disable_level> 2007d70: 82 00 7f ff add %g1, -1, %g1 2007d74: c2 20 a0 f0 st %g1, [ %g2 + 0xf0 ] 2007d78: c6 00 a0 f0 ld [ %g2 + 0xf0 ], %g3 2007d7c: 80 a0 e0 00 cmp %g3, 0 2007d80: 12 80 00 04 bne 2007d90 2007d84: 01 00 00 00 nop _Thread_Dispatch(); 2007d88: 40 00 13 24 call 200ca18 <_Thread_Dispatch> 2007d8c: 01 00 00 00 nop 2007d90: 81 c7 e0 08 ret 2007d94: 81 e8 00 00 restore status = pthread_mutex_lock( mutex ); if ( status ) return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007d98: 28 bf ff fe bleu,a 2007d90 <== NOT EXECUTED 2007d9c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2007da0: 40 00 03 6e call 2008b58 <== NOT EXECUTED 2007da4: 01 00 00 00 nop <== NOT EXECUTED 2007da8: 81 c7 e0 08 ret <== NOT EXECUTED 2007dac: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007db0: 7f ff fe b2 call 2007878 <== NOT EXECUTED 2007db4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007db8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007dbc: 32 bf ff f5 bne,a 2007d90 <== NOT EXECUTED 2007dc0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED 2007dc4: 10 bf ff d7 b 2007d20 <== NOT EXECUTED 2007dc8: d2 04 00 00 ld [ %l0 ], %o1 <== NOT EXECUTED 02007dcc : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 2007dcc: 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 ); 2007dd0: 90 10 00 19 mov %i1, %o0 2007dd4: 40 00 00 46 call 2007eec <_POSIX_Absolute_timeout_to_ticks> 2007dd8: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2007ddc: 80 a2 20 03 cmp %o0, 3 2007de0: 02 80 00 07 be 2007dfc 2007de4: d4 07 bf f4 ld [ %fp + -12 ], %o2 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 2007de8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007dec: 7f ff ff 11 call 2007a30 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 2007df0: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 2007df4: 81 c7 e0 08 ret <== NOT EXECUTED 2007df8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 2007dfc: 90 10 00 18 mov %i0, %o0 2007e00: 7f ff ff 0c call 2007a30 <_POSIX_Mutex_Lock_support> 2007e04: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 2007e08: 81 c7 e0 08 ret 2007e0c: 91 e8 00 08 restore %g0, %o0, %o0 02007e28 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 2007e28: 9d e3 bf 90 save %sp, -112, %sp 2007e2c: 80 a6 20 00 cmp %i0, 0 2007e30: 32 80 00 05 bne,a 2007e44 2007e34: d2 06 00 00 ld [ %i0 ], %o1 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 2007e38: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED } 2007e3c: 81 c7 e0 08 ret 2007e40: 91 e8 00 08 restore %g0, %o0, %o0 2007e44: 80 a2 7f ff cmp %o1, -1 2007e48: 22 80 00 22 be,a 2007ed0 2007e4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return (POSIX_Mutex_Control *) 2007e50: 11 00 80 6e sethi %hi(0x201b800), %o0 2007e54: 94 07 bf f4 add %fp, -12, %o2 2007e58: 40 00 0d f8 call 200b638 <_Objects_Get> 2007e5c: 90 12 21 54 or %o0, 0x154, %o0 register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007e60: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007e64: 80 a0 60 00 cmp %g1, 0 2007e68: 12 80 00 12 bne 2007eb0 2007e6c: 80 a0 60 02 cmp %g1, 2 ); #endif case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 2007e70: d2 02 20 08 ld [ %o0 + 8 ], %o1 2007e74: 94 10 20 00 clr %o2 2007e78: 40 00 0a 45 call 200a78c <_CORE_mutex_Surrender> 2007e7c: 90 02 20 14 add %o0, 0x14, %o0 2007e80: 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 ) 2007e84: 03 00 80 6d sethi %hi(0x201b400), %g1 2007e88: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 201b4f0 <_Thread_Dispatch_disable_level> 2007e8c: 84 00 bf ff add %g2, -1, %g2 2007e90: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 2007e94: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 2007e98: 80 a0 e0 00 cmp %g3, 0 2007e9c: 02 80 00 0a be 2007ec4 2007ea0: 01 00 00 00 nop #else NULL #endif ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); 2007ea4: 40 00 21 81 call 20104a8 <_POSIX_Mutex_From_core_mutex_status> 2007ea8: 90 10 00 18 mov %i0, %o0 2007eac: 30 bf ff e4 b,a 2007e3c register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 2007eb0: 28 bf ff e3 bleu,a 2007e3c 2007eb4: 90 10 20 16 mov 0x16, %o0 ); _Thread_Enable_dispatch(); return _POSIX_Mutex_From_core_mutex_status( status ); break; } return POSIX_BOTTOM_REACHED(); 2007eb8: 40 00 03 28 call 2008b58 <== NOT EXECUTED 2007ebc: 01 00 00 00 nop <== NOT EXECUTED 2007ec0: 30 bf ff df b,a 2007e3c <== NOT EXECUTED _Thread_Dispatch(); 2007ec4: 40 00 12 d5 call 200ca18 <_Thread_Dispatch> 2007ec8: 01 00 00 00 nop 2007ecc: 30 bf ff f6 b,a 2007ea4 Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 2007ed0: 7f ff fe 6a call 2007878 <== NOT EXECUTED 2007ed4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2007ed8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007edc: 32 bf ff d8 bne,a 2007e3c <== NOT EXECUTED 2007ee0: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED 2007ee4: 10 bf ff db b 2007e50 <== NOT EXECUTED 2007ee8: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED 02006ec8 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 2006ec8: 9d e3 bf 90 save %sp, -112, %sp if ( !once_control || !init_routine ) 2006ecc: a0 96 20 00 orcc %i0, 0, %l0 2006ed0: 02 80 00 18 be 2006f30 2006ed4: 80 a6 60 00 cmp %i1, 0 2006ed8: 02 80 00 16 be 2006f30 2006edc: 01 00 00 00 nop return EINVAL; if ( !once_control->init_executed ) { 2006ee0: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006ee4: 80 a0 60 00 cmp %g1, 0 2006ee8: 12 80 00 10 bne 2006f28 2006eec: b0 10 20 00 clr %i0 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 2006ef0: b0 07 bf f4 add %fp, -12, %i0 2006ef4: 90 10 21 00 mov 0x100, %o0 2006ef8: 92 10 21 00 mov 0x100, %o1 2006efc: 40 00 05 40 call 20083fc 2006f00: 94 10 00 18 mov %i0, %o2 if ( !once_control->init_executed ) { 2006f04: c2 04 20 04 ld [ %l0 + 4 ], %g1 2006f08: 80 a0 60 00 cmp %g1, 0 2006f0c: 02 80 00 0b be 2006f38 2006f10: 82 10 20 01 mov 1, %g1 once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 2006f14: d0 07 bf f4 ld [ %fp + -12 ], %o0 <== NOT EXECUTED 2006f18: 94 10 00 18 mov %i0, %o2 2006f1c: 92 10 21 00 mov 0x100, %o1 2006f20: 40 00 05 37 call 20083fc 2006f24: b0 10 20 00 clr %i0 } return 0; } 2006f28: 81 c7 e0 08 ret 2006f2c: 81 e8 00 00 restore int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) 2006f30: 81 c7 e0 08 ret 2006f34: 91 e8 20 16 restore %g0, 0x16, %o0 if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); if ( !once_control->init_executed ) { once_control->is_initialized = TRUE; once_control->init_executed = TRUE; 2006f38: c2 24 20 04 st %g1, [ %l0 + 4 ] (*init_routine)(); 2006f3c: 9f c6 40 00 call %i1 2006f40: c2 24 00 00 st %g1, [ %l0 ] } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 2006f44: 10 bf ff f5 b 2006f18 2006f48: d0 07 bf f4 ld [ %fp + -12 ], %o0 020062b8 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 20062b8: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 20062bc: 80 a6 20 00 cmp %i0, 0 20062c0: 02 80 00 24 be 2006350 20062c4: 21 00 80 71 sethi %hi(0x201c400), %l0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 20062c8: d2 06 00 00 ld [ %i0 ], %o1 20062cc: 94 07 bf f4 add %fp, -12, %o2 20062d0: 40 00 0f 94 call 200a120 <_Objects_Get> 20062d4: 90 14 23 2c or %l0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20062d8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062dc: 80 a0 60 00 cmp %g1, 0 20062e0: 12 80 00 15 bne 2006334 20062e4: b0 10 00 08 mov %o0, %i0 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 ) { 20062e8: 40 00 17 6f call 200c0a4 <_Thread_queue_First> 20062ec: 90 02 20 10 add %o0, 0x10, %o0 20062f0: 80 a2 20 00 cmp %o0, 0 20062f4: 02 80 00 1a be 200635c 20062f8: 90 14 23 2c or %l0, 0x32c, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20062fc: 03 00 80 71 sethi %hi(0x201c400), %g1 2006300: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 2006304: 90 10 20 10 mov 0x10, %o0 2006308: 84 00 bf ff add %g2, -1, %g2 200630c: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2006310: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006314: 80 a0 e0 00 cmp %g3, 0 2006318: 12 80 00 0c bne 2006348 200631c: 01 00 00 00 nop _Thread_Dispatch(); 2006320: 40 00 14 78 call 200b500 <_Thread_Dispatch> 2006324: 01 00 00 00 nop 2006328: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200632c: 81 c7 e0 08 ret 2006330: 91 e8 00 08 restore %g0, %o0, %o0 if ( !rwlock ) return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006334: 80 a0 60 02 cmp %g1, 2 2006338: 08 80 00 07 bleu 2006354 200633c: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006340: 40 00 03 c1 call 2007244 <== NOT EXECUTED 2006344: 01 00 00 00 nop <== NOT EXECUTED } 2006348: 81 c7 e0 08 ret 200634c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006350: 90 10 20 16 mov 0x16, %o0 } 2006354: 81 c7 e0 08 ret 2006358: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200635c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006360: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2006364: 05 00 00 3f sethi %hi(0xfc00), %g2 2006368: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200636c: 82 08 40 02 and %g1, %g2, %g1 2006370: 80 a0 40 03 cmp %g1, %g3 2006374: 38 80 00 06 bgu,a 200638c 2006378: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200637c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006380: 83 28 60 02 sll %g1, 2, %g1 2006384: 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; 2006388: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free ( POSIX_RWLock_Control *the_RWLock ) { _Objects_Free( &_POSIX_RWLock_Information, &the_RWLock->Object ); 200638c: 40 00 0f 22 call 200a014 <_Objects_Free> 2006390: 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 ) 2006394: 03 00 80 71 sethi %hi(0x201c400), %g1 2006398: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 200639c: 90 10 20 00 clr %o0 20063a0: 84 00 bf ff add %g2, -1, %g2 20063a4: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 20063a8: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 20063ac: 80 a0 e0 00 cmp %g3, 0 20063b0: 12 bf ff e6 bne 2006348 20063b4: 01 00 00 00 nop _Thread_Dispatch(); 20063b8: 40 00 14 52 call 200b500 <_Thread_Dispatch> 20063bc: 01 00 00 00 nop 20063c0: 10 bf ff e2 b 2006348 20063c4: 90 10 20 00 clr %o0 ! 0 020063c8 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 20063c8: 9d e3 bf 88 save %sp, -120, %sp const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 20063cc: 80 a6 20 00 cmp %i0, 0 20063d0: 02 80 00 23 be 200645c 20063d4: a0 10 00 19 mov %i1, %l0 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 20063d8: 80 a6 60 00 cmp %i1, 0 20063dc: 22 80 00 23 be,a 2006468 20063e0: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 20063e4: c2 04 00 00 ld [ %l0 ], %g1 20063e8: 80 a0 60 00 cmp %g1, 0 20063ec: 22 80 00 1a be,a 2006454 20063f0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 20063f4: c2 04 20 04 ld [ %l0 + 4 ], %g1 20063f8: 80 a0 60 00 cmp %g1, 0 20063fc: 32 80 00 16 bne,a 2006454 2006400: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006404: 33 00 80 71 sethi %hi(0x201c400), %i1 2006408: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 ! 201c490 <_Thread_Dispatch_disable_level> 200640c: 82 00 60 01 inc %g1 2006410: c2 26 60 90 st %g1, [ %i1 + 0x90 ] * 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 *) 2006414: 23 00 80 71 sethi %hi(0x201c400), %l1 2006418: 40 00 0d f1 call 2009bdc <_Objects_Allocate> 200641c: 90 14 63 2c or %l1, 0x32c, %o0 ! 201c72c <_POSIX_RWLock_Information> */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 2006420: a0 92 20 00 orcc %o0, 0, %l0 2006424: 12 80 00 15 bne 2006478 2006428: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200642c: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 2006430: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 2006434: 82 00 7f ff add %g1, -1, %g1 2006438: c2 26 60 90 st %g1, [ %i1 + 0x90 ] 200643c: c4 06 60 90 ld [ %i1 + 0x90 ], %g2 2006440: 80 a0 a0 00 cmp %g2, 0 2006444: 12 80 00 07 bne 2006460 2006448: 01 00 00 00 nop 200644c: 40 00 14 2d call 200b500 <_Thread_Dispatch> 2006450: 01 00 00 00 nop 2006454: 81 c7 e0 08 ret 2006458: 81 e8 00 00 restore 200645c: b0 10 20 16 mov 0x16, %i0 *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; } 2006460: 81 c7 e0 08 ret 2006464: 81 e8 00 00 restore * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 2006468: 40 00 03 4e call 20071a0 <== NOT EXECUTED 200646c: 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 ) 2006470: 10 bf ff de b 20063e8 <== NOT EXECUTED 2006474: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED if ( !the_rwlock ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 2006478: 40 00 0b 13 call 20090c4 <_CORE_RWLock_Initialize> 200647c: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006480: 90 14 63 2c or %l1, 0x32c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2006484: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006488: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 200648c: 03 00 00 3f sethi %hi(0xfc00), %g1 2006490: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006494: 82 08 c0 01 and %g3, %g1, %g1 2006498: 80 a0 40 02 cmp %g1, %g2 200649c: 38 80 00 06 bgu,a 20064b4 20064a0: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 20064a4: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20064a8: 83 28 60 02 sll %g1, 2, %g1 20064ac: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 20064b0: c6 26 00 00 st %g3, [ %i0 ] 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; 20064b4: c0 24 20 0c clr [ %l0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20064b8: c2 06 60 90 ld [ %i1 + 0x90 ], %g1 20064bc: 10 bf ff de b 2006434 20064c0: b0 10 20 00 clr %i0 020064c4 : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 20064c4: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 20064c8: 80 a6 20 00 cmp %i0, 0 20064cc: 02 80 00 24 be 200655c 20064d0: 11 00 80 71 sethi %hi(0x201c400), %o0 RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Get ( pthread_rwlock_t *RWLock, Objects_Locations *location ) { return (POSIX_RWLock_Control *) _Objects_Get( 20064d4: d2 06 00 00 ld [ %i0 ], %o1 20064d8: 94 07 bf f4 add %fp, -12, %o2 20064dc: 40 00 0f 11 call 200a120 <_Objects_Get> 20064e0: 90 12 23 2c or %o0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20064e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064e8: 80 a0 60 00 cmp %g1, 0 20064ec: 22 80 00 09 be,a 2006510 20064f0: d2 06 00 00 ld [ %i0 ], %o1 20064f4: 80 a0 60 02 cmp %g1, 2 20064f8: 08 80 00 1a bleu 2006560 20064fc: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006500: 40 00 03 51 call 2007244 <== NOT EXECUTED 2006504: 01 00 00 00 nop <== NOT EXECUTED } 2006508: 81 c7 e0 08 ret <== NOT EXECUTED 200650c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2006510: 90 02 20 10 add %o0, 0x10, %o0 2006514: 94 10 20 01 mov 1, %o2 2006518: 96 10 20 00 clr %o3 200651c: 40 00 0a f5 call 20090f0 <_CORE_RWLock_Obtain_for_reading> 2006520: 98 10 20 00 clr %o4 2006524: 03 00 80 71 sethi %hi(0x201c400), %g1 2006528: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 200652c: 84 00 bf ff add %g2, -1, %g2 2006530: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2006534: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006538: 80 a0 e0 00 cmp %g3, 0 200653c: 02 80 00 0b be 2006568 2006540: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006544: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED 2006548: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201c570 <_Thread_Executing> 200654c: 40 00 00 a1 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006550: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006554: 81 c7 e0 08 ret 2006558: 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(); 200655c: 90 10 20 16 mov 0x16, %o0 } 2006560: 81 c7 e0 08 ret 2006564: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2006568: 40 00 13 e6 call 200b500 <_Thread_Dispatch> 200656c: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006570: 10 bf ff f6 b 2006548 2006574: 03 00 80 71 sethi %hi(0x201c400), %g1 02006578 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 2006578: 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 ) 200657c: 80 a6 20 00 cmp %i0, 0 2006580: 02 80 00 2b be 200662c 2006584: 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 ); 2006588: 40 00 23 34 call 200f258 <_POSIX_Absolute_timeout_to_ticks> 200658c: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 2006590: 80 a2 20 02 cmp %o0, 2 2006594: 08 80 00 29 bleu 2006638 2006598: b2 10 00 08 mov %o0, %i1 200659c: 80 a2 20 03 cmp %o0, 3 20065a0: 22 80 00 02 be,a 20065a8 20065a4: a0 10 20 01 mov 1, %l0 20065a8: d2 06 00 00 ld [ %i0 ], %o1 20065ac: 11 00 80 71 sethi %hi(0x201c400), %o0 20065b0: 94 07 bf f4 add %fp, -12, %o2 20065b4: 40 00 0e db call 200a120 <_Objects_Get> 20065b8: 90 12 23 2c or %o0, 0x32c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20065bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20065c0: 80 a0 60 00 cmp %g1, 0 20065c4: 12 80 00 27 bne 2006660 20065c8: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 20065cc: d2 06 00 00 ld [ %i0 ], %o1 20065d0: d6 07 bf f0 ld [ %fp + -16 ], %o3 20065d4: 90 02 20 10 add %o0, 0x10, %o0 20065d8: 94 10 00 10 mov %l0, %o2 20065dc: 40 00 0a c5 call 20090f0 <_CORE_RWLock_Obtain_for_reading> 20065e0: 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 ) 20065e4: 03 00 80 71 sethi %hi(0x201c400), %g1 20065e8: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 20065ec: 84 00 bf ff add %g2, -1, %g2 20065f0: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 20065f4: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 20065f8: 80 a0 e0 00 cmp %g3, 0 20065fc: 02 80 00 26 be 2006694 2006600: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 2006604: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2006608: 12 80 00 1e bne 2006680 200660c: 07 00 80 71 sethi %hi(0x201c400), %g3 2006610: c2 00 e1 70 ld [ %g3 + 0x170 ], %g1 ! 201c570 <_Thread_Executing> <== NOT EXECUTED 2006614: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 2006618: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 200661c: 12 80 00 1a bne 2006684 <== NOT EXECUTED 2006620: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006624: 12 80 00 15 bne 2006678 <== NOT EXECUTED 2006628: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 200662c: 90 10 20 16 mov 0x16, %o0 } 2006630: 81 c7 e0 08 ret 2006634: 91 e8 00 08 restore %g0, %o0, %o0 2006638: d2 06 00 00 ld [ %i0 ], %o1 200663c: 11 00 80 71 sethi %hi(0x201c400), %o0 2006640: 94 07 bf f4 add %fp, -12, %o2 2006644: 40 00 0e b7 call 200a120 <_Objects_Get> 2006648: 90 12 23 2c or %o0, 0x32c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 200664c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006650: 80 a0 60 00 cmp %g1, 0 2006654: 02 bf ff de be 20065cc 2006658: a0 10 20 00 clr %l0 200665c: 80 a0 60 02 cmp %g1, 2 2006660: 08 bf ff f4 bleu 2006630 2006664: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006668: 40 00 02 f7 call 2007244 <== NOT EXECUTED 200666c: 01 00 00 00 nop <== NOT EXECUTED } 2006670: 81 c7 e0 08 ret <== NOT EXECUTED 2006674: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006678: 08 bf ff ee bleu 2006630 <== NOT EXECUTED 200667c: 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( 2006680: c2 00 e1 70 ld [ %g3 + 0x170 ], %g1 2006684: 40 00 00 53 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006688: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 200668c: 81 c7 e0 08 ret 2006690: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2006694: 40 00 13 9b call 200b500 <_Thread_Dispatch> 2006698: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 200669c: 10 bf ff db b 2006608 20066a0: 80 a4 20 00 cmp %l0, 0 020066a4 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 20066a4: 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 ) 20066a8: 80 a6 20 00 cmp %i0, 0 20066ac: 02 80 00 2b be 2006758 20066b0: 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 ); 20066b4: 40 00 22 e9 call 200f258 <_POSIX_Absolute_timeout_to_ticks> 20066b8: 92 07 bf f0 add %fp, -16, %o1 switch (status) { 20066bc: 80 a2 20 02 cmp %o0, 2 20066c0: 08 80 00 29 bleu 2006764 20066c4: b2 10 00 08 mov %o0, %i1 20066c8: 80 a2 20 03 cmp %o0, 3 20066cc: 22 80 00 02 be,a 20066d4 20066d0: a0 10 20 01 mov 1, %l0 20066d4: d2 06 00 00 ld [ %i0 ], %o1 20066d8: 11 00 80 71 sethi %hi(0x201c400), %o0 20066dc: 94 07 bf f4 add %fp, -12, %o2 20066e0: 40 00 0e 90 call 200a120 <_Objects_Get> 20066e4: 90 12 23 2c or %o0, 0x32c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20066e8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20066ec: 80 a0 60 00 cmp %g1, 0 20066f0: 12 80 00 27 bne 200678c 20066f4: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20066f8: d2 06 00 00 ld [ %i0 ], %o1 20066fc: d6 07 bf f0 ld [ %fp + -16 ], %o3 2006700: 90 02 20 10 add %o0, 0x10, %o0 2006704: 94 10 00 10 mov %l0, %o2 2006708: 40 00 0a af call 20091c4 <_CORE_RWLock_Obtain_for_writing> 200670c: 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 ) 2006710: 03 00 80 71 sethi %hi(0x201c400), %g1 2006714: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 2006718: 84 00 bf ff add %g2, -1, %g2 200671c: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2006720: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006724: 80 a0 e0 00 cmp %g3, 0 2006728: 02 80 00 26 be 20067c0 200672c: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 2006730: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2006734: 12 80 00 1e bne 20067ac 2006738: 07 00 80 71 sethi %hi(0x201c400), %g3 200673c: c2 00 e1 70 ld [ %g3 + 0x170 ], %g1 ! 201c570 <_Thread_Executing> <== NOT EXECUTED 2006740: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 2006744: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 2006748: 12 80 00 1a bne 20067b0 <== NOT EXECUTED 200674c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 2006750: 12 80 00 15 bne 20067a4 <== NOT EXECUTED 2006754: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006758: 90 10 20 16 mov 0x16, %o0 } 200675c: 81 c7 e0 08 ret 2006760: 91 e8 00 08 restore %g0, %o0, %o0 2006764: d2 06 00 00 ld [ %i0 ], %o1 2006768: 11 00 80 71 sethi %hi(0x201c400), %o0 200676c: 94 07 bf f4 add %fp, -12, %o2 2006770: 40 00 0e 6c call 200a120 <_Objects_Get> 2006774: 90 12 23 2c or %o0, 0x32c, %o0 do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006778: c2 07 bf f4 ld [ %fp + -12 ], %g1 200677c: 80 a0 60 00 cmp %g1, 0 2006780: 02 bf ff de be 20066f8 2006784: a0 10 20 00 clr %l0 2006788: 80 a0 60 02 cmp %g1, 2 200678c: 08 bf ff f4 bleu 200675c 2006790: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006794: 40 00 02 ac call 2007244 <== NOT EXECUTED 2006798: 01 00 00 00 nop <== NOT EXECUTED } 200679c: 81 c7 e0 08 ret <== NOT EXECUTED 20067a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 20067a4: 08 bf ff ee bleu 200675c <== NOT EXECUTED 20067a8: 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( 20067ac: c2 00 e1 70 ld [ %g3 + 0x170 ], %g1 20067b0: 40 00 00 08 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 20067b4: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 20067b8: 81 c7 e0 08 ret 20067bc: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 20067c0: 40 00 13 50 call 200b500 <_Thread_Dispatch> 20067c4: 01 00 00 00 nop ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 20067c8: 10 bf ff db b 2006734 20067cc: 80 a4 20 00 cmp %l0, 0 020067fc : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 20067fc: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006800: 80 a6 20 00 cmp %i0, 0 2006804: 02 80 00 24 be 2006894 2006808: 11 00 80 71 sethi %hi(0x201c400), %o0 200680c: d2 06 00 00 ld [ %i0 ], %o1 2006810: 94 07 bf f4 add %fp, -12, %o2 2006814: 40 00 0e 43 call 200a120 <_Objects_Get> 2006818: 90 12 23 2c or %o0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 200681c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006820: 80 a0 60 00 cmp %g1, 0 2006824: 22 80 00 09 be,a 2006848 2006828: d2 06 00 00 ld [ %i0 ], %o1 200682c: 80 a0 60 02 cmp %g1, 2 2006830: 08 80 00 1a bleu 2006898 2006834: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006838: 40 00 02 83 call 2007244 <== NOT EXECUTED 200683c: 01 00 00 00 nop <== NOT EXECUTED } 2006840: 81 c7 e0 08 ret <== NOT EXECUTED 2006844: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 2006848: 90 02 20 10 add %o0, 0x10, %o0 200684c: 94 10 20 00 clr %o2 2006850: 96 10 20 00 clr %o3 2006854: 40 00 0a 27 call 20090f0 <_CORE_RWLock_Obtain_for_reading> 2006858: 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 ) 200685c: 03 00 80 71 sethi %hi(0x201c400), %g1 2006860: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 2006864: 84 00 bf ff add %g2, -1, %g2 2006868: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 200686c: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006870: 80 a0 e0 00 cmp %g3, 0 2006874: 02 80 00 0b be 20068a0 2006878: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 200687c: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED 2006880: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201c570 <_Thread_Executing> 2006884: 7f ff ff d3 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006888: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 200688c: 81 c7 e0 08 ret 2006890: 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(); 2006894: 90 10 20 16 mov 0x16, %o0 } 2006898: 81 c7 e0 08 ret 200689c: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 20068a0: 40 00 13 18 call 200b500 <_Thread_Dispatch> 20068a4: 01 00 00 00 nop NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 20068a8: 10 bf ff f6 b 2006880 20068ac: 03 00 80 71 sethi %hi(0x201c400), %g1 020068b0 : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 20068b0: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 20068b4: 80 a6 20 00 cmp %i0, 0 20068b8: 02 80 00 24 be 2006948 20068bc: 11 00 80 71 sethi %hi(0x201c400), %o0 20068c0: d2 06 00 00 ld [ %i0 ], %o1 20068c4: 94 07 bf f4 add %fp, -12, %o2 20068c8: 40 00 0e 16 call 200a120 <_Objects_Get> 20068cc: 90 12 23 2c or %o0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 20068d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20068d4: 80 a0 60 00 cmp %g1, 0 20068d8: 22 80 00 09 be,a 20068fc 20068dc: d2 06 00 00 ld [ %i0 ], %o1 20068e0: 80 a0 60 02 cmp %g1, 2 20068e4: 08 80 00 1a bleu 200694c 20068e8: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 20068ec: 40 00 02 56 call 2007244 <== NOT EXECUTED 20068f0: 01 00 00 00 nop <== NOT EXECUTED } 20068f4: 81 c7 e0 08 ret <== NOT EXECUTED 20068f8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 20068fc: 90 02 20 10 add %o0, 0x10, %o0 2006900: 94 10 20 00 clr %o2 2006904: 96 10 20 00 clr %o3 2006908: 40 00 0a 2f call 20091c4 <_CORE_RWLock_Obtain_for_writing> 200690c: 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 ) 2006910: 03 00 80 71 sethi %hi(0x201c400), %g1 2006914: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 2006918: 84 00 bf ff add %g2, -1, %g2 200691c: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2006920: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006924: 80 a0 e0 00 cmp %g3, 0 2006928: 02 80 00 0b be 2006954 200692c: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006930: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED 2006934: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201c570 <_Thread_Executing> 2006938: 7f ff ff a6 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 200693c: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006940: 81 c7 e0 08 ret 2006944: 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(); 2006948: 90 10 20 16 mov 0x16, %o0 } 200694c: 81 c7 e0 08 ret 2006950: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2006954: 40 00 12 eb call 200b500 <_Thread_Dispatch> 2006958: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 200695c: 10 bf ff f6 b 2006934 2006960: 03 00 80 71 sethi %hi(0x201c400), %g1 02006964 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 2006964: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 2006968: 80 a6 20 00 cmp %i0, 0 200696c: 02 80 00 1f be 20069e8 2006970: 11 00 80 71 sethi %hi(0x201c400), %o0 2006974: d2 06 00 00 ld [ %i0 ], %o1 2006978: 94 07 bf f4 add %fp, -12, %o2 200697c: 40 00 0d e9 call 200a120 <_Objects_Get> 2006980: 90 12 23 2c or %o0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006984: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006988: 80 a0 60 00 cmp %g1, 0 200698c: 02 80 00 08 be 20069ac 2006990: 80 a0 60 02 cmp %g1, 2 2006994: 08 80 00 16 bleu 20069ec 2006998: 90 10 20 16 mov 0x16, %o0 status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); } return POSIX_BOTTOM_REACHED(); 200699c: 40 00 02 2a call 2007244 <== NOT EXECUTED 20069a0: 01 00 00 00 nop <== NOT EXECUTED } 20069a4: 81 c7 e0 08 ret <== NOT EXECUTED 20069a8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 20069ac: 40 00 0a 28 call 200924c <_CORE_RWLock_Release> 20069b0: 90 02 20 10 add %o0, 0x10, %o0 20069b4: 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 ) 20069b8: 03 00 80 71 sethi %hi(0x201c400), %g1 20069bc: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 20069c0: 84 00 bf ff add %g2, -1, %g2 20069c4: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 20069c8: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 20069cc: 80 a0 e0 00 cmp %g3, 0 20069d0: 02 80 00 09 be 20069f4 20069d4: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 20069d8: 7f ff ff 7e call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 20069dc: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 20069e0: 81 c7 e0 08 ret 20069e4: 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(); 20069e8: 90 10 20 16 mov 0x16, %o0 } 20069ec: 81 c7 e0 08 ret 20069f0: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 20069f4: 40 00 12 c3 call 200b500 <_Thread_Dispatch> 20069f8: 01 00 00 00 nop 20069fc: 30 bf ff f7 b,a 20069d8 02006a00 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 2006a00: 9d e3 bf 90 save %sp, -112, %sp POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 2006a04: 80 a6 20 00 cmp %i0, 0 2006a08: 02 80 00 24 be 2006a98 2006a0c: 11 00 80 71 sethi %hi(0x201c400), %o0 2006a10: d2 06 00 00 ld [ %i0 ], %o1 2006a14: 94 07 bf f4 add %fp, -12, %o2 2006a18: 40 00 0d c2 call 200a120 <_Objects_Get> 2006a1c: 90 12 23 2c or %o0, 0x32c, %o0 return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 2006a20: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006a24: 80 a0 60 00 cmp %g1, 0 2006a28: 22 80 00 09 be,a 2006a4c 2006a2c: d2 06 00 00 ld [ %i0 ], %o1 2006a30: 80 a0 60 02 cmp %g1, 2 2006a34: 08 80 00 1a bleu 2006a9c 2006a38: 90 10 20 16 mov 0x16, %o0 return _POSIX_RWLock_Translate_core_RWLock_return_code( (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); 2006a3c: 40 00 02 02 call 2007244 <== NOT EXECUTED 2006a40: 01 00 00 00 nop <== NOT EXECUTED } 2006a44: 81 c7 e0 08 ret <== NOT EXECUTED 2006a48: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 2006a4c: 90 02 20 10 add %o0, 0x10, %o0 2006a50: 94 10 20 01 mov 1, %o2 2006a54: 96 10 20 00 clr %o3 2006a58: 40 00 09 db call 20091c4 <_CORE_RWLock_Obtain_for_writing> 2006a5c: 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 ) 2006a60: 03 00 80 71 sethi %hi(0x201c400), %g1 2006a64: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201c490 <_Thread_Dispatch_disable_level> 2006a68: 84 00 bf ff add %g2, -1, %g2 2006a6c: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2006a70: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2006a74: 80 a0 e0 00 cmp %g3, 0 2006a78: 02 80 00 0b be 2006aa4 2006a7c: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006a80: 03 00 80 71 sethi %hi(0x201c400), %g1 <== NOT EXECUTED 2006a84: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 ! 201c570 <_Thread_Executing> 2006a88: 7f ff ff 52 call 20067d0 <_POSIX_RWLock_Translate_core_RWLock_return_code> 2006a8c: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 (CORE_RWLock_Status) _Thread_Executing->Wait.return_code ); } return POSIX_BOTTOM_REACHED(); } 2006a90: 81 c7 e0 08 ret 2006a94: 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(); 2006a98: 90 10 20 16 mov 0x16, %o0 } 2006a9c: 81 c7 e0 08 ret 2006aa0: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2006aa4: 40 00 12 97 call 200b500 <_Thread_Dispatch> 2006aa8: 01 00 00 00 nop 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 2006aac: 10 bf ff f6 b 2006a84 2006ab0: 03 00 80 71 sethi %hi(0x201c400), %g1 02005cec : int pthread_setcancelstate( int state, int *oldstate ) { 2005cec: 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() ) 2005cf0: 03 00 80 60 sethi %hi(0x2018000), %g1 2005cf4: c4 00 61 18 ld [ %g1 + 0x118 ], %g2 ! 2018118 <_ISR_Nest_level> int pthread_setcancelstate( int state, int *oldstate ) { 2005cf8: 86 10 00 18 mov %i0, %g3 * 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() ) 2005cfc: 80 a0 a0 00 cmp %g2, 0 2005d00: 12 80 00 22 bne 2005d88 2005d04: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldstate ) 2005d08: 80 a6 60 00 cmp %i1, 0 2005d0c: 02 80 00 04 be 2005d1c 2005d10: 80 a0 e0 01 cmp %g3, 1 return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 2005d14: 08 80 00 04 bleu 2005d24 2005d18: 21 00 80 60 sethi %hi(0x2018000), %l0 thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); _Thread_Enable_dispatch(); return 0; } 2005d1c: 81 c7 e0 08 ret <== NOT EXECUTED 2005d20: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005d24: 09 00 80 60 sethi %hi(0x2018000), %g4 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005d28: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005d2c: c4 01 21 30 ld [ %g4 + 0x130 ], %g2 2005d30: 82 00 60 01 inc %g1 2005d34: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005d38: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 2005d3c: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005d40: 80 a0 e0 00 cmp %g3, 0 return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 2005d44: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005d48: 12 80 00 06 bne 2005d60 2005d4c: c6 20 a0 cc st %g3, [ %g2 + 0xcc ] 2005d50: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 2005d54: 80 a0 60 01 cmp %g1, 1 2005d58: 22 80 00 0e be,a 2005d90 2005d5c: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 <== 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 ) 2005d60: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005d64: b0 10 20 00 clr %i0 2005d68: 82 00 7f ff add %g1, -1, %g1 2005d6c: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2005d70: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2005d74: 80 a0 a0 00 cmp %g2, 0 2005d78: 12 80 00 04 bne 2005d88 2005d7c: 01 00 00 00 nop _Thread_Dispatch(); 2005d80: 40 00 10 32 call 2009e48 <_Thread_Dispatch> 2005d84: 01 00 00 00 nop 2005d88: 81 c7 e0 08 ret 2005d8c: 81 e8 00 00 restore 2005d90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005d94: 02 bf ff f3 be 2005d60 <== NOT EXECUTED 2005d98: 01 00 00 00 nop <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 2005d9c: 7f ff fd b7 call 2005478 <_POSIX_Threads_cancel_run> <== NOT EXECUTED 2005da0: d0 01 21 30 ld [ %g4 + 0x130 ], %o0 <== NOT EXECUTED 2005da4: 30 bf ff ef b,a 2005d60 <== NOT EXECUTED 02005da8 : int pthread_setcanceltype( int type, int *oldtype ) { 2005da8: 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() ) 2005dac: 03 00 80 60 sethi %hi(0x2018000), %g1 2005db0: c4 00 61 18 ld [ %g1 + 0x118 ], %g2 ! 2018118 <_ISR_Nest_level> int pthread_setcanceltype( int type, int *oldtype ) { 2005db4: 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() ) 2005db8: 80 a0 a0 00 cmp %g2, 0 2005dbc: 12 80 00 22 bne 2005e44 2005dc0: b0 10 20 47 mov 0x47, %i0 return EPROTO; if ( !oldtype ) 2005dc4: 80 a6 60 00 cmp %i1, 0 2005dc8: 02 80 00 04 be 2005dd8 2005dcc: 80 a1 20 01 cmp %g4, 1 return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 2005dd0: 08 80 00 04 bleu 2005de0 2005dd4: 21 00 80 60 sethi %hi(0x2018000), %l0 thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); _Thread_Enable_dispatch(); return 0; } 2005dd8: 81 c7 e0 08 ret <== NOT EXECUTED 2005ddc: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005de0: 1b 00 80 60 sethi %hi(0x2018000), %o5 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005de4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005de8: c4 03 61 30 ld [ %o5 + 0x130 ], %g2 2005dec: 82 00 60 01 inc %g1 2005df0: c6 00 a1 74 ld [ %g2 + 0x174 ], %g3 2005df4: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 2005df8: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 2005dfc: c2 26 40 00 st %g1, [ %i1 ] thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005e00: c4 00 e0 cc ld [ %g3 + 0xcc ], %g2 2005e04: 80 a0 a0 00 cmp %g2, 0 2005e08: 12 80 00 05 bne 2005e1c 2005e0c: c8 20 e0 d0 st %g4, [ %g3 + 0xd0 ] 2005e10: 80 a1 20 01 cmp %g4, 1 2005e14: 22 80 00 0e be,a 2005e4c 2005e18: c2 00 e0 d4 ld [ %g3 + 0xd4 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005e1c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005e20: b0 10 20 00 clr %i0 2005e24: 82 00 7f ff add %g1, -1, %g1 2005e28: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2005e2c: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2005e30: 80 a0 a0 00 cmp %g2, 0 2005e34: 12 80 00 04 bne 2005e44 2005e38: 01 00 00 00 nop _Thread_Dispatch(); 2005e3c: 40 00 10 03 call 2009e48 <_Thread_Dispatch> 2005e40: 01 00 00 00 nop 2005e44: 81 c7 e0 08 ret 2005e48: 81 e8 00 00 restore 2005e4c: 80 a0 60 00 cmp %g1, 0 2005e50: 02 bf ff f3 be 2005e1c 2005e54: 01 00 00 00 nop thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 2005e58: 7f ff fd 88 call 2005478 <_POSIX_Threads_cancel_run> <== NOT EXECUTED 2005e5c: d0 03 61 30 ld [ %o5 + 0x130 ], %o0 <== NOT EXECUTED 2005e60: 30 bf ff ef b,a 2005e1c <== NOT EXECUTED 020088fc : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 20088fc: 9d e3 bf 90 save %sp, -112, %sp /* * Check all the parameters */ if ( !param ) 2008900: 80 a6 a0 00 cmp %i2, 0 2008904: 02 80 00 10 be 2008944 2008908: 90 10 20 16 mov 0x16, %o0 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 200890c: c2 06 80 00 ld [ %i2 ], %g1 2008910: 82 00 7f ff add %g1, -1, %g1 2008914: 80 a0 60 fd cmp %g1, 0xfd 2008918: 18 80 00 0b bgu 2008944 200891c: 80 a6 60 01 cmp %i1, 1 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2008920: 02 80 00 66 be 2008ab8 2008924: a2 10 20 00 clr %l1 2008928: 04 80 00 66 ble 2008ac0 200892c: 80 a6 60 02 cmp %i1, 2 2008930: 02 80 00 07 be 200894c 2008934: 80 a6 60 03 cmp %i1, 3 2008938: 02 80 00 41 be 2008a3c 200893c: 01 00 00 00 nop } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2008940: 90 10 20 16 mov 0x16, %o0 ! 16 } 2008944: 81 c7 e0 08 ret 2008948: 91 e8 00 08 restore %g0, %o0, %o0 return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 200894c: a2 10 20 02 mov 2, %l1 2008950: a4 10 20 00 clr %l2 2008954: 92 10 00 18 mov %i0, %o1 2008958: 11 00 80 6d sethi %hi(0x201b400), %o0 200895c: 94 07 bf f4 add %fp, -12, %o2 2008960: 40 00 0b 36 call 200b638 <_Objects_Get> 2008964: 90 12 23 d8 or %o0, 0x3d8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008968: c2 07 bf f4 ld [ %fp + -12 ], %g1 200896c: 80 a0 60 00 cmp %g1, 0 2008970: 12 80 00 4b bne 2008a9c 2008974: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: case OBJECTS_REMOTE: return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 2008978: e0 02 21 74 ld [ %o0 + 0x174 ], %l0 if ( api->schedpolicy == SCHED_SPORADIC ) 200897c: c2 04 20 7c ld [ %l0 + 0x7c ], %g1 2008980: 80 a0 60 03 cmp %g1, 3 2008984: 02 80 00 5e be 2008afc 2008988: 01 00 00 00 nop (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 200898c: f2 24 20 7c st %i1, [ %l0 + 0x7c ] api->schedparam = *param; 2008990: c6 06 80 00 ld [ %i2 ], %g3 the_thread->budget_algorithm = budget_algorithm; 2008994: e2 26 20 88 st %l1, [ %i0 + 0x88 ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 2008998: c6 24 20 80 st %g3, [ %l0 + 0x80 ] 200899c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; 20089a0: e4 26 20 8c st %l2, [ %i0 + 0x8c ] if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 20089a4: c2 24 20 84 st %g1, [ %l0 + 0x84 ] 20089a8: c4 06 a0 08 ld [ %i2 + 8 ], %g2 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20089ac: 80 a6 60 00 cmp %i1, 0 if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; api->schedparam = *param; 20089b0: c4 24 20 88 st %g2, [ %l0 + 0x88 ] 20089b4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 20089b8: c2 24 20 8c st %g1, [ %l0 + 0x8c ] 20089bc: c4 06 a0 10 ld [ %i2 + 0x10 ], %g2 20089c0: c4 24 20 90 st %g2, [ %l0 + 0x90 ] 20089c4: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 20089c8: 06 80 00 0f bl 2008a04 20089cc: c2 24 20 94 st %g1, [ %l0 + 0x94 ] 20089d0: 80 a6 60 02 cmp %i1, 2 20089d4: 14 80 00 41 bg 2008ad8 20089d8: 80 a6 60 03 cmp %i1, 3 20089dc: c6 04 20 80 ld [ %l0 + 0x80 ], %g3 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 20089e0: 03 00 80 6d sethi %hi(0x201b400), %g1 20089e4: c4 00 60 48 ld [ %g1 + 0x48 ], %g2 ! 201b448 <_Thread_Ticks_per_timeslice> 20089e8: 92 10 20 ff mov 0xff, %o1 the_thread->real_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 20089ec: 90 10 00 18 mov %i0, %o0 20089f0: 92 22 40 03 sub %o1, %g3, %o1 switch ( api->schedpolicy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 20089f4: c4 26 20 84 st %g2, [ %i0 + 0x84 ] the_thread->real_priority = 20089f8: d2 26 20 18 st %o1, [ %i0 + 0x18 ] _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 20089fc: 40 00 0e d7 call 200c558 <_Thread_Change_priority> 2008a00: 94 10 20 01 mov 1, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2008a04: 03 00 80 6d sethi %hi(0x201b400), %g1 2008a08: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 201b4f0 <_Thread_Dispatch_disable_level> 2008a0c: 90 10 20 00 clr %o0 2008a10: 84 00 bf ff add %g2, -1, %g2 2008a14: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ] 2008a18: c6 00 60 f0 ld [ %g1 + 0xf0 ], %g3 2008a1c: 80 a0 e0 00 cmp %g3, 0 2008a20: 12 bf ff c9 bne 2008944 2008a24: 01 00 00 00 nop _Thread_Dispatch(); 2008a28: 40 00 0f fc call 200ca18 <_Thread_Dispatch> 2008a2c: 01 00 00 00 nop 2008a30: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2008a34: 81 c7 e0 08 ret 2008a38: 91 e8 00 08 restore %g0, %o0, %o0 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 ) < 2008a3c: 40 00 14 b9 call 200dd20 <_Timespec_To_ticks> 2008a40: 90 06 a0 08 add %i2, 8, %o0 2008a44: a0 10 00 08 mov %o0, %l0 2008a48: 40 00 14 b6 call 200dd20 <_Timespec_To_ticks> 2008a4c: 90 06 a0 10 add %i2, 0x10, %o0 2008a50: 80 a4 00 08 cmp %l0, %o0 2008a54: 2a bf ff bc bcs,a 2008944 2008a58: 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 ) ) 2008a5c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 2008a60: 82 00 7f ff add %g1, -1, %g1 2008a64: 80 a0 60 fd cmp %g1, 0xfd 2008a68: 18 bf ff b6 bgu 2008940 2008a6c: 03 00 80 21 sethi %hi(0x2008400), %g1 2008a70: 92 10 00 18 mov %i0, %o1 2008a74: a4 10 63 c0 or %g1, 0x3c0, %l2 2008a78: 11 00 80 6d sethi %hi(0x201b400), %o0 2008a7c: 94 07 bf f4 add %fp, -12, %o2 2008a80: 40 00 0a ee call 200b638 <_Objects_Get> 2008a84: 90 12 23 d8 or %o0, 0x3d8, %o0 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008a88: c2 07 bf f4 ld [ %fp + -12 ], %g1 if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 2008a8c: a2 10 20 03 mov 3, %l1 /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 2008a90: 80 a0 60 00 cmp %g1, 0 2008a94: 02 bf ff b9 be 2008978 2008a98: b0 10 00 08 mov %o0, %i0 2008a9c: 80 a0 60 02 cmp %g1, 2 2008aa0: 08 bf ff a9 bleu 2008944 2008aa4: 90 10 20 03 mov 3, %o0 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2008aa8: 40 00 00 2c call 2008b58 <== NOT EXECUTED 2008aac: 01 00 00 00 nop <== NOT EXECUTED } 2008ab0: 81 c7 e0 08 ret <== NOT EXECUTED 2008ab4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 2008ab8: 10 bf ff a7 b 2008954 2008abc: a4 10 20 00 clr %l2 2008ac0: 80 a6 60 00 cmp %i1, 0 2008ac4: a2 10 20 01 mov 1, %l1 2008ac8: 02 bf ff a3 be 2008954 2008acc: a4 10 20 00 clr %l2 } _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2008ad0: 10 bf ff 9d b 2008944 2008ad4: 90 10 20 16 mov 0x16, %o0 api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 2008ad8: 12 bf ff cb bne 2008a04 2008adc: 01 00 00 00 nop TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 2008ae0: c6 24 20 98 st %g3, [ %l0 + 0x98 ] _Watchdog_Remove( &api->Sporadic_timer ); 2008ae4: 40 00 16 0c call 200e314 <_Watchdog_Remove> 2008ae8: 90 04 20 9c add %l0, 0x9c, %o0 _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 2008aec: 92 10 00 18 mov %i0, %o1 2008af0: 7f ff ff 48 call 2008810 <_POSIX_Threads_Sporadic_budget_TSR> 2008af4: 90 10 20 00 clr %o0 2008af8: 30 bf ff c3 b,a 2008a04 return ESRCH; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 2008afc: 40 00 16 06 call 200e314 <_Watchdog_Remove> 2008b00: 90 04 20 9c add %l0, 0x9c, %o0 api->schedpolicy = policy; 2008b04: 10 bf ff a3 b 2008990 2008b08: f2 24 20 7c st %i1, [ %l0 + 0x7c ] 02005d64 : int pthread_setspecific( pthread_key_t key, const void *value ) { 2005d64: 9d e3 bf 90 save %sp, -112, %sp 2005d68: 11 00 80 61 sethi %hi(0x2018400), %o0 2005d6c: 92 10 00 18 mov %i0, %o1 2005d70: 90 12 21 f0 or %o0, 0x1f0, %o0 2005d74: 40 00 0d 21 call 20091f8 <_Objects_Get> 2005d78: 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 ) { 2005d7c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005d80: 80 a0 60 00 cmp %g1, 0 2005d84: 12 80 00 19 bne 2005de8 2005d88: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: case OBJECTS_REMOTE: /* should never happen */ return EINVAL; case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 2005d8c: 03 00 80 60 sethi %hi(0x2018000), %g1 2005d90: c4 00 61 d0 ld [ %g1 + 0x1d0 ], %g2 ! 20181d0 <_Thread_Executing> 2005d94: c6 00 a0 08 ld [ %g2 + 8 ], %g3 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 2005d98: 05 00 00 3f sethi %hi(0xfc00), %g2 2005d9c: 83 30 e0 16 srl %g3, 0x16, %g1 2005da0: 82 08 60 1c and %g1, 0x1c, %g1 2005da4: 82 00 40 08 add %g1, %o0, %g1 2005da8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4 2005dac: 84 10 a3 ff or %g2, 0x3ff, %g2 2005db0: 86 08 c0 02 and %g3, %g2, %g3 2005db4: 87 28 e0 02 sll %g3, 2, %g3 2005db8: f2 21 00 03 st %i1, [ %g4 + %g3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005dbc: 07 00 80 60 sethi %hi(0x2018000), %g3 2005dc0: c2 00 e0 f0 ld [ %g3 + 0xf0 ], %g1 ! 20180f0 <_Thread_Dispatch_disable_level> 2005dc4: 90 10 20 00 clr %o0 2005dc8: 82 00 7f ff add %g1, -1, %g1 2005dcc: c2 20 e0 f0 st %g1, [ %g3 + 0xf0 ] 2005dd0: c4 00 e0 f0 ld [ %g3 + 0xf0 ], %g2 2005dd4: 80 a0 a0 00 cmp %g2, 0 2005dd8: 02 80 00 0a be 2005e00 2005ddc: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2005de0: 81 c7 e0 08 ret 2005de4: 91 e8 00 08 restore %g0, %o0, %o0 uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 2005de8: 08 bf ff fe bleu 2005de0 2005dec: 90 10 20 16 mov 0x16, %o0 index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2005df0: 40 00 02 4a call 2006718 <== NOT EXECUTED 2005df4: 01 00 00 00 nop <== NOT EXECUTED } 2005df8: 81 c7 e0 08 ret <== NOT EXECUTED 2005dfc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2005e00: 40 00 11 f6 call 200a5d8 <_Thread_Dispatch> 2005e04: 01 00 00 00 nop 2005e08: 90 10 20 00 clr %o0 ! 0 2005e0c: 81 c7 e0 08 ret 2005e10: 91 e8 00 08 restore %g0, %o0, %o0 02005964 : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 2005964: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 2005968: 80 a6 20 00 cmp %i0, 0 200596c: 02 80 00 23 be 20059f8 2005970: 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( 2005974: d2 06 00 00 ld [ %i0 ], %o1 2005978: 31 00 80 55 sethi %hi(0x2015400), %i0 200597c: 40 00 0c 4d call 2008ab0 <_Objects_Get> 2005980: 90 16 22 e4 or %i0, 0x2e4, %o0 ! 20156e4 <_POSIX_Spinlock_Information> return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005984: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005988: 80 a0 60 00 cmp %g1, 0 200598c: 12 80 00 14 bne 20059dc 2005990: 92 10 00 08 mov %o0, %o1 RTEMS_INLINE_ROUTINE boolean _CORE_spinlock_Is_busy( CORE_spinlock_Control *the_spinlock ) { return (the_spinlock->users != 0); 2005994: 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 ) ) { 2005998: 80 a0 60 00 cmp %g1, 0 200599c: 02 80 00 1a be 2005a04 20059a0: 90 16 22 e4 or %i0, 0x2e4, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20059a4: 03 00 80 54 sethi %hi(0x2015000), %g1 20059a8: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20153b0 <_Thread_Dispatch_disable_level> 20059ac: 90 10 20 10 mov 0x10, %o0 20059b0: 84 00 bf ff add %g2, -1, %g2 20059b4: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 20059b8: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 20059bc: 80 a0 e0 00 cmp %g3, 0 20059c0: 12 80 00 0c bne 20059f0 20059c4: 01 00 00 00 nop _Thread_Dispatch(); 20059c8: 40 00 11 32 call 2009e90 <_Thread_Dispatch> 20059cc: 01 00 00 00 nop 20059d0: 90 10 20 10 mov 0x10, %o0 ! 10 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 20059d4: 81 c7 e0 08 ret 20059d8: 91 e8 00 08 restore %g0, %o0, %o0 if ( !spinlock ) return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 20059dc: 80 a0 60 02 cmp %g1, 2 20059e0: 08 80 00 07 bleu 20059fc 20059e4: 90 10 20 16 mov 0x16, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20059e8: 40 00 00 e9 call 2005d8c <== NOT EXECUTED 20059ec: 01 00 00 00 nop <== NOT EXECUTED } 20059f0: 81 c7 e0 08 ret 20059f4: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20059f8: 90 10 20 16 mov 0x16, %o0 } 20059fc: 81 c7 e0 08 ret 2005a00: 91 e8 00 08 restore %g0, %o0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005a04: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005a08: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005a0c: 05 00 00 3f sethi %hi(0xfc00), %g2 2005a10: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005a14: 82 08 40 02 and %g1, %g2, %g1 2005a18: 80 a0 40 03 cmp %g1, %g3 2005a1c: 18 80 00 04 bgu 2005a2c 2005a20: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 2005a24: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005a28: 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 ); 2005a2c: 40 00 0b de call 20089a4 <_Objects_Free> 2005a30: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005a34: 03 00 80 54 sethi %hi(0x2015000), %g1 2005a38: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20153b0 <_Thread_Dispatch_disable_level> 2005a3c: 90 10 20 00 clr %o0 2005a40: 84 00 bf ff add %g2, -1, %g2 2005a44: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 2005a48: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 2005a4c: 80 a0 e0 00 cmp %g3, 0 2005a50: 12 bf ff e8 bne 20059f0 2005a54: 01 00 00 00 nop _Thread_Dispatch(); 2005a58: 40 00 11 0e call 2009e90 <_Thread_Dispatch> 2005a5c: 01 00 00 00 nop 2005a60: 10 bf ff e4 b 20059f0 2005a64: 90 10 20 00 clr %o0 ! 0 02005a68 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 2005a68: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 2005a6c: 80 a6 20 00 cmp %i0, 0 2005a70: 02 80 00 1a be 2005ad8 2005a74: 80 a6 60 00 cmp %i1, 0 return EINVAL; switch ( pshared ) { 2005a78: 32 80 00 16 bne,a 2005ad0 2005a7c: b0 10 20 16 mov 0x16, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005a80: 21 00 80 54 sethi %hi(0x2015000), %l0 2005a84: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 ! 20153b0 <_Thread_Dispatch_disable_level> 2005a88: 82 00 60 01 inc %g1 2005a8c: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] * 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 *) 2005a90: 23 00 80 55 sethi %hi(0x2015400), %l1 2005a94: 40 00 0a b6 call 200856c <_Objects_Allocate> 2005a98: 90 14 62 e4 or %l1, 0x2e4, %o0 ! 20156e4 <_POSIX_Spinlock_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 2005a9c: b2 92 20 00 orcc %o0, 0, %i1 2005aa0: 12 80 00 11 bne 2005ae4 2005aa4: 90 06 60 10 add %i1, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005aa8: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 2005aac: b0 10 20 0b mov 0xb, %i0 _Thread_Dispatch(); 2005ab0: 82 00 7f ff add %g1, -1, %g1 2005ab4: c2 24 23 b0 st %g1, [ %l0 + 0x3b0 ] 2005ab8: c4 04 23 b0 ld [ %l0 + 0x3b0 ], %g2 2005abc: 80 a0 a0 00 cmp %g2, 0 2005ac0: 12 80 00 07 bne 2005adc 2005ac4: 01 00 00 00 nop 2005ac8: 40 00 10 f2 call 2009e90 <_Thread_Dispatch> 2005acc: 01 00 00 00 nop 2005ad0: 81 c7 e0 08 ret 2005ad4: 81 e8 00 00 restore 2005ad8: b0 10 20 16 mov 0x16, %i0 *spinlock = the_spinlock->Object.id; _Thread_Enable_dispatch(); return 0; } 2005adc: 81 c7 e0 08 ret 2005ae0: 81 e8 00 00 restore if ( !the_spinlock ) { _Thread_Enable_dispatch(); return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 2005ae4: 40 00 08 75 call 2007cb8 <_CORE_spinlock_Initialize> 2005ae8: 92 07 bf f4 add %fp, -12, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005aec: 90 14 62 e4 or %l1, 0x2e4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005af0: c6 06 60 08 ld [ %i1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005af4: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005af8: 03 00 00 3f sethi %hi(0xfc00), %g1 2005afc: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005b00: 82 08 c0 01 and %g3, %g1, %g1 2005b04: 80 a0 40 02 cmp %g1, %g2 2005b08: 38 80 00 06 bgu,a 2005b20 2005b0c: c6 26 00 00 st %g3, [ %i0 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005b10: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005b14: 83 28 60 02 sll %g1, 2, %g1 2005b18: f2 20 80 01 st %i1, [ %g2 + %g1 ] &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 2005b1c: c6 26 00 00 st %g3, [ %i0 ] 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; 2005b20: c0 26 60 0c clr [ %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 ) 2005b24: c2 04 23 b0 ld [ %l0 + 0x3b0 ], %g1 2005b28: 10 bf ff e2 b 2005ab0 2005b2c: b0 10 20 00 clr %i0 02005b30 : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 2005b30: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005b34: 80 a6 20 00 cmp %i0, 0 2005b38: 02 80 00 21 be 2005bbc 2005b3c: 11 00 80 55 sethi %hi(0x2015400), %o0 RTEMS_INLINE_ROUTINE POSIX_Spinlock_Control *_POSIX_Spinlock_Get ( pthread_spinlock_t *spinlock, Objects_Locations *location ) { return (POSIX_Spinlock_Control *) _Objects_Get( 2005b40: d2 06 00 00 ld [ %i0 ], %o1 2005b44: 94 07 bf f4 add %fp, -12, %o2 2005b48: 40 00 0b da call 2008ab0 <_Objects_Get> 2005b4c: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005b50: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005b54: 80 a0 60 00 cmp %g1, 0 2005b58: 02 80 00 09 be 2005b7c 2005b5c: 92 10 20 01 mov 1, %o1 2005b60: 80 a0 60 02 cmp %g1, 2 2005b64: 08 80 00 17 bleu 2005bc0 2005b68: 90 10 20 16 mov 0x16, %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(); 2005b6c: 40 00 00 88 call 2005d8c <== NOT EXECUTED 2005b70: 01 00 00 00 nop <== NOT EXECUTED } 2005b74: 81 c7 e0 08 ret <== NOT EXECUTED 2005b78: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 2005b7c: 94 10 20 00 clr %o2 2005b80: 40 00 08 73 call 2007d4c <_CORE_spinlock_Wait> 2005b84: 90 02 20 10 add %o0, 0x10, %o0 2005b88: b0 10 00 08 mov %o0, %i0 2005b8c: 03 00 80 54 sethi %hi(0x2015000), %g1 2005b90: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20153b0 <_Thread_Dispatch_disable_level> 2005b94: 84 00 bf ff add %g2, -1, %g2 2005b98: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 2005b9c: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 2005ba0: 80 a0 e0 00 cmp %g3, 0 2005ba4: 02 80 00 09 be 2005bc8 2005ba8: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005bac: 40 00 00 0a call 2005bd4 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 2005bb0: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005bb4: 81 c7 e0 08 ret 2005bb8: 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(); 2005bbc: 90 10 20 16 mov 0x16, %o0 } 2005bc0: 81 c7 e0 08 ret 2005bc4: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2005bc8: 40 00 10 b2 call 2009e90 <_Thread_Dispatch> 2005bcc: 01 00 00 00 nop 2005bd0: 30 bf ff f7 b,a 2005bac 02005c00 : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 2005c00: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005c04: 80 a6 20 00 cmp %i0, 0 2005c08: 02 80 00 21 be 2005c8c 2005c0c: 11 00 80 55 sethi %hi(0x2015400), %o0 2005c10: d2 06 00 00 ld [ %i0 ], %o1 2005c14: 94 07 bf f4 add %fp, -12, %o2 2005c18: 40 00 0b a6 call 2008ab0 <_Objects_Get> 2005c1c: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005c20: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005c24: 80 a0 60 00 cmp %g1, 0 2005c28: 02 80 00 09 be 2005c4c 2005c2c: 92 10 20 00 clr %o1 2005c30: 80 a0 60 02 cmp %g1, 2 2005c34: 08 80 00 17 bleu 2005c90 2005c38: 90 10 20 16 mov 0x16, %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(); 2005c3c: 40 00 00 54 call 2005d8c <== NOT EXECUTED 2005c40: 01 00 00 00 nop <== NOT EXECUTED } 2005c44: 81 c7 e0 08 ret <== NOT EXECUTED 2005c48: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 2005c4c: 94 10 20 00 clr %o2 2005c50: 40 00 08 3f call 2007d4c <_CORE_spinlock_Wait> 2005c54: 90 02 20 10 add %o0, 0x10, %o0 2005c58: 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 ) 2005c5c: 03 00 80 54 sethi %hi(0x2015000), %g1 2005c60: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20153b0 <_Thread_Dispatch_disable_level> 2005c64: 84 00 bf ff add %g2, -1, %g2 2005c68: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 2005c6c: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 2005c70: 80 a0 e0 00 cmp %g3, 0 2005c74: 02 80 00 09 be 2005c98 2005c78: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005c7c: 7f ff ff d6 call 2005bd4 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 2005c80: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005c84: 81 c7 e0 08 ret 2005c88: 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(); 2005c8c: 90 10 20 16 mov 0x16, %o0 } 2005c90: 81 c7 e0 08 ret 2005c94: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2005c98: 40 00 10 7e call 2009e90 <_Thread_Dispatch> 2005c9c: 01 00 00 00 nop 2005ca0: 30 bf ff f7 b,a 2005c7c 02005ca4 : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 2005ca4: 9d e3 bf 90 save %sp, -112, %sp POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 2005ca8: 80 a6 20 00 cmp %i0, 0 2005cac: 02 80 00 1f be 2005d28 2005cb0: 11 00 80 55 sethi %hi(0x2015400), %o0 2005cb4: d2 06 00 00 ld [ %i0 ], %o1 2005cb8: 94 07 bf f4 add %fp, -12, %o2 2005cbc: 40 00 0b 7d call 2008ab0 <_Objects_Get> 2005cc0: 90 12 22 e4 or %o0, 0x2e4, %o0 return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 2005cc4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cc8: 80 a0 60 00 cmp %g1, 0 2005ccc: 02 80 00 08 be 2005cec 2005cd0: 80 a0 60 02 cmp %g1, 2 2005cd4: 08 80 00 16 bleu 2005d2c 2005cd8: 90 10 20 16 mov 0x16, %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(); 2005cdc: 40 00 00 2c call 2005d8c <== NOT EXECUTED 2005ce0: 01 00 00 00 nop <== NOT EXECUTED } 2005ce4: 81 c7 e0 08 ret <== NOT EXECUTED 2005ce8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_REMOTE: case OBJECTS_ERROR: return EINVAL; case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 2005cec: 40 00 07 fa call 2007cd4 <_CORE_spinlock_Release> 2005cf0: 90 02 20 10 add %o0, 0x10, %o0 2005cf4: 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 ) 2005cf8: 03 00 80 54 sethi %hi(0x2015000), %g1 2005cfc: c4 00 63 b0 ld [ %g1 + 0x3b0 ], %g2 ! 20153b0 <_Thread_Dispatch_disable_level> 2005d00: 84 00 bf ff add %g2, -1, %g2 2005d04: c4 20 63 b0 st %g2, [ %g1 + 0x3b0 ] 2005d08: c6 00 63 b0 ld [ %g1 + 0x3b0 ], %g3 2005d0c: 80 a0 e0 00 cmp %g3, 0 2005d10: 02 80 00 09 be 2005d34 2005d14: 01 00 00 00 nop _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 2005d18: 7f ff ff af call 2005bd4 <_POSIX_Spinlock_Translate_core_spinlock_return_code> 2005d1c: 90 10 00 18 mov %i0, %o0 } return POSIX_BOTTOM_REACHED(); } 2005d20: 81 c7 e0 08 ret 2005d24: 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(); 2005d28: 90 10 20 16 mov 0x16, %o0 } 2005d2c: 81 c7 e0 08 ret 2005d30: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2005d34: 40 00 10 57 call 2009e90 <_Thread_Dispatch> 2005d38: 01 00 00 00 nop 2005d3c: 30 bf ff f7 b,a 2005d18 02005e88 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 2005e88: 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() ) 2005e8c: 03 00 80 60 sethi %hi(0x2018000), %g1 2005e90: c4 00 61 18 ld [ %g1 + 0x118 ], %g2 ! 2018118 <_ISR_Nest_level> 2005e94: 80 a0 a0 00 cmp %g2, 0 2005e98: 12 80 00 17 bne 2005ef4 2005e9c: 21 00 80 60 sethi %hi(0x2018000), %l0 return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 2005ea0: 07 00 80 60 sethi %hi(0x2018000), %g3 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005ea4: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005ea8: c4 00 e1 30 ld [ %g3 + 0x130 ], %g2 2005eac: 82 00 60 01 inc %g1 2005eb0: c4 00 a1 74 ld [ %g2 + 0x174 ], %g2 2005eb4: c2 24 20 50 st %g1, [ %l0 + 0x50 ] _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 2005eb8: c2 00 a0 cc ld [ %g2 + 0xcc ], %g1 2005ebc: 80 a0 60 00 cmp %g1, 0 2005ec0: 12 80 00 06 bne 2005ed8 2005ec4: 01 00 00 00 nop 2005ec8: c2 00 a0 d4 ld [ %g2 + 0xd4 ], %g1 2005ecc: 80 a0 60 00 cmp %g1, 0 2005ed0: 12 80 00 0d bne 2005f04 2005ed4: 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 ) 2005ed8: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005edc: 82 00 7f ff add %g1, -1, %g1 2005ee0: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2005ee4: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2005ee8: 80 a0 a0 00 cmp %g2, 0 2005eec: 02 80 00 04 be 2005efc 2005ef0: 01 00 00 00 nop 2005ef4: 81 c7 e0 08 ret <== NOT EXECUTED 2005ef8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2005efc: 40 00 0f d3 call 2009e48 <_Thread_Dispatch> 2005f00: 81 e8 00 00 restore thread_support->cancelation_requested ) _POSIX_Threads_cancel_run( _Thread_Executing ); 2005f04: 7f ff fd 5d call 2005478 <_POSIX_Threads_cancel_run> 2005f08: d0 00 e1 30 ld [ %g3 + 0x130 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005f0c: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 2005f10: 82 00 7f ff add %g1, -1, %g1 2005f14: c2 24 20 50 st %g1, [ %l0 + 0x50 ] 2005f18: c4 04 20 50 ld [ %l0 + 0x50 ], %g2 2005f1c: 80 a0 a0 00 cmp %g2, 0 2005f20: 12 bf ff f5 bne 2005ef4 2005f24: 01 00 00 00 nop 2005f28: 30 bf ff f5 b,a 2005efc 02016f60 : ssize_t read( int fd, void *buffer, size_t count ) { 2016f60: 9d e3 bf 98 save %sp, -104, %sp ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2016f64: 03 00 80 61 sethi %hi(0x2018400), %g1 2016f68: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20184ec ssize_t read( int fd, void *buffer, size_t count ) { 2016f6c: 92 10 00 19 mov %i1, %o1 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 2016f70: 80 a6 00 02 cmp %i0, %g2 2016f74: 1a 80 00 24 bcc 2017004 2016f78: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 2016f7c: 03 00 80 65 sethi %hi(0x2019400), %g1 2016f80: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 ! 2019670 2016f84: 85 2e 20 02 sll %i0, 2, %g2 2016f88: 83 2e 20 04 sll %i0, 4, %g1 2016f8c: 82 20 40 02 sub %g1, %g2, %g1 2016f90: 82 00 40 18 add %g1, %i0, %g1 2016f94: 83 28 60 02 sll %g1, 2, %g1 2016f98: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 2016f9c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 2016fa0: 80 88 61 00 btst 0x100, %g1 2016fa4: 02 80 00 18 be 2017004 2016fa8: 80 a6 60 00 cmp %i1, 0 rtems_libio_check_buffer( buffer ); 2016fac: 02 80 00 1c be 201701c 2016fb0: 80 a6 a0 00 cmp %i2, 0 rtems_libio_check_count( count ); 2016fb4: 02 80 00 12 be 2016ffc 2016fb8: 90 10 20 00 clr %o0 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 2016fbc: 80 88 60 02 btst 2, %g1 2016fc0: 02 80 00 17 be 201701c 2016fc4: 01 00 00 00 nop /* * Now process the read(). */ if ( !iop->handlers->read_h ) 2016fc8: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2016fcc: c2 00 60 08 ld [ %g1 + 8 ], %g1 2016fd0: 80 a0 60 00 cmp %g1, 0 2016fd4: 02 80 00 18 be 2017034 2016fd8: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->read_h)( iop, buffer, count ); 2016fdc: 9f c0 40 00 call %g1 2016fe0: 90 10 00 18 mov %i0, %o0 if ( rc > 0 ) 2016fe4: 80 a2 20 00 cmp %o0, 0 2016fe8: 04 80 00 05 ble 2016ffc 2016fec: 01 00 00 00 nop iop->offset += rc; 2016ff0: c2 06 20 08 ld [ %i0 + 8 ], %g1 2016ff4: 82 00 40 08 add %g1, %o0, %g1 2016ff8: c2 26 20 08 st %g1, [ %i0 + 8 ] return rc; } 2016ffc: 81 c7 e0 08 ret 2017000: 91 e8 00 08 restore %g0, %o0, %o0 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 2017004: 7f ff e0 2f call 200f0c0 <__errno> <== NOT EXECUTED 2017008: 01 00 00 00 nop <== NOT EXECUTED 201700c: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 2017010: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017014: 10 bf ff fa b 2016ffc <== NOT EXECUTED 2017018: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 201701c: 7f ff e0 29 call 200f0c0 <__errno> <== NOT EXECUTED 2017020: 01 00 00 00 nop <== NOT EXECUTED 2017024: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2017028: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 201702c: 10 bf ff f4 b 2016ffc <== NOT EXECUTED 2017030: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2017034: 7f ff e0 23 call 200f0c0 <__errno> <== NOT EXECUTED 2017038: 01 00 00 00 nop <== NOT EXECUTED 201703c: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2017040: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017044: 10 bf ff ee b 2016ffc <== NOT EXECUTED 2017048: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 02018c6c : /* * get next entry in a directory. */ struct dirent * readdir(dirp) register DIR *dirp; { 2018c6c: 9d e3 bf 98 save %sp, -104, %sp register struct dirent *dp; if ( !dirp ) 2018c70: 80 a6 20 00 cmp %i0, 0 2018c74: 02 80 00 29 be 2018d18 2018c78: 88 10 20 00 clr %g4 2018c7c: d2 06 20 0c ld [ %i0 + 0xc ], %o1 return NULL; for (;;) { if (dirp->dd_loc == 0) { 2018c80: c4 06 20 04 ld [ %i0 + 4 ], %g2 2018c84: 80 a0 a0 00 cmp %g2, 0 2018c88: 22 80 00 1b be,a 2018cf4 2018c8c: d0 06 00 00 ld [ %i0 ], %o0 dirp->dd_len); if (dirp->dd_size <= 0) return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 2018c90: c2 06 20 08 ld [ %i0 + 8 ], %g1 2018c94: 80 a0 40 02 cmp %g1, %g2 2018c98: 24 bf ff fa ble,a 2018c80 2018c9c: c0 26 20 04 clr [ %i0 + 4 ] dirp->dd_loc = 0; continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 2018ca0: 88 00 80 09 add %g2, %o1, %g4 if ((intptr_t)dp & 03) /* bogus pointer check */ 2018ca4: 80 89 20 03 btst 3, %g4 2018ca8: 32 80 00 1c bne,a 2018d18 2018cac: 88 10 20 00 clr %g4 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 2018cb0: c6 11 20 08 lduh [ %g4 + 8 ], %g3 2018cb4: 80 a0 e0 00 cmp %g3, 0 2018cb8: 02 80 00 17 be 2018d14 2018cbc: 9a 00 80 03 add %g2, %g3, %o5 2018cc0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 2018cc4: 82 00 60 01 inc %g1 2018cc8: 82 20 40 02 sub %g1, %g2, %g1 2018ccc: 80 a0 c0 01 cmp %g3, %g1 2018cd0: 34 80 00 12 bg,a 2018d18 2018cd4: 88 10 20 00 clr %g4 <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 2018cd8: da 26 20 04 st %o5, [ %i0 + 4 ] if (dp->d_ino == 0) 2018cdc: c2 00 80 09 ld [ %g2 + %o1 ], %g1 2018ce0: 80 a0 60 00 cmp %g1, 0 2018ce4: 22 bf ff e8 be,a 2018c84 2018ce8: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED continue; return (dp); } } 2018cec: 81 c7 e0 08 ret 2018cf0: 91 e8 00 04 restore %g0, %g4, %o0 if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { dirp->dd_size = getdents (dirp->dd_fd, 2018cf4: 40 00 29 5d call 2023268 2018cf8: d4 06 20 10 ld [ %i0 + 0x10 ], %o2 dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 2018cfc: 80 a2 20 00 cmp %o0, 0 2018d00: 04 80 00 05 ble 2018d14 2018d04: d0 26 20 08 st %o0, [ %i0 + 8 ] 2018d08: c4 06 20 04 ld [ %i0 + 4 ], %g2 2018d0c: 10 bf ff e1 b 2018c90 2018d10: d2 06 20 0c ld [ %i0 + 0xc ], %o1 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) 2018d14: 88 10 20 00 clr %g4 continue; return (dp); } } 2018d18: 81 c7 e0 08 ret 2018d1c: 91 e8 00 04 restore %g0, %g4, %o0 02005f68 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 2005f68: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t loc; int result; if (!buf) 2005f6c: 80 a6 60 00 cmp %i1, 0 2005f70: 02 80 00 27 be 200600c 2005f74: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, 0, &loc, FALSE ); 2005f78: a0 07 bf e8 add %fp, -24, %l0 2005f7c: 92 10 20 00 clr %o1 2005f80: 94 10 00 10 mov %l0, %o2 2005f84: 96 10 20 00 clr %o3 2005f88: 7f ff f9 89 call 20045ac 2005f8c: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 2005f90: 80 a2 20 00 cmp %o0, 0 2005f94: 12 80 00 1c bne 2006004 2005f98: c4 07 bf f0 ld [ %fp + -16 ], %g2 return -1; if ( !loc.ops->node_type_h ){ 2005f9c: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2005fa0: 80 a0 60 00 cmp %g1, 0 2005fa4: 22 80 00 31 be,a 2006068 2005fa8: c2 00 a0 1c ld [ %g2 + 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_SYM_LINK ){ 2005fac: 9f c0 40 00 call %g1 2005fb0: 90 10 00 10 mov %l0, %o0 2005fb4: 80 a2 20 04 cmp %o0, 4 2005fb8: 12 80 00 1b bne 2006024 2005fbc: c4 07 bf f0 ld [ %fp + -16 ], %g2 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !loc.ops->readlink_h ){ 2005fc0: c2 00 a0 3c ld [ %g2 + 0x3c ], %g1 2005fc4: 80 a0 60 00 cmp %g1, 0 2005fc8: 02 80 00 27 be 2006064 2005fcc: 92 10 00 19 mov %i1, %o1 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 2005fd0: 94 10 00 1a mov %i2, %o2 2005fd4: 9f c0 40 00 call %g1 2005fd8: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2005fdc: c2 07 bf f0 ld [ %fp + -16 ], %g1 2005fe0: 80 a0 60 00 cmp %g1, 0 2005fe4: 02 80 00 08 be 2006004 2005fe8: b0 10 00 08 mov %o0, %i0 2005fec: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2005ff0: 80 a0 60 00 cmp %g1, 0 2005ff4: 02 80 00 26 be 200608c 2005ff8: 01 00 00 00 nop 2005ffc: 9f c0 40 00 call %g1 2006000: 90 10 00 10 mov %l0, %o0 return result; } 2006004: 81 c7 e0 08 ret 2006008: 81 e8 00 00 restore { rtems_filesystem_location_info_t loc; int result; if (!buf) rtems_set_errno_and_return_minus_one( EFAULT ); 200600c: 40 00 36 14 call 201385c <__errno> <== NOT EXECUTED 2006010: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006014: 82 10 20 0e mov 0xe, %g1 <== NOT EXECUTED 2006018: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200601c: 81 c7 e0 08 ret <== NOT EXECUTED 2006020: 81 e8 00 00 restore <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ rtems_filesystem_freenode( &loc ); 2006024: c2 07 bf f0 ld [ %fp + -16 ], %g1 2006028: 80 a0 60 00 cmp %g1, 0 200602c: 02 80 00 08 be 200604c 2006030: 01 00 00 00 nop 2006034: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2006038: 80 a0 60 00 cmp %g1, 0 200603c: 02 80 00 04 be 200604c 2006040: 01 00 00 00 nop 2006044: 9f c0 40 00 call %g1 2006048: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 200604c: 40 00 36 04 call 201385c <__errno> 2006050: b0 10 3f ff mov -1, %i0 2006054: 82 10 20 16 mov 0x16, %g1 2006058: c2 22 00 00 st %g1, [ %o0 ] 200605c: 81 c7 e0 08 ret 2006060: 81 e8 00 00 restore } if ( !loc.ops->readlink_h ){ rtems_filesystem_freenode( &loc ); 2006064: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2006068: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200606c: 02 80 00 04 be 200607c <== NOT EXECUTED 2006070: 01 00 00 00 nop <== NOT EXECUTED 2006074: 9f c0 40 00 call %g1 <== NOT EXECUTED 2006078: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 200607c: 40 00 35 f8 call 201385c <__errno> <== NOT EXECUTED 2006080: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006084: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2006088: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200608c: 81 c7 e0 08 ret <== NOT EXECUTED 2006090: 81 e8 00 00 restore <== NOT EXECUTED 020024e0 : void *realloc( void *ptr, size_t size ) { 20024e0: 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())) { 20024e4: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 20024e8: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> <== NOT EXECUTED 20024ec: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20024f0: 02 80 00 10 be 2002530 <== NOT EXECUTED 20024f4: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 20024f8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 20024fc: 02 80 00 13 be 2002548 <== NOT EXECUTED 2002500: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED return malloc( size ); if ( !size ) { 2002504: 02 80 00 15 be 2002558 <== NOT EXECUTED 2002508: 21 00 80 65 sethi %hi(0x2019400), %l0 <== NOT EXECUTED memcpy(np,ptr,size); free(ptr); return np; } #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, size ) ) { 200250c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002510: 90 14 22 7c or %l0, 0x27c, %o0 <== NOT EXECUTED 2002514: 40 00 19 94 call 2008b64 <_Protected_heap_Resize_block> <== NOT EXECUTED 2002518: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 200251c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002520: 02 80 00 13 be 200256c <== NOT EXECUTED 2002524: 01 00 00 00 nop <== NOT EXECUTED memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 2002528: 81 c7 e0 08 ret <== NOT EXECUTED 200252c: 81 e8 00 00 restore <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) 2002530: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 <== NOT EXECUTED 2002534: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2002538: 02 80 00 25 be 20025cc <== NOT EXECUTED 200253c: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 2002540: 81 c7 e0 08 ret <== NOT EXECUTED 2002544: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 2002548: 7f ff ff 95 call 200239c <== NOT EXECUTED 200254c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2002550: 81 c7 e0 08 ret <== NOT EXECUTED 2002554: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if ( !size ) { free( ptr ); 2002558: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200255c: 7f ff ff 67 call 20022f8 <== NOT EXECUTED 2002560: b0 10 20 00 clr %i0 <== NOT EXECUTED 2002564: 81 c7 e0 08 ret <== NOT EXECUTED 2002568: 81 e8 00 00 restore <== NOT EXECUTED #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, size ) ) { return ptr; } new_area = malloc( size ); 200256c: 7f ff ff 8c call 200239c <== NOT EXECUTED 2002570: 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 ) { 2002574: a2 92 20 00 orcc %o0, 0, %l1 <== NOT EXECUTED 2002578: 02 bf ff f2 be 2002540 <== NOT EXECUTED 200257c: 90 14 22 7c or %l0, 0x27c, %o0 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 2002580: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2002584: 40 00 18 dc call 20088f4 <_Protected_heap_Get_block_size> <== NOT EXECUTED 2002588: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200258c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2002590: 02 80 00 15 be 20025e4 <== NOT EXECUTED 2002594: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED errno = EINVAL; return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 2002598: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 200259c: 08 80 00 03 bleu 20025a8 <== NOT EXECUTED 20025a0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 20025a4: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 20025a8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 20025ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20025b0: 40 00 34 99 call 200f814 <== NOT EXECUTED 20025b4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED free( ptr ); 20025b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20025bc: 7f ff ff 4f call 20022f8 <== NOT EXECUTED 20025c0: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED 20025c4: 81 c7 e0 08 ret <== NOT EXECUTED 20025c8: 81 e8 00 00 restore <== NOT EXECUTED if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 20025cc: c4 00 61 08 ld [ %g1 + 0x108 ], %g2 <== NOT EXECUTED 20025d0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20025d4: 02 bf ff ca be 20024fc <== NOT EXECUTED 20025d8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 20025dc: 81 c7 e0 08 ret <== NOT EXECUTED 20025e0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !new_area ) { return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 20025e4: 40 00 32 b7 call 200f0c0 <__errno> <== NOT EXECUTED 20025e8: b0 10 20 00 clr %i0 <== NOT EXECUTED 20025ec: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20025f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20025f4: 81 c7 e0 08 ret <== NOT EXECUTED 20025f8: 81 e8 00 00 restore <== NOT EXECUTED 02018d20 : #include int rmdir( const char *pathname ) { 2018d20: 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 ); 2018d24: 92 10 20 00 clr %o1 2018d28: 90 10 00 18 mov %i0, %o0 2018d2c: a0 07 bf e8 add %fp, -24, %l0 2018d30: 96 10 20 00 clr %o3 2018d34: 7f ff ac 8f call 2003f70 2018d38: 94 10 00 10 mov %l0, %o2 if ( result != 0 ) 2018d3c: 80 a2 20 00 cmp %o0, 0 2018d40: 02 80 00 04 be 2018d50 2018d44: 90 10 20 02 mov 2, %o0 result = (*loc.handlers->rmnod_h)( &loc ); rtems_filesystem_freenode( &loc ); return result; } 2018d48: 81 c7 e0 08 ret 2018d4c: 91 e8 3f ff restore %g0, -1, %o0 result = rtems_filesystem_evaluate_path( pathname, 0, &loc, FALSE ); if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 2018d50: 7f ff ac 58 call 2003eb0 2018d54: 92 10 00 10 mov %l0, %o1 if (result != 0) { 2018d58: 80 a2 20 00 cmp %o0, 0 2018d5c: 12 80 00 2d bne 2018e10 2018d60: c4 07 bf f0 ld [ %fp + -16 ], %g2 /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 2018d64: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2018d68: 80 a0 60 00 cmp %g1, 0 2018d6c: 22 80 00 35 be,a 2018e40 2018d70: c2 00 a0 1c ld [ %g2 + 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 ){ 2018d74: 9f c0 40 00 call %g1 2018d78: 90 10 00 10 mov %l0, %o0 2018d7c: 80 a2 20 01 cmp %o0, 1 2018d80: 12 80 00 14 bne 2018dd0 2018d84: c2 07 bf ec ld [ %fp + -20 ], %g1 /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 2018d88: c2 00 60 34 ld [ %g1 + 0x34 ], %g1 2018d8c: 80 a0 60 00 cmp %g1, 0 2018d90: 22 80 00 37 be,a 2018e6c 2018d94: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->rmnod_h)( &loc ); 2018d98: 9f c0 40 00 call %g1 2018d9c: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 2018da0: c2 07 bf f0 ld [ %fp + -16 ], %g1 2018da4: 80 a0 60 00 cmp %g1, 0 2018da8: 02 80 00 08 be 2018dc8 2018dac: b0 10 00 08 mov %o0, %i0 2018db0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2018db4: 80 a0 60 00 cmp %g1, 0 2018db8: 02 80 00 2b be 2018e64 2018dbc: 01 00 00 00 nop 2018dc0: 9f c0 40 00 call %g1 2018dc4: 90 10 00 10 mov %l0, %o0 2018dc8: 81 c7 e0 08 ret 2018dcc: 81 e8 00 00 restore rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ rtems_filesystem_freenode( &loc ); 2018dd0: c2 07 bf f0 ld [ %fp + -16 ], %g1 2018dd4: 80 a0 60 00 cmp %g1, 0 2018dd8: 02 80 00 08 be 2018df8 2018ddc: 01 00 00 00 nop 2018de0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2018de4: 80 a0 60 00 cmp %g1, 0 2018de8: 02 80 00 04 be 2018df8 2018dec: 01 00 00 00 nop 2018df0: 9f c0 40 00 call %g1 2018df4: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( ENOTDIR ); 2018df8: 40 00 32 88 call 2025818 <__errno> 2018dfc: b0 10 3f ff mov -1, %i0 2018e00: 82 10 20 14 mov 0x14, %g1 2018e04: c2 22 00 00 st %g1, [ %o0 ] 2018e08: 81 c7 e0 08 ret 2018e0c: 81 e8 00 00 restore if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); if (result != 0) { rtems_filesystem_freenode( &loc ); 2018e10: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2018e14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018e18: 02 bf ff ec be 2018dc8 <== NOT EXECUTED 2018e1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2018e20: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2018e24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018e28: 02 bf ff e8 be 2018dc8 <== NOT EXECUTED 2018e2c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2018e30: 9f c0 40 00 call %g1 <== NOT EXECUTED 2018e34: 01 00 00 00 nop <== NOT EXECUTED 2018e38: 81 c7 e0 08 ret <== NOT EXECUTED 2018e3c: 81 e8 00 00 restore <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ rtems_filesystem_freenode( &loc ); 2018e40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018e44: 02 80 00 04 be 2018e54 <== NOT EXECUTED 2018e48: 01 00 00 00 nop <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 2018e4c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2018e50: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2018e54: 40 00 32 71 call 2025818 <__errno> <== NOT EXECUTED 2018e58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2018e5c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2018e60: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2018e64: 81 c7 e0 08 ret <== NOT EXECUTED 2018e68: 81 e8 00 00 restore <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 2018e6c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018e70: 02 bf ff f9 be 2018e54 <== NOT EXECUTED 2018e74: 01 00 00 00 nop <== NOT EXECUTED 2018e78: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2018e7c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018e80: 12 bf ff f3 bne 2018e4c <== NOT EXECUTED 2018e84: 01 00 00 00 nop <== NOT EXECUTED 2018e88: 30 bf ff f3 b,a 2018e54 <== NOT EXECUTED 020199d4 : sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value); #else static char bad_buffer[32] = ""; #endif return bad_buffer; } 20199d4: 11 00 80 a9 sethi %hi(0x202a400), %o0 <== NOT EXECUTED 20199d8: 81 c3 e0 08 retl <== NOT EXECUTED 20199dc: 90 12 21 28 or %o0, 0x128, %o0 ! 202a528 <== NOT EXECUTED 020150d4 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 20150d4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 20150d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20150dc: 40 00 00 0b call 2015108 <== NOT EXECUTED 20150e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (nap) 20150e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20150e8: 02 80 00 05 be 20150fc <== NOT EXECUTED 20150ec: 01 00 00 00 nop <== NOT EXECUTED return nap->name; return rtems_assoc_name_bad(local_value); } 20150f0: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED 20150f4: 81 c7 e0 08 ret <== NOT EXECUTED 20150f8: 81 e8 00 00 restore <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 20150fc: 40 00 12 36 call 20199d4 <== NOT EXECUTED 2015100: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED 2015104: 01 00 00 00 nop 0200efd4 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 200efd4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 200efd8: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED 200efdc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200efe0: 02 80 00 1e be 200f058 <== NOT EXECUTED 200efe4: 13 00 80 5f sethi %hi(0x2017c00), %o1 <== NOT EXECUTED 200efe8: 40 00 04 c4 call 20102f8 <== NOT EXECUTED 200efec: 92 12 60 f0 or %o1, 0xf0, %o1 ! 2017cf0 <_POSIX_Threads_Default_attributes+0x120> <== NOT EXECUTED 200eff0: 84 10 00 18 mov %i0, %g2 <== NOT EXECUTED 200eff4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200eff8: 12 80 00 0f bne 200f034 <== NOT EXECUTED 200effc: 86 10 20 00 clr %g3 <== NOT EXECUTED default_ap = ap++; for ( ; ap->name; ap++) 200f000: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 200f004: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200f008: 02 80 00 10 be 200f048 <== NOT EXECUTED 200f00c: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED if (ap->local_value == local_value) 200f010: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 200f014: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 200f018: 02 80 00 0b be 200f044 <== NOT EXECUTED 200f01c: 86 10 00 18 mov %i0, %g3 <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200f020: 84 00 a0 0c add %g2, 0xc, %g2 <== NOT EXECUTED 200f024: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 200f028: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200f02c: 02 80 00 09 be 200f050 <== NOT EXECUTED 200f030: 01 00 00 00 nop <== NOT EXECUTED if (ap->local_value == local_value) 200f034: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 200f038: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 200f03c: 32 bf ff fa bne,a 200f024 <== NOT EXECUTED 200f040: 84 00 a0 0c add %g2, 0xc, %g2 <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200f044: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 200f048: 81 c7 e0 08 ret <== NOT EXECUTED 200f04c: 81 e8 00 00 restore <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200f050: 81 c7 e0 08 ret <== NOT EXECUTED 200f054: 91 e8 00 03 restore %g0, %g3, %o0 <== NOT EXECUTED uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 200f058: 81 c7 e0 08 ret <== NOT EXECUTED 200f05c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 0200e550 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 200e550: 9d e3 bf 98 save %sp, -104, %sp const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 200e554: d0 06 00 00 ld [ %i0 ], %o0 200e558: 80 a2 20 00 cmp %o0, 0 200e55c: 02 80 00 1e be 200e5d4 200e560: 13 00 80 5f sethi %hi(0x2017c00), %o1 200e564: 40 00 07 65 call 20102f8 200e568: 92 12 60 f0 or %o1, 0xf0, %o1 ! 2017cf0 <_POSIX_Threads_Default_attributes+0x120> 200e56c: 84 10 00 18 mov %i0, %g2 200e570: 80 a2 20 00 cmp %o0, 0 200e574: 12 80 00 0f bne 200e5b0 200e578: 86 10 20 00 clr %g3 default_ap = ap++; for ( ; ap->name; ap++) 200e57c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 200e580: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200e584: 02 80 00 10 be 200e5c4 <== NOT EXECUTED 200e588: 84 06 20 0c add %i0, 0xc, %g2 <== NOT EXECUTED if (ap->remote_value == remote_value) 200e58c: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED 200e590: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 200e594: 02 80 00 0b be 200e5c0 <== NOT EXECUTED 200e598: 86 10 00 18 mov %i0, %g3 <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200e59c: 84 00 a0 0c add %g2, 0xc, %g2 <== NOT EXECUTED 200e5a0: c2 00 80 00 ld [ %g2 ], %g1 200e5a4: 80 a0 60 00 cmp %g1, 0 200e5a8: 02 80 00 09 be 200e5cc 200e5ac: 01 00 00 00 nop if (ap->remote_value == remote_value) 200e5b0: c2 00 a0 08 ld [ %g2 + 8 ], %g1 200e5b4: 80 a0 40 19 cmp %g1, %i1 200e5b8: 32 bf ff fa bne,a 200e5a0 200e5bc: 84 00 a0 0c add %g2, 0xc, %g2 const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200e5c0: b0 10 00 02 mov %g2, %i0 if (ap->remote_value == remote_value) return ap; return default_ap; } 200e5c4: 81 c7 e0 08 ret 200e5c8: 81 e8 00 00 restore const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 200e5cc: 81 c7 e0 08 ret 200e5d0: 91 e8 00 03 restore %g0, %g3, %o0 uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 200e5d4: 81 c7 e0 08 ret <== NOT EXECUTED 200e5d8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 0200e5dc : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 200e5dc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 200e5e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200e5e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 200e5e8: 40 00 02 7b call 200efd4 <== NOT EXECUTED 200e5ec: b0 10 20 00 clr %i0 <== NOT EXECUTED if (nap) 200e5f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200e5f4: 32 80 00 02 bne,a 200e5fc <== NOT EXECUTED 200e5f8: f0 02 20 08 ld [ %o0 + 8 ], %i0 <== NOT EXECUTED return nap->remote_value; return 0; } 200e5fc: 81 c7 e0 08 ret <== NOT EXECUTED 200e600: 81 e8 00 00 restore <== NOT EXECUTED 020062a8 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 20062a8: 9d e3 bf 90 save %sp, -112, %sp Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 20062ac: a4 96 20 00 orcc %i0, 0, %l2 20062b0: 02 80 00 20 be 2006330 20062b4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 20062b8: 80 a6 e0 00 cmp %i3, 0 20062bc: 02 80 00 1d be 2006330 20062c0: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 20062c4: 80 8e 60 10 btst 0x10, %i1 20062c8: 02 80 00 39 be 20063ac 20062cc: 80 a6 a0 00 cmp %i2, 0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 20062d0: 02 80 00 18 be 2006330 20062d4: 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; 20062d8: c0 27 bf f0 clr [ %fp + -16 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20062dc: 21 00 80 77 sethi %hi(0x201dc00), %l0 20062e0: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 ! 201dfe0 <_Thread_Dispatch_disable_level> if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 20062e4: f4 27 bf f4 st %i2, [ %fp + -12 ] 20062e8: 82 00 60 01 inc %g1 20062ec: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] * 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 ); 20062f0: 23 00 80 77 sethi %hi(0x201dc00), %l1 20062f4: 40 00 0a 6a call 2008c9c <_Objects_Allocate> 20062f8: 90 14 62 40 or %l1, 0x240, %o0 ! 201de40 <_Barrier_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 20062fc: b4 92 20 00 orcc %o0, 0, %i2 2006300: 12 80 00 0e bne 2006338 2006304: 90 06 a0 14 add %i2, 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 ) 2006308: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 200630c: b0 10 20 05 mov 5, %i0 2006310: 82 00 7f ff add %g1, -1, %g1 2006314: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 2006318: c4 04 23 e0 ld [ %l0 + 0x3e0 ], %g2 200631c: 80 a0 a0 00 cmp %g2, 0 2006320: 12 80 00 21 bne 20063a4 2006324: 01 00 00 00 nop _Thread_Dispatch(); 2006328: 40 00 10 e2 call 200a6b0 <_Thread_Dispatch> 200632c: 01 00 00 00 nop 2006330: 81 c7 e0 08 ret 2006334: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 2006338: f2 26 a0 10 st %i1, [ %i2 + 0x10 ] _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 200633c: 40 00 07 8c call 200816c <_CORE_barrier_Initialize> 2006340: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2006344: 90 14 62 40 or %l1, 0x240, %o0 Objects_Name name ) { uint32_t index; index = _Objects_Get_index( the_object->id ); 2006348: c6 06 a0 08 ld [ %i2 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200634c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2006350: 03 00 00 3f sethi %hi(0xfc00), %g1 2006354: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2006358: 82 08 c0 01 and %g3, %g1, %g1 200635c: 80 a0 40 02 cmp %g1, %g2 2006360: 38 80 00 06 bgu,a 2006378 2006364: e4 26 a0 0c st %l2, [ %i2 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2006368: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200636c: 83 28 60 02 sll %g1, 2, %g1 2006370: 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; 2006374: e4 26 a0 0c st %l2, [ %i2 + 0xc ] &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 2006378: c6 26 c0 00 st %g3, [ %i3 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200637c: c2 04 23 e0 ld [ %l0 + 0x3e0 ], %g1 2006380: b0 10 20 00 clr %i0 2006384: 82 00 7f ff add %g1, -1, %g1 2006388: c2 24 23 e0 st %g1, [ %l0 + 0x3e0 ] 200638c: c4 04 23 e0 ld [ %l0 + 0x3e0 ], %g2 2006390: 80 a0 a0 00 cmp %g2, 0 2006394: 12 80 00 04 bne 20063a4 2006398: 01 00 00 00 nop _Thread_Dispatch(); 200639c: 40 00 10 c5 call 200a6b0 <_Thread_Dispatch> 20063a0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 20063a4: 81 c7 e0 08 ret 20063a8: 81 e8 00 00 restore if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 20063ac: 82 10 20 01 mov 1, %g1 20063b0: 10 bf ff cb b 20062dc 20063b4: c2 27 bf f0 st %g1, [ %fp + -16 ] 020063b8 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 20063b8: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 20063bc: 21 00 80 77 sethi %hi(0x201dc00), %l0 20063c0: 92 10 00 18 mov %i0, %o1 20063c4: 94 07 bf f4 add %fp, -12, %o2 20063c8: 40 00 0b 86 call 20091e0 <_Objects_Get> 20063cc: 90 14 22 40 or %l0, 0x240, %o0 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 20063d0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20063d4: 80 a0 60 00 cmp %g1, 0 20063d8: 12 80 00 20 bne 2006458 20063dc: b0 10 00 08 mov %o0, %i0 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Flush( 20063e0: 90 02 20 14 add %o0, 0x14, %o0 20063e4: 92 10 20 00 clr %o1 20063e8: 40 00 13 51 call 200b12c <_Thread_queue_Flush> 20063ec: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20063f0: 90 14 22 40 or %l0, 0x240, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 20063f4: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 20063f8: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 20063fc: 05 00 00 3f sethi %hi(0xfc00), %g2 2006400: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2006404: 82 08 40 02 and %g1, %g2, %g1 2006408: 80 a0 40 03 cmp %g1, %g3 200640c: 38 80 00 06 bgu,a 2006424 2006410: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2006414: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2006418: 83 28 60 02 sll %g1, 2, %g1 200641c: 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; 2006420: c0 26 20 0c clr [ %i0 + 0xc ] */ RTEMS_INLINE_ROUTINE void _Barrier_Free ( Barrier_Control *the_barrier ) { _Objects_Free( &_Barrier_Information, &the_barrier->Object ); 2006424: 40 00 0b 2c call 20090d4 <_Objects_Free> 2006428: 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 ) 200642c: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006430: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 201dfe0 <_Thread_Dispatch_disable_level> 2006434: b0 10 20 00 clr %i0 2006438: 84 00 bf ff add %g2, -1, %g2 200643c: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2006440: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 2006444: 80 a0 e0 00 cmp %g3, 0 2006448: 02 80 00 09 be 200646c 200644c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006450: 81 c7 e0 08 ret 2006454: 81 e8 00 00 restore { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 2006458: 80 a0 60 02 cmp %g1, 2 200645c: 08 bf ff fd bleu 2006450 2006460: b0 10 20 04 mov 4, %i0 2006464: 81 c7 e0 08 ret <== NOT EXECUTED 2006468: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200646c: 40 00 10 91 call 200a6b0 <_Thread_Dispatch> 2006470: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006474: 81 c7 e0 08 ret 2006478: 81 e8 00 00 restore 020064b4 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 20064b4: 9d e3 bf 90 save %sp, -112, %sp 20064b8: a0 10 00 18 mov %i0, %l0 Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 20064bc: 80 a6 60 00 cmp %i1, 0 20064c0: 02 80 00 1f be 200653c 20064c4: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 20064c8: 11 00 80 77 sethi %hi(0x201dc00), %o0 20064cc: 92 10 00 10 mov %l0, %o1 20064d0: 90 12 22 40 or %o0, 0x240, %o0 20064d4: 40 00 0b 43 call 20091e0 <_Objects_Get> 20064d8: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 20064dc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20064e0: 80 a0 60 00 cmp %g1, 0 20064e4: 02 80 00 07 be 2006500 20064e8: 92 10 00 10 mov %l0, %o1 20064ec: 80 a0 60 02 cmp %g1, 2 20064f0: 08 80 00 13 bleu 200653c 20064f4: b0 10 20 04 mov 4, %i0 20064f8: 81 c7 e0 08 ret <== NOT EXECUTED 20064fc: 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 ); 2006500: 94 10 20 00 clr %o2 2006504: 40 00 07 26 call 200819c <_CORE_barrier_Release> 2006508: 90 02 20 14 add %o0, 0x14, %o0 200650c: 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 ) 2006510: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006514: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 201dfe0 <_Thread_Dispatch_disable_level> 2006518: b0 10 20 00 clr %i0 200651c: 84 00 bf ff add %g2, -1, %g2 2006520: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2006524: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 2006528: 80 a0 e0 00 cmp %g3, 0 200652c: 12 80 00 04 bne 200653c 2006530: 01 00 00 00 nop _Thread_Dispatch(); 2006534: 40 00 10 5f call 200a6b0 <_Thread_Dispatch> 2006538: 01 00 00 00 nop return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200653c: 81 c7 e0 08 ret 2006540: 81 e8 00 00 restore 02006544 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 2006544: 9d e3 bf 90 save %sp, -112, %sp 2006548: 11 00 80 77 sethi %hi(0x201dc00), %o0 200654c: 92 10 00 18 mov %i0, %o1 2006550: 90 12 22 40 or %o0, 0x240, %o0 2006554: 40 00 0b 23 call 20091e0 <_Objects_Get> 2006558: 94 07 bf f4 add %fp, -12, %o2 Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 200655c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006560: 80 a0 60 00 cmp %g1, 0 2006564: 12 80 00 14 bne 20065b4 2006568: 96 10 00 19 mov %i1, %o3 case OBJECTS_REMOTE: case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _CORE_barrier_Wait( 200656c: 90 02 20 14 add %o0, 0x14, %o0 2006570: 92 10 00 18 mov %i0, %o1 2006574: 94 10 20 01 mov 1, %o2 2006578: 40 00 07 14 call 20081c8 <_CORE_barrier_Wait> 200657c: 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 ) 2006580: 03 00 80 77 sethi %hi(0x201dc00), %g1 2006584: c4 00 63 e0 ld [ %g1 + 0x3e0 ], %g2 ! 201dfe0 <_Thread_Dispatch_disable_level> 2006588: 84 00 bf ff add %g2, -1, %g2 200658c: c4 20 63 e0 st %g2, [ %g1 + 0x3e0 ] 2006590: c6 00 63 e0 ld [ %g1 + 0x3e0 ], %g3 2006594: 80 a0 e0 00 cmp %g3, 0 2006598: 02 80 00 0d be 20065cc 200659c: 03 00 80 78 sethi %hi(0x201e000), %g1 TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 20065a0: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 201e0c0 <_Thread_Executing> <== NOT EXECUTED 20065a4: 40 00 20 12 call 200e5ec <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 20065a8: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20065ac: 81 c7 e0 08 ret 20065b0: 91 e8 00 08 restore %g0, %o0, %o0 { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 20065b4: 80 a0 60 02 cmp %g1, 2 20065b8: 08 bf ff fd bleu 20065ac 20065bc: 90 10 20 04 mov 4, %o0 20065c0: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20065c4: 81 c7 e0 08 ret <== NOT EXECUTED 20065c8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20065cc: 40 00 10 39 call 200a6b0 <_Thread_Dispatch> 20065d0: 01 00 00 00 nop TRUE, timeout, NULL ); _Thread_Enable_dispatch(); return _Barrier_Translate_core_barrier_return_code( 20065d4: 03 00 80 78 sethi %hi(0x201e000), %g1 20065d8: c4 00 60 c0 ld [ %g1 + 0xc0 ], %g2 ! 201e0c0 <_Thread_Executing> 20065dc: 40 00 20 04 call 200e5ec <_Barrier_Translate_core_barrier_return_code> 20065e0: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 20065e4: 30 bf ff f2 b,a 20065ac 020052bc : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 20052bc: 9d e3 bf 60 save %sp, -160, %sp 20052c0: 82 10 00 18 mov %i0, %g1 if ( !time_buffer ) 20052c4: 80 a6 60 00 cmp %i1, 0 20052c8: 02 80 00 19 be 200532c 20052cc: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; switch ( option ) { 20052d0: 80 a0 60 04 cmp %g1, 4 20052d4: 18 80 00 16 bgu 200532c 20052d8: b0 10 20 19 mov 0x19, %i0 20052dc: 83 28 60 02 sll %g1, 2, %g1 20052e0: 05 00 80 14 sethi %hi(0x2005000), %g2 20052e4: 84 10 a2 a8 or %g2, 0x2a8, %g2 ! 20052a8 20052e8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20052ec: 81 c0 c0 00 jmp %g3 20052f0: 01 00 00 00 nop } case RTEMS_CLOCK_GET_TIME_VALUE: { struct timeval *time = (struct timeval *)time_buffer; if ( !_TOD_Is_set ) 20052f4: 03 00 80 66 sethi %hi(0x2019800), %g1 <== NOT EXECUTED 20052f8: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201987c <_TOD_Is_set> <== NOT EXECUTED 20052fc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2005300: 12 80 00 46 bne 2005418 <== NOT EXECUTED 2005304: 01 00 00 00 nop <== NOT EXECUTED } } return RTEMS_INTERNAL_ERROR; /* should never get here */ } 2005308: 81 c7 e0 08 ret 200530c: 91 e8 20 0b restore %g0, 0xb, %o0 } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; 2005310: 03 00 80 66 sethi %hi(0x2019800), %g1 2005314: d2 00 62 1c ld [ %g1 + 0x21c ], %o1 ! 2019a1c <_TOD_Microseconds_per_tick> 2005318: 11 00 03 d0 sethi %hi(0xf4000), %o0 200531c: b0 10 20 00 clr %i0 2005320: 40 00 43 05 call 2015f34 <.udiv> 2005324: 90 12 22 40 or %o0, 0x240, %o0 2005328: d0 26 40 00 st %o0, [ %i1 ] 200532c: 81 c7 e0 08 ret 2005330: 81 e8 00 00 restore } case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = _Watchdog_Ticks_since_boot; 2005334: 03 00 80 66 sethi %hi(0x2019800), %g1 2005338: c4 00 61 c4 ld [ %g1 + 0x1c4 ], %g2 ! 20199c4 <_Watchdog_Ticks_since_boot> 200533c: c4 26 40 00 st %g2, [ %i1 ] 2005340: 81 c7 e0 08 ret 2005344: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: { rtems_interval *interval = (rtems_interval *)time_buffer; if ( !_TOD_Is_set ) 2005348: 03 00 80 66 sethi %hi(0x2019800), %g1 200534c: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201987c <_TOD_Is_set> 2005350: 80 a0 a0 00 cmp %g2, 0 2005354: 02 bf ff ed be 2005308 2005358: 03 00 80 66 sethi %hi(0x2019800), %g1 return RTEMS_NOT_DEFINED; *interval = _TOD_Seconds_since_epoch; 200535c: c4 00 60 fc ld [ %g1 + 0xfc ], %g2 ! 20198fc <_TOD_Now> 2005360: c4 26 40 00 st %g2, [ %i1 ] 2005364: 81 c7 e0 08 ret 2005368: 91 e8 20 00 restore %g0, 0, %o0 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 ) 200536c: 03 00 80 66 sethi %hi(0x2019800), %g1 2005370: c4 00 60 7c ld [ %g1 + 0x7c ], %g2 ! 201987c <_TOD_Is_set> 2005374: 80 a0 a0 00 cmp %g2, 0 2005378: 02 bf ff e4 be 2005308 200537c: 01 00 00 00 nop ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 2005380: 7f ff f2 9f call 2001dfc 2005384: 01 00 00 00 nop 2005388: a0 10 00 08 mov %o0, %l0 _TOD_Get( &now ); 200538c: 40 00 07 96 call 20071e4 <_TOD_Get> 2005390: 90 07 bf e8 add %fp, -24, %o0 _ISR_Enable(level); 2005394: 7f ff f2 9e call 2001e0c 2005398: 90 10 00 10 mov %l0, %o0 time->tv_sec = now.tv_sec; 200539c: c2 07 bf e8 ld [ %fp + -24 ], %g1 time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 20053a0: d0 07 bf ec ld [ %fp + -20 ], %o0 _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 20053a4: c2 27 bf f0 st %g1, [ %fp + -16 ] time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 20053a8: 40 00 42 e3 call 2015f34 <.udiv> 20053ac: 92 10 23 e8 mov 0x3e8, %o1 /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 20053b0: 92 07 bf c4 add %fp, -60, %o1 20053b4: d0 27 bf f4 st %o0, [ %fp + -12 ] 20053b8: 40 00 29 12 call 200f800 20053bc: 90 07 bf f0 add %fp, -16, %o0 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; 20053c0: c4 07 bf d0 ld [ %fp + -48 ], %g2 tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 20053c4: 03 00 80 66 sethi %hi(0x2019800), %g1 20053c8: d2 00 62 1c ld [ %g1 + 0x21c ], %o1 ! 2019a1c <_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; 20053cc: c4 26 60 08 st %g2, [ %i1 + 8 ] tmbuf->hour = time.tm_hour; 20053d0: c2 07 bf cc ld [ %fp + -52 ], %g1 tmbuf->minute = time.tm_min; 20053d4: c4 07 bf c8 ld [ %fp + -56 ], %g2 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; tmbuf->month = time.tm_mon + 1; tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; 20053d8: c2 26 60 0c st %g1, [ %i1 + 0xc ] tmbuf->minute = time.tm_min; 20053dc: c4 26 60 10 st %g2, [ %i1 + 0x10 ] /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 20053e0: c2 07 bf d8 ld [ %fp + -40 ], %g1 tmbuf->month = time.tm_mon + 1; 20053e4: c4 07 bf d4 ld [ %fp + -44 ], %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 20053e8: c6 07 bf c4 ld [ %fp + -60 ], %g3 tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 20053ec: d0 07 bf f4 ld [ %fp + -12 ], %o0 /* 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; 20053f0: 82 00 67 6c add %g1, 0x76c, %g1 tmbuf->month = time.tm_mon + 1; 20053f4: 84 00 a0 01 inc %g2 tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; 20053f8: c6 26 60 14 st %g3, [ %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; 20053fc: c2 26 40 00 st %g1, [ %i1 ] tmbuf->month = time.tm_mon + 1; 2005400: c4 26 60 04 st %g2, [ %i1 + 4 ] tmbuf->day = time.tm_mday; tmbuf->hour = time.tm_hour; tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 2005404: 40 00 42 cc call 2015f34 <.udiv> 2005408: b0 10 20 00 clr %i0 200540c: d0 26 60 18 st %o0, [ %i1 + 0x18 ] 2005410: 81 c7 e0 08 ret 2005414: 81 e8 00 00 restore ) { ISR_Level level; struct timespec now; _ISR_Disable(level); 2005418: 7f ff f2 79 call 2001dfc <== NOT EXECUTED 200541c: 01 00 00 00 nop <== NOT EXECUTED 2005420: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED _TOD_Get( &now ); 2005424: 40 00 07 70 call 20071e4 <_TOD_Get> <== NOT EXECUTED 2005428: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED _ISR_Enable(level); 200542c: 7f ff f2 78 call 2001e0c <== NOT EXECUTED 2005430: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED time->tv_sec = now.tv_sec; 2005434: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005438: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 200543c: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED _ISR_Disable(level); _TOD_Get( &now ); _ISR_Enable(level); time->tv_sec = now.tv_sec; 2005440: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND; 2005444: 40 00 42 bc call 2015f34 <.udiv> <== NOT EXECUTED 2005448: b0 10 20 00 clr %i0 <== NOT EXECUTED 200544c: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED 2005450: 81 c7 e0 08 ret <== NOT EXECUTED 2005454: 81 e8 00 00 restore <== NOT EXECUTED 02005478 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 2005478: 9d e3 bf 98 save %sp, -104, %sp _TOD_Tickle_ticks(); 200547c: 40 00 07 82 call 2007284 <_TOD_Tickle_ticks> 2005480: 01 00 00 00 nop */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 2005484: 11 00 80 66 sethi %hi(0x2019800), %o0 2005488: 40 00 15 7a call 200aa70 <_Watchdog_Tickle> 200548c: 90 12 21 40 or %o0, 0x140, %o0 ! 2019940 <_Watchdog_Ticks_chain> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 2005490: 40 00 13 9e call 200a308 <_Thread_Tickle_timeslice> 2005494: 01 00 00 00 nop * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_context_switch_necessary( void ) { return ( _Context_Switch_necessary ); 2005498: 03 00 80 66 sethi %hi(0x2019800), %g1 200549c: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 2019930 <_Context_Switch_necessary> if ( _Thread_Is_context_switch_necessary() && 20054a0: 80 a0 a0 00 cmp %g2, 0 20054a4: 02 80 00 06 be 20054bc 20054a8: 03 00 80 66 sethi %hi(0x2019800), %g1 * otherwise. */ RTEMS_INLINE_ROUTINE boolean _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 20054ac: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 20054b0: 80 a0 a0 00 cmp %g2, 0 20054b4: 02 80 00 04 be 20054c4 20054b8: 01 00 00 00 nop _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 20054bc: 81 c7 e0 08 ret 20054c0: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 20054c4: 40 00 0f 76 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 20054c8: b0 10 20 00 clr %i0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 20054cc: 81 c7 e0 08 ret <== NOT EXECUTED 20054d0: 81 e8 00 00 restore <== NOT EXECUTED 02002b90 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 2002b90: 9d e3 bf 68 save %sp, -152, %sp struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 2002b94: 80 a6 60 00 cmp %i1, 0 2002b98: 02 80 00 61 be 2002d1c 2002b9c: 01 00 00 00 nop * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); 2002ba0: 40 00 17 e7 call 2008b3c <_TOD_Get_uptime> 2002ba4: 90 07 bf e0 add %fp, -32, %o0 _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 2002ba8: 92 07 bf e0 add %fp, -32, %o1 2002bac: 94 07 bf d8 add %fp, -40, %o2 2002bb0: 11 00 80 9a sethi %hi(0x2026800), %o0 2002bb4: 40 00 26 5e call 200c52c <_Timespec_Subtract> 2002bb8: 90 12 23 e4 or %o0, 0x3e4, %o0 ! 2026be4 } } } #endif (*print)( context, "CPU Usage by thread\n" 2002bbc: 90 10 00 18 mov %i0, %o0 2002bc0: 13 00 80 6e sethi %hi(0x201b800), %o1 2002bc4: 9f c6 40 00 call %i1 2002bc8: 92 12 61 48 or %o1, 0x148, %o1 ! 201b948 2002bcc: 03 00 80 99 sethi %hi(0x2026400), %g1 if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); (*print)( context, "0x%08" PRIx32 " %4s ", the_thread->Object.id, name ); 2002bd0: 05 00 80 6e sethi %hi(0x201b800), %g2 } } } #endif (*print)( context, "CPU Usage by thread\n" 2002bd4: aa 10 60 b4 or %g1, 0xb4, %l5 the_thread = (Thread_Control *)information->local_table[ i ]; if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002bd8: a8 07 bf eb add %fp, -21, %l4 /* * Print the information */ (*print)( context, 2002bdc: 03 00 80 6e sethi %hi(0x201b800), %g1 if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); (*print)( context, "0x%08" PRIx32 " %4s ", the_thread->Object.id, name ); 2002be0: b4 10 a1 88 or %g2, 0x188, %i2 /* * Print the information */ (*print)( context, 2002be4: b6 10 61 a0 or %g1, 0x1a0, %i3 /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 2002be8: 39 00 80 99 sethi %hi(0x2026400), %i4 _Timespec_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002bec: ba 07 bf f4 add %fp, -12, %i5 2002bf0: ae 07 bf f0 add %fp, -16, %l7 2002bf4: ac 07 bf d0 add %fp, -48, %l6 ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 2002bf8: c2 05 40 00 ld [ %l5 ], %g1 2002bfc: 80 a0 60 00 cmp %g1, 0 2002c00: 22 80 00 39 be,a 2002ce4 2002c04: aa 05 60 04 add %l5, 4, %l5 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 2002c08: e6 00 60 04 ld [ %g1 + 4 ], %l3 if ( information ) { 2002c0c: 80 a4 e0 00 cmp %l3, 0 2002c10: 22 80 00 35 be,a 2002ce4 2002c14: aa 05 60 04 add %l5, 4, %l5 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 2002c18: c2 14 e0 10 lduh [ %l3 + 0x10 ], %g1 2002c1c: 86 90 60 00 orcc %g1, 0, %g3 2002c20: 22 80 00 31 be,a 2002ce4 2002c24: aa 05 60 04 add %l5, 4, %l5 2002c28: a4 10 20 01 mov 1, %l2 the_thread = (Thread_Control *)information->local_table[ i ]; 2002c2c: c4 04 e0 20 ld [ %l3 + 0x20 ], %g2 2002c30: 83 2c a0 02 sll %l2, 2, %g1 2002c34: e0 00 80 01 ld [ %g2 + %g1 ], %l0 if ( !the_thread ) continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002c38: 94 10 00 14 mov %l4, %o2 2002c3c: 92 10 20 05 mov 5, %o1 information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; if ( !the_thread ) 2002c40: 80 a4 20 00 cmp %l0, 0 2002c44: 02 80 00 22 be 2002ccc 2002c48: a4 04 a0 01 inc %l2 continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 2002c4c: d0 04 20 08 ld [ %l0 + 8 ], %o0 2002c50: 40 00 10 bb call 2006f3c 2002c54: a2 10 00 16 mov %l6, %l1 (*print)( context, "0x%08" PRIx32 " %4s ", the_thread->Object.id, name ); 2002c58: d4 04 20 08 ld [ %l0 + 8 ], %o2 2002c5c: 90 10 00 18 mov %i0, %o0 2002c60: 92 10 00 1a mov %i2, %o1 2002c64: 9f c6 40 00 call %i1 2002c68: 96 10 00 14 mov %l4, %o3 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 2002c6c: c4 1c 20 90 ldd [ %l0 + 0x90 ], %g2 if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 2002c70: c8 07 22 30 ld [ %i4 + 0x230 ], %g4 #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; 2002c74: c4 3f bf d0 std %g2, [ %fp + -48 ] if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 2002c78: da 01 20 08 ld [ %g4 + 8 ], %o5 2002c7c: c2 04 20 08 ld [ %l0 + 8 ], %g1 2002c80: 80 a3 40 01 cmp %o5, %g1 2002c84: 02 80 00 28 be 2002d24 2002c88: 92 07 bf e0 add %fp, -32, %o1 _Timespec_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002c8c: 94 10 00 1d mov %i5, %o2 2002c90: 96 10 00 17 mov %l7, %o3 2002c94: 90 10 00 11 mov %l1, %o0 2002c98: 40 00 25 95 call 200c2ec <_Timespec_Divide> 2002c9c: 92 07 bf d8 add %fp, -40, %o1 /* * Print the information */ (*print)( context, 2002ca0: d0 07 bf d4 ld [ %fp + -44 ], %o0 2002ca4: 40 00 5a e8 call 2019844 <.udiv> 2002ca8: 92 10 23 e8 mov 0x3e8, %o1 2002cac: d4 07 bf d0 ld [ %fp + -48 ], %o2 2002cb0: d8 07 bf f4 ld [ %fp + -12 ], %o4 2002cb4: da 07 bf f0 ld [ %fp + -16 ], %o5 2002cb8: 96 10 00 08 mov %o0, %o3 2002cbc: 92 10 00 1b mov %i3, %o1 2002cc0: 9f c6 40 00 call %i1 2002cc4: 90 10 00 18 mov %i0, %o0 2002cc8: c6 14 e0 10 lduh [ %l3 + 0x10 ], %g3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 2002ccc: 83 28 e0 10 sll %g3, 0x10, %g1 2002cd0: 83 30 60 10 srl %g1, 0x10, %g1 2002cd4: 80 a0 40 12 cmp %g1, %l2 2002cd8: 3a bf ff d6 bcc,a 2002c30 2002cdc: c4 04 e0 20 ld [ %l3 + 0x20 ], %g2 2002ce0: aa 05 60 04 add %l5, 4, %l5 " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2002ce4: 03 00 80 99 sethi %hi(0x2026400), %g1 2002ce8: 82 10 60 c4 or %g1, 0xc4, %g1 ! 20264c4 <_Objects_Information_table+0x14> 2002cec: 80 a5 40 01 cmp %l5, %g1 2002cf0: 32 bf ff c3 bne,a 2002bfc 2002cf4: c2 05 40 00 ld [ %l5 ], %g1 } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 2002cf8: d0 07 bf dc ld [ %fp + -36 ], %o0 2002cfc: 40 00 5a d2 call 2019844 <.udiv> 2002d00: 92 10 23 e8 mov 0x3e8, %o1 2002d04: d4 07 bf d8 ld [ %fp + -40 ], %o2 2002d08: 96 10 00 08 mov %o0, %o3 2002d0c: 13 00 80 6e sethi %hi(0x201b800), %o1 2002d10: 90 10 00 18 mov %i0, %o0 2002d14: 9f c6 40 00 call %i1 2002d18: 92 12 61 b8 or %o1, 0x1b8, %o1 2002d1c: 81 c7 e0 08 ret 2002d20: 81 e8 00 00 restore * 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( 2002d24: 94 07 bf c8 add %fp, -56, %o2 2002d28: 11 00 80 99 sethi %hi(0x2026400), %o0 2002d2c: 40 00 26 00 call 200c52c <_Timespec_Subtract> 2002d30: 90 12 22 38 or %o0, 0x238, %o0 ! 2026638 <_Thread_Time_of_last_context_switch> &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 2002d34: 92 07 bf c8 add %fp, -56, %o1 2002d38: 40 00 25 53 call 200c284 <_Timespec_Add_to> 2002d3c: 90 10 00 16 mov %l6, %o0 }; _Timespec_Divide( &ran, &total, &ival, &fval ); 2002d40: 10 bf ff d4 b 2002c90 2002d44: 94 10 00 1d mov %i5, %o2 0200e0c8 : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 200e0c8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code))) 200e0cc: 11 00 80 63 sethi %hi(0x2018c00), %o0 <== NOT EXECUTED 200e0d0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200e0d4: 40 00 01 42 call 200e5dc <== NOT EXECUTED 200e0d8: 90 12 21 7c or %o0, 0x17c, %o0 <== NOT EXECUTED 200e0dc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 200e0e0: 02 80 00 05 be 200e0f4 <== NOT EXECUTED 200e0e4: 01 00 00 00 nop <== NOT EXECUTED { errno = rc; 200e0e8: 40 00 03 f6 call 200f0c0 <__errno> <== NOT EXECUTED 200e0ec: 01 00 00 00 nop <== NOT EXECUTED 200e0f0: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED return -1; } return -1; } 200e0f4: 81 c7 e0 08 ret <== NOT EXECUTED 200e0f8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED 02008c44 : int rtems_error( int error_flag, const char *printf_format, ... ) { 2008c44: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED va_list arglist; int chars_written; va_start(arglist, printf_format); 2008c48: 94 07 a0 4c add %fp, 0x4c, %o2 <== NOT EXECUTED int rtems_error( int error_flag, const char *printf_format, ... ) { 2008c4c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 2008c50: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED 2008c54: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED 2008c58: 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); 2008c5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2008c60: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2008c64: 7f ff ff 7c call 2008a54 <== NOT EXECUTED 2008c68: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED va_end(arglist); return chars_written; } 2008c6c: 81 c7 e0 08 ret <== NOT EXECUTED 2008c70: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 0200570c : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 200570c: 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 ) ) { 2005710: 92 96 20 00 orcc %i0, 0, %o1 2005714: 12 80 00 1c bne 2005784 2005718: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200571c: 23 00 80 66 sethi %hi(0x2019800), %l1 2005720: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 2005724: 82 00 60 01 inc %g1 2005728: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 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; 200572c: 03 00 80 66 sethi %hi(0x2019800), %g1 2005730: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_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; 2005734: c0 27 bf f4 clr [ %fp + -12 ] rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 2005738: 7f ff f1 b1 call 2001dfc 200573c: e0 06 21 70 ld [ %i0 + 0x170 ], %l0 *the_event_set |= the_new_events; 2005740: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2005744: 82 10 40 19 or %g1, %i1, %g1 2005748: c2 24 20 40 st %g1, [ %l0 + 0x40 ] _ISR_Enable( level ); 200574c: 7f ff f1 b0 call 2001e0c 2005750: 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 ); 2005754: 40 00 00 2d call 2005808 <_Event_Surrender> 2005758: 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 ) 200575c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2005760: b0 10 20 00 clr %i0 2005764: 82 00 7f ff add %g1, -1, %g1 2005768: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 200576c: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 2005770: 80 a0 a0 00 cmp %g2, 0 2005774: 02 80 00 0a be 200579c 2005778: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200577c: 81 c7 e0 08 ret 2005780: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2005784: 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 ) { 2005788: 80 a0 a0 04 cmp %g2, 4 200578c: 08 80 00 08 bleu 20057ac 2005790: 83 32 60 1b srl %o1, 0x1b, %g1 2005794: 81 c7 e0 08 ret <== NOT EXECUTED 2005798: 91 e8 20 04 restore %g0, 4, %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 ) _Thread_Dispatch(); 200579c: 40 00 0e c0 call 200929c <_Thread_Dispatch> 20057a0: 01 00 00 00 nop 20057a4: 81 c7 e0 08 ret 20057a8: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20057ac: 80 a0 60 01 cmp %g1, 1 20057b0: 12 bf ff f3 bne 200577c 20057b4: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20057b8: 83 28 a0 02 sll %g2, 2, %g1 20057bc: 05 00 80 65 sethi %hi(0x2019400), %g2 20057c0: 84 10 a3 a0 or %g2, 0x3a0, %g2 ! 20197a0 <_Objects_Information_table> 20057c4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 20057c8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 20057cc: 80 a2 20 00 cmp %o0, 0 20057d0: 02 bf ff f5 be 20057a4 20057d4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 20057d8: 40 00 09 7d call 2007dcc <_Objects_Get> 20057dc: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 20057e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20057e4: b0 10 00 08 mov %o0, %i0 20057e8: 80 a0 60 00 cmp %g1, 0 20057ec: 02 bf ff d3 be 2005738 20057f0: 23 00 80 66 sethi %hi(0x2019800), %l1 20057f4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20057f8: 18 bf ff e1 bgu 200577c <== NOT EXECUTED 20057fc: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2005800: 81 c7 e0 08 ret <== NOT EXECUTED 2005804: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200dafc : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 200dafc: 9d e3 bf 98 save %sp, -104, %sp Extension_Control *the_extension; if ( !rtems_is_name_valid( name ) ) 200db00: a6 96 20 00 orcc %i0, 0, %l3 200db04: 02 80 00 16 be 200db5c 200db08: b0 10 20 03 mov 3, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200db0c: 23 00 80 ad sethi %hi(0x202b400), %l1 200db10: c2 04 62 60 ld [ %l1 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 200db14: 82 00 60 01 inc %g1 200db18: c2 24 62 60 st %g1, [ %l1 + 0x260 ] * the inactive chain of free extension control blocks. */ RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 200db1c: 25 00 80 ae sethi %hi(0x202b800), %l2 200db20: 40 00 03 ef call 200eadc <_Objects_Allocate> 200db24: 90 14 a0 fc or %l2, 0xfc, %o0 ! 202b8fc <_Extension_Information> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 200db28: a0 92 20 00 orcc %o0, 0, %l0 200db2c: 12 80 00 0e bne 200db64 200db30: 90 04 20 10 add %l0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200db34: c2 04 62 60 ld [ %l1 + 0x260 ], %g1 <== NOT EXECUTED 200db38: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 200db3c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200db40: c2 24 62 60 st %g1, [ %l1 + 0x260 ] <== NOT EXECUTED 200db44: c4 04 62 60 ld [ %l1 + 0x260 ], %g2 <== NOT EXECUTED 200db48: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200db4c: 12 80 00 20 bne 200dbcc <== NOT EXECUTED 200db50: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 200db54: 40 00 0a 67 call 20104f0 <_Thread_Dispatch> <== NOT EXECUTED 200db58: 01 00 00 00 nop <== NOT EXECUTED 200db5c: 81 c7 e0 08 ret <== NOT EXECUTED 200db60: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 200db64: 40 00 0f 19 call 20117c8 <_User_extensions_Add_set> 200db68: 92 10 00 19 mov %i1, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200db6c: 90 14 a0 fc or %l2, 0xfc, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200db70: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200db74: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 200db78: 03 00 00 3f sethi %hi(0xfc00), %g1 200db7c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200db80: 82 08 c0 01 and %g3, %g1, %g1 200db84: 80 a0 40 02 cmp %g1, %g2 200db88: 38 80 00 06 bgu,a 200dba0 200db8c: e6 24 20 0c st %l3, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200db90: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200db94: 83 28 60 02 sll %g1, 2, %g1 200db98: e0 20 80 01 st %l0, [ %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; 200db9c: e6 24 20 0c st %l3, [ %l0 + 0xc ] &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 200dba0: c6 26 80 00 st %g3, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200dba4: c2 04 62 60 ld [ %l1 + 0x260 ], %g1 200dba8: b0 10 20 00 clr %i0 200dbac: 82 00 7f ff add %g1, -1, %g1 200dbb0: c2 24 62 60 st %g1, [ %l1 + 0x260 ] 200dbb4: c4 04 62 60 ld [ %l1 + 0x260 ], %g2 200dbb8: 80 a0 a0 00 cmp %g2, 0 200dbbc: 12 80 00 04 bne 200dbcc 200dbc0: 01 00 00 00 nop _Thread_Dispatch(); 200dbc4: 40 00 0a 4b call 20104f0 <_Thread_Dispatch> 200dbc8: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200dbcc: 81 c7 e0 08 ret 200dbd0: 81 e8 00 00 restore 0200dbd4 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 200dbd4: 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 *) 200dbd8: 21 00 80 ae sethi %hi(0x202b800), %l0 <== NOT EXECUTED 200dbdc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200dbe0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200dbe4: 40 00 05 0f call 200f020 <_Objects_Get> <== NOT EXECUTED 200dbe8: 90 14 20 fc or %l0, 0xfc, %o0 <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200dbec: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200dbf0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200dbf4: 12 80 00 1e bne 200dc6c <== NOT EXECUTED 200dbf8: b0 10 00 08 mov %o0, %i0 <== 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 ); 200dbfc: 40 00 0f 2d call 20118b0 <_User_extensions_Remove_set> <== NOT EXECUTED 200dc00: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dc04: 90 14 20 fc or %l0, 0xfc, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200dc08: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200dc0c: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 <== NOT EXECUTED 200dc10: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200dc14: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200dc18: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200dc1c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200dc20: 38 80 00 06 bgu,a 200dc38 <== NOT EXECUTED 200dc24: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200dc28: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 <== NOT EXECUTED 200dc2c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200dc30: 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; 200dc34: 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 ); 200dc38: 40 00 04 b7 call 200ef14 <_Objects_Free> <== NOT EXECUTED 200dc3c: 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 ) 200dc40: 03 00 80 ad sethi %hi(0x202b400), %g1 <== NOT EXECUTED 200dc44: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 202b660 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200dc48: b0 10 20 00 clr %i0 <== NOT EXECUTED 200dc4c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200dc50: c4 20 62 60 st %g2, [ %g1 + 0x260 ] <== NOT EXECUTED 200dc54: c6 00 62 60 ld [ %g1 + 0x260 ], %g3 <== NOT EXECUTED 200dc58: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200dc5c: 02 80 00 09 be 200dc80 <== NOT EXECUTED 200dc60: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200dc64: 81 c7 e0 08 ret <== NOT EXECUTED 200dc68: 81 e8 00 00 restore <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 200dc6c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200dc70: 08 bf ff fd bleu 200dc64 <== NOT EXECUTED 200dc74: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 200dc78: 81 c7 e0 08 ret <== NOT EXECUTED 200dc7c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200dc80: 40 00 0a 1c call 20104f0 <_Thread_Dispatch> <== NOT EXECUTED 200dc84: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200dc88: 81 c7 e0 08 ret <== NOT EXECUTED 200dc8c: 81 e8 00 00 restore <== NOT EXECUTED 02001fd8 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 2001fd8: 9d e3 bf 88 save %sp, -120, %sp rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 2001fdc: 80 a6 60 00 cmp %i1, 0 2001fe0: 02 80 00 28 be 2002080 2001fe4: 92 10 00 18 mov %i0, %o1 rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ if ( !pathloc->ops->evalpath_h ) 2001fe8: c8 06 60 08 ld [ %i1 + 8 ], %g4 2001fec: da 01 00 00 ld [ %g4 ], %o5 2001ff0: 80 a3 60 00 cmp %o5, 0 2001ff4: 02 80 00 1d be 2002068 2001ff8: 11 00 80 5e sethi %hi(0x2017800), %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); parent = *pathloc; 2001ffc: c6 06 60 0c ld [ %i1 + 0xc ], %g3 2002000: c2 06 40 00 ld [ %i1 ], %g1 2002004: c4 06 60 04 ld [ %i1 + 4 ], %g2 2002008: c2 27 bf e8 st %g1, [ %fp + -24 ] 200200c: c4 27 bf ec st %g2, [ %fp + -20 ] 2002010: c8 27 bf f0 st %g4, [ %fp + -16 ] 2002014: c6 27 bf f4 st %g3, [ %fp + -12 ] result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 2002018: b2 07 bf e8 add %fp, -24, %i1 200201c: 90 12 21 18 or %o0, 0x118, %o0 2002020: 9f c3 40 00 call %o5 2002024: 94 10 00 19 mov %i1, %o2 if (result != 0){ 2002028: b0 92 20 00 orcc %o0, 0, %i0 200202c: 12 80 00 0d bne 2002060 2002030: c2 07 bf f0 ld [ %fp + -16 ], %g1 return -1; } rtems_filesystem_freenode( &parent ); 2002034: 80 a0 60 00 cmp %g1, 0 2002038: 02 80 00 16 be 2002090 200203c: 01 00 00 00 nop 2002040: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2002044: 80 a0 60 00 cmp %g1, 0 2002048: 02 80 00 12 be 2002090 200204c: 01 00 00 00 nop 2002050: 9f c0 40 00 call %g1 2002054: 90 10 00 19 mov %i1, %o0 return result; } 2002058: 81 c7 e0 08 ret 200205c: 81 e8 00 00 restore if ( !pathloc->ops->evalpath_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); parent = *pathloc; result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); if (result != 0){ 2002060: 81 c7 e0 08 ret <== NOT EXECUTED 2002064: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ if ( !pathloc->ops->evalpath_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 2002068: 40 00 34 16 call 200f0c0 <__errno> <== NOT EXECUTED 200206c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002070: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2002074: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2002078: 81 c7 e0 08 ret <== NOT EXECUTED 200207c: 81 e8 00 00 restore <== NOT EXECUTED { rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 2002080: 40 00 34 10 call 200f0c0 <__errno> <== NOT EXECUTED 2002084: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002088: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 200208c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2002090: 81 c7 e0 08 ret <== NOT EXECUTED 2002094: 81 e8 00 00 restore <== NOT EXECUTED 02002098 : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 2002098: 9d e3 bf 98 save %sp, -104, %sp /* * Verify Input parameters. */ if ( !pathname ) 200209c: 80 a6 20 00 cmp %i0, 0 20020a0: 02 80 00 50 be 20021e0 20020a4: 80 a6 a0 00 cmp %i2, 0 rtems_set_errno_and_return_minus_one( EFAULT ); if ( !pathloc ) 20020a8: 02 80 00 54 be 20021f8 20020ac: 01 00 00 00 nop /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 20020b0: c2 4e 00 00 ldsb [ %i0 ], %g1 20020b4: 80 a0 60 2f cmp %g1, 0x2f 20020b8: 02 80 00 11 be 20020fc 20020bc: 80 a0 60 5c cmp %g1, 0x5c 20020c0: 02 80 00 0f be 20020fc 20020c4: 80 a0 60 00 cmp %g1, 0 20020c8: 02 80 00 0e be 2002100 20020cc: 03 00 80 62 sethi %hi(0x2018800), %g1 20020d0: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 20020d4: 88 10 20 00 clr %g4 20020d8: c2 00 e0 04 ld [ %g3 + 4 ], %g1 20020dc: c2 26 80 00 st %g1, [ %i2 ] 20020e0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 20020e4: c4 26 a0 04 st %g2, [ %i2 + 4 ] 20020e8: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 20020ec: c2 26 a0 08 st %g1, [ %i2 + 8 ] 20020f0: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 20020f4: 10 80 00 0d b 2002128 20020f8: c4 26 a0 0c st %g2, [ %i2 + 0xc ] 20020fc: 03 00 80 62 sethi %hi(0x2018800), %g1 2002100: c6 00 63 08 ld [ %g1 + 0x308 ], %g3 ! 2018b08 2002104: 88 10 20 01 mov 1, %g4 2002108: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 200210c: c2 26 80 00 st %g1, [ %i2 ] 2002110: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 2002114: c4 26 a0 04 st %g2, [ %i2 + 4 ] 2002118: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 200211c: c2 26 a0 08 st %g1, [ %i2 + 8 ] 2002120: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 2002124: c4 26 a0 0c st %g2, [ %i2 + 0xc ] if ( !pathloc->ops->evalpath_h ) 2002128: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200212c: c2 00 40 00 ld [ %g1 ], %g1 2002130: 80 a0 60 00 cmp %g1, 0 2002134: 02 80 00 25 be 20021c8 2002138: 90 06 00 04 add %i0, %g4, %o0 rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 200213c: 92 10 00 19 mov %i1, %o1 2002140: 9f c0 40 00 call %g1 2002144: 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 ) { 2002148: b0 92 20 00 orcc %o0, 0, %i0 200214c: 12 80 00 0f bne 2002188 2002150: 80 a6 e0 00 cmp %i3, 0 2002154: 02 80 00 2d be 2002208 2002158: 01 00 00 00 nop if ( !pathloc->ops->node_type_h ){ 200215c: c4 06 a0 08 ld [ %i2 + 8 ], %g2 2002160: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 2002164: 80 a0 60 00 cmp %g1, 0 2002168: 22 80 00 13 be,a 20021b4 200216c: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( pathloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 2002170: 9f c0 40 00 call %g1 2002174: 90 10 00 1a mov %i2, %o0 if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 2002178: 90 02 3f fd add %o0, -3, %o0 200217c: 80 a2 20 01 cmp %o0, 1 2002180: 28 80 00 04 bleu,a 2002190 2002184: c4 06 a0 08 ld [ %i2 + 8 ], %g2 } } return result; } 2002188: 81 c7 e0 08 ret 200218c: 81 e8 00 00 restore type = (*pathloc->ops->node_type_h)( pathloc ); if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 2002190: c2 00 a0 34 ld [ %g2 + 0x34 ], %g1 2002194: 80 a0 60 00 cmp %g1, 0 2002198: 02 80 00 06 be 20021b0 200219c: 90 10 00 1a mov %i2, %o0 * 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 ); 20021a0: 9f c0 40 00 call %g1 20021a4: 92 10 00 19 mov %i1, %o1 } } return result; } 20021a8: 81 c7 e0 08 ret 20021ac: 91 e8 00 08 restore %g0, %o0, %o0 if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ rtems_filesystem_freenode( pathloc ); 20021b0: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20021b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20021b8: 02 80 00 04 be 20021c8 <== NOT EXECUTED 20021bc: 01 00 00 00 nop <== NOT EXECUTED 20021c0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20021c4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 20021c8: 40 00 33 be call 200f0c0 <__errno> <== NOT EXECUTED 20021cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20021d0: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 20021d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20021d8: 81 c7 e0 08 ret <== NOT EXECUTED 20021dc: 81 e8 00 00 restore <== NOT EXECUTED /* * Verify Input parameters. */ if ( !pathname ) rtems_set_errno_and_return_minus_one( EFAULT ); 20021e0: 40 00 33 b8 call 200f0c0 <__errno> 20021e4: b0 10 3f ff mov -1, %i0 20021e8: 82 10 20 0e mov 0xe, %g1 20021ec: c2 22 00 00 st %g1, [ %o0 ] 20021f0: 81 c7 e0 08 ret 20021f4: 81 e8 00 00 restore if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 20021f8: 40 00 33 b2 call 200f0c0 <__errno> <== NOT EXECUTED 20021fc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2002200: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED 2002204: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2002208: 81 c7 e0 08 ret 200220c: 81 e8 00 00 restore 0200c024 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 200c024: 9d e3 bf 80 save %sp, -128, %sp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 200c028: 25 00 80 62 sethi %hi(0x2018800), %l2 200c02c: c4 04 a3 08 ld [ %l2 + 0x308 ], %g2 ! 2018b08 200c030: 82 10 20 12 mov 0x12, %g1 init_fs_mount_table(); 200c034: 40 00 01 c0 call 200c734 200c038: c2 30 a0 24 sth %g1, [ %g2 + 0x24 ] /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 200c03c: 03 00 80 61 sethi %hi(0x2018400), %g1 200c040: c4 00 61 08 ld [ %g1 + 0x108 ], %g2 ! 2018508 200c044: 80 a0 a0 00 cmp %g2, 0 200c048: 02 80 00 40 be 200c148 200c04c: 03 00 80 61 sethi %hi(0x2018400), %g1 rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 200c050: c4 00 61 04 ld [ %g1 + 0x104 ], %g2 ! 2018504 status = mount( 200c054: 90 07 bf f4 add %fp, -12, %o0 200c058: d8 00 a0 0c ld [ %g2 + 0xc ], %o4 200c05c: d2 00 80 00 ld [ %g2 ], %o1 200c060: d4 00 a0 04 ld [ %g2 + 4 ], %o2 200c064: 40 00 01 bc call 200c754 200c068: d6 00 a0 08 ld [ %g2 + 8 ], %o3 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 200c06c: 80 a2 3f ff cmp %o0, -1 200c070: 02 80 00 45 be 200c184 200c074: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c078: c8 07 bf f4 ld [ %fp + -12 ], %g4 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 200c07c: c2 04 a3 08 ld [ %l2 + 0x308 ], %g1 * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c080: c4 01 20 18 ld [ %g4 + 0x18 ], %g2 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 200c084: c0 30 60 26 clrh [ %g1 + 0x26 ] * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c088: c4 20 60 14 st %g2, [ %g1 + 0x14 ] 200c08c: c6 01 20 1c ld [ %g4 + 0x1c ], %g3 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c090: a0 07 bf e4 add %fp, -28, %l0 * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c094: c6 20 60 18 st %g3, [ %g1 + 0x18 ] 200c098: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c09c: 23 00 80 5e sethi %hi(0x2017800), %l1 * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c0a0: c4 20 60 1c st %g2, [ %g1 + 0x1c ] 200c0a4: c6 01 20 24 ld [ %g4 + 0x24 ], %g3 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0a8: 92 10 20 00 clr %o1 * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c0ac: c6 20 60 20 st %g3, [ %g1 + 0x20 ] /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0b0: 94 10 00 10 mov %l0, %o2 200c0b4: 96 10 20 00 clr %o3 200c0b8: 7f ff d7 f8 call 2002098 200c0bc: 90 14 63 80 or %l1, 0x380, %o0 rtems_filesystem_root = loc; 200c0c0: c4 04 a3 08 ld [ %l2 + 0x308 ], %g2 200c0c4: c2 07 bf e4 ld [ %fp + -28 ], %g1 /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0c8: 94 10 00 10 mov %l0, %o2 * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 200c0cc: c2 20 a0 14 st %g1, [ %g2 + 0x14 ] 200c0d0: c2 07 bf e8 ld [ %fp + -24 ], %g1 /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0d4: 92 10 20 00 clr %o1 * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 200c0d8: c2 20 a0 18 st %g1, [ %g2 + 0x18 ] 200c0dc: c2 07 bf ec ld [ %fp + -20 ], %g1 /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0e0: 96 10 20 00 clr %o3 * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 200c0e4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] 200c0e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 200c0ec: 90 14 63 80 or %l1, 0x380, %o0 200c0f0: 7f ff d7 ea call 2002098 200c0f4: c2 20 a0 20 st %g1, [ %g2 + 0x20 ] rtems_filesystem_current = loc; 200c0f8: c2 07 bf e4 ld [ %fp + -28 ], %g1 200c0fc: c6 04 a3 08 ld [ %l2 + 0x308 ], %g3 * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 200c100: 11 00 80 5e sethi %hi(0x2017800), %o0 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_current = loc; 200c104: c2 20 e0 04 st %g1, [ %g3 + 4 ] 200c108: c2 07 bf e8 ld [ %fp + -24 ], %g1 * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 200c10c: 90 12 23 88 or %o0, 0x388, %o0 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_current = loc; 200c110: c2 20 e0 08 st %g1, [ %g3 + 8 ] 200c114: c2 07 bf ec ld [ %fp + -20 ], %g1 * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 200c118: 92 10 21 ff mov 0x1ff, %o1 /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_current = loc; 200c11c: c2 20 e0 0c st %g1, [ %g3 + 0xc ] 200c120: c4 07 bf f0 ld [ %fp + -16 ], %g2 * * NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually * created that way by the IMFS. */ status = mkdir( "/dev", 0777); 200c124: 40 00 01 7a call 200c70c 200c128: c4 20 e0 10 st %g2, [ %g3 + 0x10 ] if ( status != 0 ) 200c12c: 80 a2 20 00 cmp %o0, 0 200c130: 02 80 00 04 be 200c140 200c134: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 rtems_fatal_error_occurred( 0xABCD0003 ); 200c138: 7f ff ea 4e call 2006a70 <== NOT EXECUTED 200c13c: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <== NOT EXECUTED 200c140: 81 c7 e0 08 ret 200c144: 81 e8 00 00 restore /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 200c148: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED 200c14c: 7f ff ea 49 call 2006a70 <== NOT EXECUTED 200c150: 90 12 20 01 or %o0, 1, %o0 ! abcd0001 <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 200c154: 03 00 80 61 sethi %hi(0x2018400), %g1 <== NOT EXECUTED 200c158: c4 00 61 04 ld [ %g1 + 0x104 ], %g2 ! 2018504 <== NOT EXECUTED status = mount( 200c15c: 90 07 bf f4 add %fp, -12, %o0 <== NOT EXECUTED 200c160: d8 00 a0 0c ld [ %g2 + 0xc ], %o4 <== NOT EXECUTED 200c164: d2 00 80 00 ld [ %g2 ], %o1 <== NOT EXECUTED 200c168: d4 00 a0 04 ld [ %g2 + 4 ], %o2 <== NOT EXECUTED 200c16c: 40 00 01 7a call 200c754 <== NOT EXECUTED 200c170: d6 00 a0 08 ld [ %g2 + 8 ], %o3 <== NOT EXECUTED &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 200c174: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 200c178: 32 bf ff c1 bne,a 200c07c <== NOT EXECUTED 200c17c: c8 07 bf f4 ld [ %fp + -12 ], %g4 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0002 ); 200c180: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED 200c184: 7f ff ea 3b call 2006a70 <== NOT EXECUTED 200c188: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <== NOT EXECUTED * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 200c18c: 10 bf ff bc b 200c07c <== NOT EXECUTED 200c190: c8 07 bf f4 ld [ %fp + -12 ], %g4 <== NOT EXECUTED 02006a8c : #include const char *rtems_get_version_string(void) { return _RTEMS_version; } 2006a8c: 11 00 80 61 sethi %hi(0x2018400), %o0 <== NOT EXECUTED 2006a90: 81 c3 e0 08 retl <== NOT EXECUTED 2006a94: 90 12 20 88 or %o0, 0x88, %o0 ! 2018488 <_RTEMS_version> <== NOT EXECUTED 02006830 : rtems_interrupt_level rtems_initialize_executive_early( rtems_configuration_table *configuration_table, rtems_cpu_table *cpu_table ) { 2006830: 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 ); 2006834: 7f ff ed 72 call 2001dfc 2006838: 01 00 00 00 nop 200683c: a6 10 00 08 mov %o0, %l3 if ( configuration_table == NULL ) 2006840: 80 a6 20 00 cmp %i0, 0 2006844: 22 80 00 79 be,a 2006a28 2006848: 90 10 20 00 clr %o0 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 200684c: 05 00 80 66 sethi %hi(0x2019800), %g2 RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; _System_state_Is_multiprocessing = is_multiprocessing; 2006850: 03 00 80 66 sethi %hi(0x2019800), %g1 2006854: a4 10 a0 54 or %g2, 0x54, %l2 2006858: 94 10 20 28 mov 0x28, %o2 200685c: 92 10 00 19 mov %i1, %o1 2006860: c0 20 61 4c clr [ %g1 + 0x14c ] RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization ( boolean is_multiprocessing ) { _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION; 2006864: 29 00 80 66 sethi %hi(0x2019800), %l4 2006868: 90 10 00 12 mov %l2, %o0 200686c: 40 00 23 ea call 200f814 2006870: c0 25 22 20 clr [ %l4 + 0x220 ] /* * Provided just for user convenience. */ _Configuration_Table = configuration_table; 2006874: 03 00 80 66 sethi %hi(0x2019800), %g1 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_NO_CPU_TABLE ); _CPU_Initialize( cpu_table, _Thread_Dispatch ); 2006878: 90 10 00 19 mov %i1, %o0 200687c: 13 00 80 24 sethi %hi(0x2009000), %o1 2006880: 92 12 62 9c or %o1, 0x29c, %o1 ! 200929c <_Thread_Dispatch> 2006884: 40 00 12 69 call 200b228 <_CPU_Initialize> 2006888: f0 20 61 04 st %i0, [ %g1 + 0x104 ] /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 200688c: 40 00 1b 36 call 200d564 <_Debug_Manager_initialization> 2006890: a2 10 20 01 mov 1, %l1 _API_extensions_Initialization(); 2006894: 40 00 01 03 call 2006ca0 <_API_extensions_Initialization> 2006898: 01 00 00 00 nop _Thread_Dispatch_initialization(); _Workspace_Handler_initialization( 200689c: d2 06 20 04 ld [ %i0 + 4 ], %o1 20068a0: 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; 20068a4: 03 00 80 66 sethi %hi(0x2019800), %g1 20068a8: e2 20 60 40 st %l1, [ %g1 + 0x40 ] ! 2019840 <_Thread_Dispatch_disable_level> 20068ac: 40 00 10 a8 call 200ab4c <_Workspace_Handler_initialization> 20068b0: 21 00 80 66 sethi %hi(0x2019800), %l0 (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 20068b4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 20068b8: 40 00 0f 19 call 200a51c <_User_extensions_Handler_initialization> 20068bc: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 20068c0: 40 00 03 d5 call 2007814 <_ISR_Handler_initialization> 20068c4: 01 00 00 00 nop _Objects_Handler_initialization( 20068c8: 90 10 20 01 mov 1, %o0 ! 1 20068cc: 92 10 20 01 mov 1, %o1 20068d0: 40 00 05 d8 call 2008030 <_Objects_Handler_initialization> 20068d4: 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; 20068d8: 05 00 80 65 sethi %hi(0x2019400), %g2 /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068dc: 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; 20068e0: 03 00 80 66 sethi %hi(0x2019800), %g1 20068e4: 82 10 60 80 or %g1, 0x80, %g1 ! 2019880 <_Internal_Objects> /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068e8: 92 10 20 01 mov 1, %o1 multiprocessing_table->node, multiprocessing_table->maximum_nodes, multiprocessing_table->maximum_global_objects ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 20068ec: c2 20 a3 a4 st %g1, [ %g2 + 0x3a4 ] /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 20068f0: 94 10 20 02 mov 2, %o2 20068f4: 96 10 20 01 mov 1, %o3 20068f8: 98 10 20 74 mov 0x74, %o4 20068fc: 9a 10 20 00 clr %o5 2006900: 40 00 05 5a call 2007e68 <_Objects_Initialize_information> 2006904: 90 14 21 50 or %l0, 0x150, %o0 _API_Mutex_Allocate( _RTEMS_Allocator_Mutex ); 2006908: 82 10 20 02 mov 2, %g1 200690c: e2 27 bf e8 st %l1, [ %fp + -24 ] 2006910: c2 27 bf f0 st %g1, [ %fp + -16 ] 2006914: c0 27 bf ec clr [ %fp + -20 ] 2006918: c0 27 bf f4 clr [ %fp + -12 ] 200691c: 40 00 03 db call 2007888 <_Objects_Allocate> 2006920: 90 14 21 50 or %l0, 0x150, %o0 2006924: 03 00 80 66 sethi %hi(0x2019800), %g1 2006928: 84 10 00 08 mov %o0, %g2 200692c: 92 07 bf e8 add %fp, -24, %o1 2006930: c4 20 61 18 st %g2, [ %g1 + 0x118 ] 2006934: 90 02 20 10 add %o0, 0x10, %o0 2006938: 40 00 01 47 call 2006e54 <_CORE_mutex_Initialize> 200693c: 94 10 20 01 mov 1, %o2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006940: 03 00 80 66 sethi %hi(0x2019800), %g1 for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 2006944: 05 00 80 66 sethi %hi(0x2019800), %g2 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; 2006948: c0 30 61 14 clrh [ %g1 + 0x114 ] for ( index=0 ; index <16 ; index++ ) _Priority_Bit_map[ index ] = 0; 200694c: c0 30 a1 a0 clrh [ %g2 + 0x1a0 ] 2006950: 82 10 20 02 mov 2, %g1 2006954: 84 10 a1 a0 or %g2, 0x1a0, %g2 2006958: c0 30 40 02 clrh [ %g1 + %g2 ] 200695c: 82 00 60 02 add %g1, 2, %g1 RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void ) { size_t index; _Priority_Major_bit_map = 0; for ( index=0 ; index <16 ; index++ ) 2006960: 80 a0 60 20 cmp %g1, 0x20 2006964: 32 bf ff fe bne,a 200695c 2006968: c0 30 40 02 clrh [ %g1 + %g2 ] _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 200696c: 40 00 0f f8 call 200a94c <_Watchdog_Handler_initialization> 2006970: 01 00 00 00 nop _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 2006974: 40 00 02 35 call 2007248 <_TOD_Handler_initialization> 2006978: d0 06 20 0c ld [ %i0 + 0xc ], %o0 _Thread_Handler_initialization( 200697c: d2 06 20 08 ld [ %i0 + 8 ], %o1 2006980: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 2006984: 40 00 0b 34 call 2009654 <_Thread_Handler_initialization> 2006988: 94 10 20 00 clr %o2 ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 200698c: 40 00 00 a6 call 2006c24 <_RTEMS_API_Initialize> 2006990: 90 10 00 18 mov %i0, %o0 _Extension_Manager_initialization( configuration_table->maximum_extensions ); 2006994: 40 00 00 2a call 2006a3c <_Extension_Manager_initialization> 2006998: d0 06 20 08 ld [ %i0 + 8 ], %o0 _IO_Manager_initialization( 200699c: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 20069a0: d4 06 20 14 ld [ %i0 + 0x14 ], %o2 20069a4: 40 00 00 4e call 2006adc <_IO_Manager_initialization> 20069a8: 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 ); 20069ac: 40 00 00 7a call 2006b94 <_POSIX_API_Initialize> 20069b0: 90 10 00 18 mov %i0, %o0 RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 20069b4: 82 10 20 01 mov 1, %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(); 20069b8: 40 00 09 e5 call 200914c <_Thread_Create_idle> 20069bc: c2 25 22 20 st %g1, [ %l4 + 0x220 ] /* * Scheduling can properly occur now as long as we avoid dispatching. */ if ( cpu_table->pretasking_hook ) 20069c0: d0 06 40 00 ld [ %i1 ], %o0 20069c4: 80 a2 20 00 cmp %o0, 0 20069c8: 02 80 00 04 be 20069d8 20069cc: 01 00 00 00 nop (*cpu_table->pretasking_hook)(); 20069d0: 9f c2 00 00 call %o0 20069d4: 01 00 00 00 nop /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 20069d8: 40 00 00 d4 call 2006d28 <_API_extensions_Run_predriver> 20069dc: 01 00 00 00 nop if ( _CPU_Table.predriver_hook ) 20069e0: c2 04 a0 04 ld [ %l2 + 4 ], %g1 20069e4: 80 a0 60 00 cmp %g1, 0 20069e8: 02 80 00 04 be 20069f8 20069ec: 01 00 00 00 nop (*_CPU_Table.predriver_hook)(); 20069f0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20069f4: 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(); 20069f8: 40 00 00 28 call 2006a98 <_IO_Initialize_all_drivers> 20069fc: 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(); 2006a00: 40 00 00 af call 2006cbc <_API_extensions_Run_postdriver> 2006a04: 01 00 00 00 nop if ( _CPU_Table.postdriver_hook ) 2006a08: c4 04 a0 08 ld [ %l2 + 8 ], %g2 2006a0c: 80 a0 a0 00 cmp %g2, 0 2006a10: 02 80 00 04 be 2006a20 2006a14: 01 00 00 00 nop (*_CPU_Table.postdriver_hook)(); 2006a18: 9f c0 80 00 call %g2 2006a1c: 01 00 00 00 nop return bsp_level; } 2006a20: 81 c7 e0 08 ret 2006a24: 91 e8 00 13 restore %g0, %l3, %o0 */ _ISR_Disable( bsp_level ); if ( configuration_table == NULL ) _Internal_error_Occurred( 2006a28: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2006a2c: 40 00 03 6a call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2006a30: 94 10 20 00 clr %o2 <== NOT EXECUTED /* * Grab our own copy of the user's CPU table. */ _CPU_Table = *cpu_table; 2006a34: 10 bf ff 87 b 2006850 <== NOT EXECUTED 2006a38: 05 00 80 66 sethi %hi(0x2019800), %g2 <== NOT EXECUTED 02001e70 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 2001e70: 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 ); 2001e74: 92 10 20 00 clr %o1 <== NOT EXECUTED 2001e78: a2 07 bf e8 add %fp, -24, %l1 <== NOT EXECUTED 2001e7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2001e80: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 2001e84: 40 00 00 85 call 2002098 <== NOT EXECUTED 2001e88: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED the_jnode = loc.node_access; if ( !loc.ops->node_type_h ) { 2001e8c: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== 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 ); 2001e90: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED the_jnode = loc.node_access; if ( !loc.ops->node_type_h ) { 2001e94: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED 2001e98: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2001e9c: 12 80 00 0e bne 2001ed4 <== NOT EXECUTED 2001ea0: e4 07 bf e8 ld [ %fp + -24 ], %l2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2001ea4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2001ea8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001eac: 02 80 00 04 be 2001ebc <== NOT EXECUTED 2001eb0: 01 00 00 00 nop <== NOT EXECUTED 2001eb4: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001eb8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2001ebc: 40 00 34 81 call 200f0c0 <__errno> <== NOT EXECUTED 2001ec0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2001ec4: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2001ec8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2001ecc: 81 c7 e0 08 ret <== NOT EXECUTED 2001ed0: 81 e8 00 00 restore <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); 2001ed4: 9f c0 80 00 call %g2 <== NOT EXECUTED 2001ed8: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 2001edc: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2001ee0: 12 80 00 18 bne 2001f40 <== NOT EXECUTED 2001ee4: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2001ee8: 80 a2 20 02 cmp %o0, 2 <== NOT EXECUTED 2001eec: 12 80 00 16 bne 2001f44 <== NOT EXECUTED 2001ef0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 2001ef4: f0 26 40 00 st %i0, [ %i1 ] <== NOT EXECUTED device_info->device_name_length = strlen( name ); 2001ef8: 40 00 39 50 call 2010438 <== NOT EXECUTED 2001efc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2001f00: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 2001f04: c2 04 a0 4c ld [ %l2 + 0x4c ], %g1 <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); 2001f08: c6 07 bf f0 ld [ %fp + -16 ], %g3 <== NOT EXECUTED return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; device_info->device_name_length = strlen( name ); device_info->major = the_jnode->info.device.major; 2001f0c: c2 26 60 08 st %g1, [ %i1 + 8 ] <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 2001f10: c4 04 a0 50 ld [ %l2 + 0x50 ], %g2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2001f14: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2001f18: 02 80 00 17 be 2001f74 <== NOT EXECUTED 2001f1c: c4 26 60 0c st %g2, [ %i1 + 0xc ] <== NOT EXECUTED 2001f20: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 2001f24: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001f28: 02 80 00 13 be 2001f74 <== NOT EXECUTED 2001f2c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2001f30: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001f34: b0 10 20 00 clr %i0 <== NOT EXECUTED 2001f38: 81 c7 e0 08 ret <== NOT EXECUTED 2001f3c: 81 e8 00 00 restore <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { rtems_filesystem_freenode( &loc ); 2001f40: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001f44: 02 80 00 0a be 2001f6c <== NOT EXECUTED 2001f48: 01 00 00 00 nop <== NOT EXECUTED 2001f4c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2001f50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2001f54: 02 80 00 06 be 2001f6c <== NOT EXECUTED 2001f58: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2001f5c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2001f60: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED 2001f64: 81 c7 e0 08 ret <== NOT EXECUTED 2001f68: 81 e8 00 00 restore <== NOT EXECUTED device_info->device_name = (char *) name; device_info->device_name_length = strlen( name ); device_info->major = the_jnode->info.device.major; device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); 2001f6c: 81 c7 e0 08 ret <== NOT EXECUTED 2001f70: 91 e8 20 0d restore %g0, 0xd, %o0 <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 2001f74: 81 c7 e0 08 ret <== NOT EXECUTED 2001f78: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02007ba0 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 2007ba0: 9d e3 bf 98 save %sp, -104, %sp /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 2007ba4: 80 a6 60 00 cmp %i1, 0 2007ba8: 02 80 00 3e be 2007ca0 2007bac: 90 10 00 18 mov %i0, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 2007bb0: 80 a6 a0 00 cmp %i2, 0 2007bb4: 02 80 00 3b be 2007ca0 2007bb8: 01 00 00 00 nop return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2007bbc: c2 06 40 00 ld [ %i1 ], %g1 2007bc0: 80 a0 60 00 cmp %g1, 0 2007bc4: 22 80 00 34 be,a 2007c94 2007bc8: c2 06 60 04 ld [ %i1 + 4 ], %g1 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 2007bcc: c0 26 80 00 clr [ %i2 ] /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 2007bd0: 03 00 80 77 sethi %hi(0x201dc00), %g1 2007bd4: c6 00 62 4c ld [ %g1 + 0x24c ], %g3 ! 201de4c <_IO_Number_of_drivers> 2007bd8: 80 a0 c0 08 cmp %g3, %o0 2007bdc: 08 80 00 43 bleu 2007ce8 2007be0: b0 10 20 0a mov 0xa, %i0 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 2007be4: 80 a2 20 00 cmp %o0, 0 2007be8: 12 80 00 1f bne 2007c64 2007bec: 03 00 80 77 sethi %hi(0x201dc00), %g1 boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007bf0: 90 80 ff ff addcc %g3, -1, %o0 2007bf4: 02 80 00 26 be 2007c8c 2007bf8: c8 00 62 50 ld [ %g1 + 0x250 ], %g4 if ( !_IO_Driver_address_table[major].initialization_entry && 2007bfc: 85 28 e0 05 sll %g3, 5, %g2 2007c00: 83 28 e0 03 sll %g3, 3, %g1 2007c04: 84 20 80 01 sub %g2, %g1, %g2 2007c08: 84 00 bf e8 add %g2, -24, %g2 2007c0c: 10 80 00 04 b 2007c1c 2007c10: 84 00 80 04 add %g2, %g4, %g2 * in use. */ if ( major == 0 ) { boolean found = FALSE; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 2007c14: 02 80 00 1e be 2007c8c 2007c18: 84 00 bf e8 add %g2, -24, %g2 if ( !_IO_Driver_address_table[major].initialization_entry && 2007c1c: c2 00 80 00 ld [ %g2 ], %g1 2007c20: 80 a0 60 00 cmp %g1, 0 2007c24: 32 bf ff fc bne,a 2007c14 2007c28: 90 82 3f ff addcc %o0, -1, %o0 2007c2c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2007c30: 80 a0 60 00 cmp %g1, 0 2007c34: 32 bf ff f8 bne,a 2007c14 2007c38: 90 82 3f ff addcc %o0, -1, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 2007c3c: 85 2a 20 03 sll %o0, 3, %g2 2007c40: 83 2a 20 05 sll %o0, 5, %g1 2007c44: 82 20 40 02 sub %g1, %g2, %g1 2007c48: 88 01 00 01 add %g4, %g1, %g4 2007c4c: c2 01 20 04 ld [ %g4 + 4 ], %g1 2007c50: 80 a0 60 00 cmp %g1, 0 2007c54: 22 80 00 15 be,a 2007ca8 2007c58: c2 06 40 00 ld [ %i1 ], %g1 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007c5c: 81 c7 e0 08 ret <== NOT EXECUTED 2007c60: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 2007c64: c8 00 62 50 ld [ %g1 + 0x250 ], %g4 2007c68: 85 2a 20 03 sll %o0, 3, %g2 2007c6c: 83 2a 20 05 sll %o0, 5, %g1 2007c70: 82 20 40 02 sub %g1, %g2, %g1 2007c74: c6 00 40 04 ld [ %g1 + %g4 ], %g3 2007c78: 80 a0 e0 00 cmp %g3, 0 2007c7c: 02 bf ff f4 be 2007c4c 2007c80: 88 00 40 04 add %g1, %g4, %g4 _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007c84: 81 c7 e0 08 ret 2007c88: 91 e8 20 0c restore %g0, 0xc, %o0 2007c8c: 81 c7 e0 08 ret 2007c90: 91 e8 20 05 restore %g0, 5, %o0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 2007c94: 80 a0 60 00 cmp %g1, 0 2007c98: 32 bf ff ce bne,a 2007bd0 2007c9c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; rtems_io_initialize( major, 0, NULL ); return RTEMS_SUCCESSFUL; 2007ca0: 81 c7 e0 08 ret 2007ca4: 91 e8 20 09 restore %g0, 9, %o0 _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; *registered_major = major; 2007ca8: d0 26 80 00 st %o0, [ %i2 ] if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007cac: c2 21 00 00 st %g1, [ %g4 ] 2007cb0: c4 06 60 04 ld [ %i1 + 4 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007cb4: 92 10 20 00 clr %o1 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007cb8: c4 21 20 04 st %g2, [ %g4 + 4 ] 2007cbc: c2 06 60 08 ld [ %i1 + 8 ], %g1 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007cc0: 94 10 20 00 clr %o2 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007cc4: c2 21 20 08 st %g1, [ %g4 + 8 ] 2007cc8: c4 06 60 0c ld [ %i1 + 0xc ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007ccc: b0 10 20 00 clr %i0 if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 2007cd0: c4 21 20 0c st %g2, [ %g4 + 0xc ] 2007cd4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 2007cd8: c2 21 20 10 st %g1, [ %g4 + 0x10 ] 2007cdc: c4 06 60 14 ld [ %i1 + 0x14 ], %g2 *registered_major = major; rtems_io_initialize( major, 0, NULL ); 2007ce0: 7f ff ff 30 call 20079a0 2007ce4: c4 21 20 14 st %g2, [ %g4 + 0x14 ] 2007ce8: 81 c7 e0 08 ret 2007cec: 81 e8 00 00 restore 02009288 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 2009288: 9d e3 bf 98 save %sp, -104, %sp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 200928c: 80 a6 20 00 cmp %i0, 0 2009290: 02 80 00 23 be 200931c 2009294: 03 00 80 99 sethi %hi(0x2026400), %g1 return; 2009298: a4 10 60 b4 or %g1, 0xb4, %l2 ! 20264b4 <_Objects_Information_table+0x4> 200929c: a6 04 a0 10 add %l2, 0x10, %l3 for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 20092a0: c2 04 80 00 ld [ %l2 ], %g1 20092a4: 80 a0 60 00 cmp %g1, 0 20092a8: 22 80 00 1a be,a 2009310 20092ac: a4 04 a0 04 add %l2, 4, %l2 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 20092b0: e2 00 60 04 ld [ %g1 + 4 ], %l1 if ( information ) { 20092b4: 80 a4 60 00 cmp %l1, 0 20092b8: 22 80 00 16 be,a 2009310 20092bc: a4 04 a0 04 add %l2, 4, %l2 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 20092c0: c2 14 60 10 lduh [ %l1 + 0x10 ], %g1 20092c4: 86 90 60 00 orcc %g1, 0, %g3 20092c8: 22 80 00 12 be,a 2009310 20092cc: a4 04 a0 04 add %l2, 4, %l2 20092d0: a0 10 20 01 mov 1, %l0 the_thread = (Thread_Control *)information->local_table[ i ]; 20092d4: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 20092d8: 83 2c 20 02 sll %l0, 2, %g1 20092dc: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( !the_thread ) 20092e0: 80 a2 20 00 cmp %o0, 0 20092e4: 02 80 00 05 be 20092f8 20092e8: a0 04 20 01 inc %l0 continue; (*routine)(the_thread); 20092ec: 9f c6 00 00 call %i0 20092f0: 01 00 00 00 nop 20092f4: c6 14 60 10 lduh [ %l1 + 0x10 ], %g3 api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 20092f8: 83 28 e0 10 sll %g3, 0x10, %g1 20092fc: 83 30 60 10 srl %g1, 0x10, %g1 2009300: 80 a0 40 10 cmp %g1, %l0 2009304: 3a bf ff f5 bcc,a 20092d8 2009308: c4 04 60 20 ld [ %l1 + 0x20 ], %g2 200930c: a4 04 a0 04 add %l2, 4, %l2 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 2009310: 80 a4 80 13 cmp %l2, %l3 2009314: 32 bf ff e4 bne,a 20092a4 2009318: c2 04 80 00 ld [ %l2 ], %g1 200931c: 81 c7 e0 08 ret 2009320: 81 e8 00 00 restore 0200c5e0 : * 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 ) { 200c5e0: 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 ); 200c5e4: 23 00 80 65 sethi %hi(0x2019400), %l1 200c5e8: d0 04 62 78 ld [ %l1 + 0x278 ], %o0 ! 2019678 200c5ec: 92 10 20 00 clr %o1 200c5f0: 7f ff e6 04 call 2005e00 200c5f4: 94 10 20 00 clr %o2 if (rtems_libio_iop_freelist) { 200c5f8: 21 00 80 65 sethi %hi(0x2019400), %l0 200c5fc: c4 04 22 74 ld [ %l0 + 0x274 ], %g2 ! 2019674 200c600: 80 a0 a0 00 cmp %g2, 0 200c604: 12 80 00 07 bne 200c620 200c608: 03 00 80 65 sethi %hi(0x2019400), %g1 } failed: iop = 0; done: 200c60c: b0 10 20 00 clr %i0 rtems_semaphore_release( rtems_libio_semaphore ); 200c610: 7f ff e6 cb call 200613c 200c614: d0 04 62 78 ld [ %l1 + 0x278 ], %o0 return iop; } 200c618: 81 c7 e0 08 ret 200c61c: 81 e8 00 00 restore rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); if (rtems_libio_iop_freelist) { rc = rtems_semaphore_create( 200c620: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 200c624: 92 10 20 01 mov 1, %o1 200c628: 86 20 80 03 sub %g2, %g3, %g3 200c62c: 87 38 e0 02 sra %g3, 2, %g3 200c630: 83 28 e0 02 sll %g3, 2, %g1 200c634: 85 28 e0 06 sll %g3, 6, %g2 200c638: 84 20 80 01 sub %g2, %g1, %g2 200c63c: 83 28 a0 06 sll %g2, 6, %g1 200c640: 82 20 40 02 sub %g1, %g2, %g1 200c644: 85 28 60 0c sll %g1, 0xc, %g2 200c648: 82 00 40 02 add %g1, %g2, %g1 200c64c: 82 00 40 03 add %g1, %g3, %g1 200c650: 83 28 60 04 sll %g1, 4, %g1 200c654: 82 20 40 03 sub %g1, %g3, %g1 200c658: 83 28 60 02 sll %g1, 2, %g1 200c65c: 86 20 c0 01 sub %g3, %g1, %g3 200c660: 94 10 20 54 mov 0x54, %o2 200c664: 96 10 20 00 clr %o3 200c668: 11 13 10 92 sethi %hi(0x4c424800), %o0 200c66c: 98 07 bf f4 add %fp, -12, %o4 200c670: 90 12 21 00 or %o0, 0x100, %o0 200c674: 7f ff e5 0c call 2005aa4 200c678: 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) 200c67c: 80 a2 20 00 cmp %o0, 0 200c680: 32 bf ff e4 bne,a 200c610 200c684: b0 10 20 00 clr %i0 <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 200c688: f0 04 22 74 ld [ %l0 + 0x274 ], %i0 next = iop->data1; (void) memset( iop, 0, sizeof(rtems_libio_t) ); iop->flags = LIBIO_FLAGS_OPEN; iop->sem = sema; 200c68c: c4 07 bf f4 ld [ %fp + -12 ], %g2 &sema ); if (rc != RTEMS_SUCCESSFUL) goto failed; iop = rtems_libio_iop_freelist; next = iop->data1; 200c690: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 (void) memset( iop, 0, sizeof(rtems_libio_t) ); 200c694: c0 26 20 20 clr [ %i0 + 0x20 ] 200c698: c0 26 00 00 clr [ %i0 ] 200c69c: c0 26 20 04 clr [ %i0 + 4 ] 200c6a0: c0 26 20 08 clr [ %i0 + 8 ] 200c6a4: c0 26 20 10 clr [ %i0 + 0x10 ] 200c6a8: c0 26 20 14 clr [ %i0 + 0x14 ] 200c6ac: c0 26 20 18 clr [ %i0 + 0x18 ] 200c6b0: c0 26 20 1c clr [ %i0 + 0x1c ] 200c6b4: c0 26 20 24 clr [ %i0 + 0x24 ] 200c6b8: c0 26 20 28 clr [ %i0 + 0x28 ] 200c6bc: c0 26 20 2c clr [ %i0 + 0x2c ] 200c6c0: c0 26 20 30 clr [ %i0 + 0x30 ] iop->flags = LIBIO_FLAGS_OPEN; iop->sem = sema; rtems_libio_iop_freelist = next; 200c6c4: c2 24 22 74 st %g1, [ %l0 + 0x274 ] 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; 200c6c8: c4 26 20 20 st %g2, [ %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; 200c6cc: 82 10 21 00 mov 0x100, %g1 200c6d0: 10 bf ff d0 b 200c610 200c6d4: c2 26 20 0c st %g1, [ %i0 + 0xc ] 02002210 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 2002210: 9d e3 bf 98 save %sp, -104, %sp rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 2002214: 21 00 80 61 sethi %hi(0x2018400), %l0 2002218: d0 04 20 ec ld [ %l0 + 0xec ], %o0 ! 20184ec 200221c: 80 a2 20 00 cmp %o0, 0 2002220: 12 80 00 13 bne 200226c 2002224: 92 10 20 34 mov 0x34, %o1 /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 2002228: 11 13 10 92 sethi %hi(0x4c424800), %o0 200222c: 92 10 20 01 mov 1, %o1 2002230: 90 12 21 4f or %o0, 0x14f, %o0 2002234: 94 10 20 54 mov 0x54, %o2 2002238: 96 10 20 00 clr %o3 200223c: 19 00 80 65 sethi %hi(0x2019400), %o4 2002240: 40 00 0e 19 call 2005aa4 2002244: 98 13 22 78 or %o4, 0x278, %o4 ! 2019678 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 2002248: 80 a2 20 00 cmp %o0, 0 200224c: 12 80 00 04 bne 200225c 2002250: 01 00 00 00 nop /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 2002254: 40 00 27 74 call 200c024 2002258: 81 e8 00 00 restore RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) rtems_fatal_error_occurred( rc ); 200225c: 40 00 12 05 call 2006a70 <== NOT EXECUTED 2002260: 01 00 00 00 nop <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 2002264: 40 00 27 70 call 200c024 <== NOT EXECUTED 2002268: 81 e8 00 00 restore <== NOT EXECUTED int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 200226c: 40 00 00 ea call 2002614 2002270: 23 00 80 65 sethi %hi(0x2019400), %l1 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 2002274: 80 a2 20 00 cmp %o0, 0 2002278: 02 80 00 18 be 20022d8 200227c: d0 24 62 70 st %o0, [ %l1 + 0x270 ] rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 2002280: c8 04 62 70 ld [ %l1 + 0x270 ], %g4 for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 2002284: c6 04 20 ec ld [ %l0 + 0xec ], %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; 2002288: 03 00 80 65 sethi %hi(0x2019400), %g1 for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 200228c: 80 a0 e0 01 cmp %g3, 1 2002290: 02 80 00 10 be 20022d0 2002294: c8 20 62 74 st %g4, [ %g1 + 0x274 ] 2002298: 82 10 00 04 mov %g4, %g1 200229c: 84 10 20 01 mov 1, %g2 iop->data1 = iop + 1; 20022a0: 82 00 60 34 add %g1, 0x34, %g1 20022a4: 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++) 20022a8: 80 a0 80 03 cmp %g2, %g3 20022ac: 12 bf ff fd bne 20022a0 20022b0: c2 20 7f f4 st %g1, [ %g1 + -12 ] 20022b4: 85 28 e0 02 sll %g3, 2, %g2 20022b8: 83 28 e0 04 sll %g3, 4, %g1 20022bc: 82 20 40 02 sub %g1, %g2, %g1 20022c0: 82 00 40 03 add %g1, %g3, %g1 20022c4: 83 28 60 02 sll %g1, 2, %g1 20022c8: 82 01 00 01 add %g4, %g1, %g1 20022cc: 88 00 7f cc add %g1, -52, %g4 iop->data1 = iop + 1; iop->data1 = NULL; 20022d0: 10 bf ff d6 b 2002228 20022d4: c0 21 20 28 clr [ %g4 + 0x28 ] if (rtems_libio_number_iops > 0) { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 20022d8: 40 00 11 e6 call 2006a70 <== NOT EXECUTED 20022dc: 90 10 20 1a mov 0x1a, %o0 <== NOT EXECUTED iop = rtems_libio_iop_freelist = rtems_libio_iops; 20022e0: 10 bf ff e9 b 2002284 <== NOT EXECUTED 20022e4: c8 04 62 70 ld [ %l1 + 0x270 ], %g4 <== NOT EXECUTED 02018b24 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 2018b24: 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); 2018b28: 90 10 20 00 clr %o0 2018b2c: 92 10 20 00 clr %o1 2018b30: 40 00 03 d4 call 2019a80 2018b34: 94 07 bf f4 add %fp, -12, %o2 if (sc != RTEMS_SUCCESSFUL) return sc; 2018b38: b0 92 20 00 orcc %o0, 0, %i0 2018b3c: 12 80 00 44 bne 2018c4c 2018b40: 25 00 80 ec sethi %hi(0x203b000), %l2 /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 2018b44: c4 04 a2 00 ld [ %l2 + 0x200 ], %g2 ! 203b200 2018b48: 03 00 80 f7 sethi %hi(0x203dc00), %g1 2018b4c: a6 10 60 84 or %g1, 0x84, %l3 ! 203dc84 2018b50: 80 a0 80 13 cmp %g2, %l3 2018b54: 12 80 00 0f bne 2018b90 2018b58: a2 14 a2 00 or %l2, 0x200, %l1 rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 2018b5c: 7f ff ae ac call 200460c 2018b60: 90 10 20 40 mov 0x40, %o0 if (!tmp) 2018b64: a0 92 20 00 orcc %o0, 0, %l0 2018b68: 02 80 00 3b be 2018c54 2018b6c: 92 10 00 11 mov %l1, %o1 #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); 2018b70: 90 10 20 00 clr %o0 2018b74: 15 00 80 62 sethi %hi(0x2018800), %o2 2018b78: 40 00 04 e7 call 2019f14 2018b7c: 94 12 a1 f8 or %o2, 0x1f8, %o2 ! 20189f8 if (sc != RTEMS_SUCCESSFUL) { 2018b80: a2 92 20 00 orcc %o0, 0, %l1 2018b84: 32 80 00 36 bne,a 2018c5c 2018b88: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED * not initialized yet */ free(tmp); return sc; } rtems_current_user_env = tmp; 2018b8c: e0 24 a2 00 st %l0, [ %l2 + 0x200 ] }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 2018b90: d0 04 a2 00 ld [ %l2 + 0x200 ], %o0 2018b94: 92 10 00 13 mov %l3, %o1 2018b98: 40 00 39 d4 call 20272e8 2018b9c: 94 10 20 40 mov 0x40, %o2 rtems_current_user_env->task_id=task_id; /* mark the local values*/ /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018ba0: 03 00 80 f5 sethi %hi(0x203d400), %g1 2018ba4: c8 00 60 94 ld [ %g1 + 0x94 ], %g4 ! 203d494 } 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*/ 2018ba8: c4 04 a2 00 ld [ %l2 + 0x200 ], %g2 /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bac: c2 01 20 18 ld [ %g4 + 0x18 ], %g1 * 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); 2018bb0: a2 07 bf e4 add %fp, -28, %l1 *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bb4: c2 20 a0 14 st %g1, [ %g2 + 0x14 ] } 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*/ 2018bb8: c2 07 bf f4 ld [ %fp + -12 ], %g1 /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bbc: c6 01 20 1c ld [ %g4 + 0x1c ], %g3 } 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*/ 2018bc0: c2 20 80 00 st %g1, [ %g2 ] /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bc4: c6 20 a0 18 st %g3, [ %g2 + 0x18 ] 2018bc8: c2 01 20 20 ld [ %g4 + 0x20 ], %g1 * 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); 2018bcc: 21 00 80 dd sethi %hi(0x2037400), %l0 *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bd0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] 2018bd4: c6 01 20 24 ld [ %g4 + 0x24 ], %g3 * 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); 2018bd8: 92 10 20 00 clr %o1 *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ rtems_current_user_env->task_id=task_id; /* mark the local values*/ /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 2018bdc: c6 20 a0 20 st %g3, [ %g2 + 0x20 ] * 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); 2018be0: 94 10 00 11 mov %l1, %o2 2018be4: 96 10 20 00 clr %o3 2018be8: 7f ff ac e2 call 2003f70 2018bec: 90 14 20 98 or %l0, 0x98, %o0 rtems_filesystem_root = loc; 2018bf0: c4 04 a2 00 ld [ %l2 + 0x200 ], %g2 2018bf4: c2 07 bf e4 ld [ %fp + -28 ], %g1 rtems_filesystem_evaluate_path("/", 0, &loc, 0); 2018bf8: 90 14 20 98 or %l0, 0x98, %o0 * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 2018bfc: c2 20 a0 14 st %g1, [ %g2 + 0x14 ] 2018c00: c2 07 bf e8 ld [ %fp + -24 ], %g1 rtems_filesystem_evaluate_path("/", 0, &loc, 0); 2018c04: 94 10 00 11 mov %l1, %o2 * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 2018c08: c2 20 a0 18 st %g1, [ %g2 + 0x18 ] 2018c0c: c2 07 bf ec ld [ %fp + -20 ], %g1 rtems_filesystem_evaluate_path("/", 0, &loc, 0); 2018c10: 92 10 20 00 clr %o1 * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); rtems_filesystem_root = loc; 2018c14: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] 2018c18: c2 07 bf f0 ld [ %fp + -16 ], %g1 rtems_filesystem_evaluate_path("/", 0, &loc, 0); 2018c1c: 96 10 20 00 clr %o3 2018c20: 7f ff ac d4 call 2003f70 2018c24: c2 20 a0 20 st %g1, [ %g2 + 0x20 ] rtems_filesystem_current = loc; 2018c28: c2 07 bf e4 ld [ %fp + -28 ], %g1 2018c2c: c6 04 a2 00 ld [ %l2 + 0x200 ], %g3 2018c30: c2 20 e0 04 st %g1, [ %g3 + 4 ] 2018c34: c4 07 bf e8 ld [ %fp + -24 ], %g2 2018c38: c4 20 e0 08 st %g2, [ %g3 + 8 ] 2018c3c: c2 07 bf ec ld [ %fp + -20 ], %g1 2018c40: c2 20 e0 0c st %g1, [ %g3 + 0xc ] 2018c44: c4 07 bf f0 ld [ %fp + -16 ], %g2 2018c48: c4 20 e0 10 st %g2, [ %g3 + 0x10 ] return RTEMS_SUCCESSFUL; } 2018c4c: 81 c7 e0 08 ret 2018c50: 81 e8 00 00 restore if (sc != RTEMS_SUCCESSFUL) return sc; /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); if (!tmp) 2018c54: 81 c7 e0 08 ret <== NOT EXECUTED 2018c58: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env); if (sc != RTEMS_SUCCESSFUL) { /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 2018c5c: 7f ff ae 43 call 2004568 <== NOT EXECUTED 2018c60: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED 2018c64: 81 c7 e0 08 ret <== NOT EXECUTED 2018c68: 81 e8 00 00 restore <== NOT EXECUTED 02018a70 : * 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) { 2018a70: 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); 2018a74: 90 10 20 00 clr %o0 <== NOT EXECUTED 2018a78: 92 10 20 00 clr %o1 <== NOT EXECUTED 2018a7c: 40 00 04 01 call 2019a80 <== NOT EXECUTED 2018a80: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 2018a84: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED 2018a88: 12 80 00 13 bne 2018ad4 <== NOT EXECUTED 2018a8c: 25 00 80 ec sethi %hi(0x203b000), %l2 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 2018a90: e2 04 a2 00 ld [ %l2 + 0x200 ], %l1 ! 203b200 <== NOT EXECUTED 2018a94: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2018a98: c4 04 40 00 ld [ %l1 ], %g2 <== NOT EXECUTED 2018a9c: 86 14 a2 00 or %l2, 0x200, %g3 <== NOT EXECUTED 2018aa0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2018aa4: 02 80 00 0e be 2018adc <== NOT EXECUTED 2018aa8: a0 10 00 03 mov %g3, %l0 <== NOT EXECUTED free_user_env(tmp); }; /* AT THIS POINT, rtems_current_user_env is DANGLING */ sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, 2018aac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018ab0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 2018ab4: 40 00 05 eb call 201a260 <== NOT EXECUTED 2018ab8: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 2018abc: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED 2018ac0: 02 80 00 10 be 2018b00 <== NOT EXECUTED 2018ac4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 2018ac8: 03 00 80 f7 sethi %hi(0x203dc00), %g1 <== NOT EXECUTED 2018acc: 82 10 60 84 or %g1, 0x84, %g1 ! 203dc84 <== NOT EXECUTED 2018ad0: c2 24 a2 00 st %g1, [ %l2 + 0x200 ] <== NOT EXECUTED return sc; } 2018ad4: 81 c7 e0 08 ret <== NOT EXECUTED 2018ad8: 91 e8 00 02 restore %g0, %g2, %o0 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; if (rtems_current_user_env->task_id==current_task_id) { /* 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); 2018adc: 40 00 05 6d call 201a090 <== NOT EXECUTED 2018ae0: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 2018ae4: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED 2018ae8: 12 bf ff fb bne 2018ad4 <== NOT EXECUTED 2018aec: 01 00 00 00 nop <== NOT EXECUTED free_user_env(tmp); 2018af0: 7f ff ff c2 call 20189f8 <== NOT EXECUTED 2018af4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED }; /* AT THIS POINT, rtems_current_user_env is DANGLING */ sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, 2018af8: 10 bf ff ee b 2018ab0 <== NOT EXECUTED 2018afc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 2018b00: 15 00 80 62 sethi %hi(0x2018800), %o2 <== NOT EXECUTED 2018b04: 40 00 05 04 call 2019f14 <== NOT EXECUTED 2018b08: 94 12 a1 f8 or %o2, 0x1f8, %o2 ! 20189f8 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 2018b0c: 84 92 20 00 orcc %o0, 0, %g2 <== NOT EXECUTED 2018b10: 12 bf ff ef bne 2018acc <== NOT EXECUTED 2018b14: 03 00 80 f7 sethi %hi(0x203dc00), %g1 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 2018b18: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2018b1c: 10 bf ff ee b 2018ad4 <== NOT EXECUTED 2018b20: c2 24 a2 00 st %g1, [ %l2 + 0x200 ] <== NOT EXECUTED 0200c420 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 200c420: 84 10 00 08 mov %o0, %g2 uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 200c424: 82 08 a0 06 and %g2, 6, %g1 200c428: 80 a0 60 06 cmp %g1, 6 200c42c: 02 80 00 05 be 200c440 200c430: 90 10 20 02 mov 2, %o0 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 200c434: 80 88 a0 02 btst 2, %g2 200c438: 02 80 00 0e be 200c470 200c43c: 90 10 20 00 clr %o0 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 ) { 200c440: 80 88 a0 01 btst 1, %g2 200c444: 02 80 00 04 be 200c454 200c448: 80 88 a2 00 btst 0x200, %g2 fcntl_flags |= O_NONBLOCK; 200c44c: 03 00 00 10 sethi %hi(0x4000), %g1 200c450: 90 12 00 01 or %o0, %g1, %o0 } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 200c454: 32 80 00 02 bne,a 200c45c 200c458: 90 12 20 08 or %o0, 8, %o0 fcntl_flags |= O_APPEND; } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 200c45c: 80 88 a4 00 btst 0x400, %g2 200c460: 32 80 00 02 bne,a 200c468 200c464: 90 12 22 00 or %o0, 0x200, %o0 fcntl_flags |= O_CREAT; } return fcntl_flags; } 200c468: 81 c3 e0 08 retl 200c46c: 01 00 00 00 nop { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 200c470: 83 30 a0 02 srl %g2, 2, %g1 <== NOT EXECUTED 200c474: 10 bf ff f3 b 200c440 <== NOT EXECUTED 200c478: 90 08 60 01 and %g1, 1, %o0 <== NOT EXECUTED 0200efe8 : Objects_Id id, void *buffer, size_t size, uint32_t *count ) { 200efe8: 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 ) 200efec: 80 a6 60 00 cmp %i1, 0 200eff0: 02 80 00 28 be 200f090 200eff4: 80 a6 e0 00 cmp %i3, 0 return RTEMS_INVALID_ADDRESS; if ( !count ) 200eff8: 02 80 00 26 be 200f090 200effc: 92 10 00 18 mov %i0, %o1 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 200f000: 11 00 80 d0 sethi %hi(0x2034000), %o0 200f004: 90 12 23 50 or %o0, 0x350, %o0 ! 2034350 <_Message_queue_Information> 200f008: 40 00 19 83 call 2015614 <_Objects_Get> 200f00c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f010: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f014: 80 a0 60 00 cmp %g1, 0 200f018: 02 80 00 08 be 200f038 200f01c: 9a 10 00 1b mov %i3, %o5 200f020: 80 a0 60 02 cmp %g1, 2 200f024: 08 80 00 03 bleu 200f030 200f028: 90 10 20 04 mov 4, %o0 200f02c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( core_status ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f030: 81 c7 e0 08 ret 200f034: 91 e8 00 08 restore %g0, %o0, %o0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 200f038: 92 10 00 19 mov %i1, %o1 200f03c: 94 10 00 1a mov %i2, %o2 200f040: 96 10 00 18 mov %i0, %o3 200f044: 98 10 20 00 clr %o4 200f048: 40 00 13 f7 call 2014024 <_CORE_message_queue_Broadcast> 200f04c: 90 02 20 14 add %o0, 0x14, %o0 200f050: 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 ) 200f054: 03 00 80 ce sethi %hi(0x2033800), %g1 200f058: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f05c: 84 00 bf ff add %g2, -1, %g2 200f060: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f064: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f068: 80 a0 e0 00 cmp %g3, 0 200f06c: 02 80 00 06 be 200f084 200f070: 01 00 00 00 nop #endif count ); _Thread_Enable_dispatch(); return 200f074: 40 00 01 35 call 200f548 <_Message_queue_Translate_core_message_queue_return_code> 200f078: 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 */ } 200f07c: 81 c7 e0 08 ret 200f080: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 200f084: 40 00 1e 98 call 2016ae4 <_Thread_Dispatch> 200f088: 01 00 00 00 nop 200f08c: 30 bf ff fa b,a 200f074 #endif count ); _Thread_Enable_dispatch(); return 200f090: 10 bf ff e8 b 200f030 <== NOT EXECUTED 200f094: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 0200f098 : uint32_t count, uint32_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f098: 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 ) ) 200f09c: a4 96 20 00 orcc %i0, 0, %l2 200f0a0: 02 80 00 1f be 200f11c 200f0a4: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 200f0a8: 80 a7 20 00 cmp %i4, 0 200f0ac: 02 80 00 1c be 200f11c 200f0b0: 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 ) 200f0b4: 80 a6 60 00 cmp %i1, 0 200f0b8: 02 80 00 19 be 200f11c 200f0bc: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 200f0c0: 80 a6 a0 00 cmp %i2, 0 200f0c4: 02 80 00 16 be 200f11c 200f0c8: b0 10 20 08 mov 8, %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f0cc: 23 00 80 ce sethi %hi(0x2033800), %l1 200f0d0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 200f0d4: 82 00 60 01 inc %g1 200f0d8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate( count, max_message_size ); 200f0dc: 90 10 00 19 mov %i1, %o0 200f0e0: 40 00 2f af call 201af9c <_Message_queue_Allocate> 200f0e4: 92 10 00 1a mov %i2, %o1 if ( !the_message_queue ) { 200f0e8: a0 92 20 00 orcc %o0, 0, %l0 200f0ec: 12 80 00 0e bne 200f124 200f0f0: 80 8e e0 04 btst 4, %i3 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f0f4: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 200f0f8: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 200f0fc: 82 00 7f ff add %g1, -1, %g1 200f100: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 200f104: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 200f108: 80 a0 a0 00 cmp %g2, 0 200f10c: 12 80 00 33 bne 200f1d8 200f110: 01 00 00 00 nop 200f114: 40 00 1e 74 call 2016ae4 <_Thread_Dispatch> 200f118: 01 00 00 00 nop 200f11c: 81 c7 e0 08 ret 200f120: 81 e8 00 00 restore } #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) 200f124: 12 80 00 11 bne 200f168 200f128: f6 24 20 10 st %i3, [ %l0 + 0x10 ] the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 200f12c: c0 27 bf f4 clr [ %fp + -12 ] if ( ! _CORE_message_queue_Initialize( 200f130: 94 10 00 19 mov %i1, %o2 200f134: 96 10 00 1a mov %i2, %o3 200f138: 90 04 20 14 add %l0, 0x14, %o0 200f13c: 40 00 14 07 call 2014158 <_CORE_message_queue_Initialize> 200f140: 92 07 bf f4 add %fp, -12, %o1 200f144: 80 a2 20 00 cmp %o0, 0 200f148: 12 80 00 0b bne 200f174 200f14c: 92 10 00 10 mov %l0, %o1 RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 200f150: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED 200f154: 40 00 18 d9 call 20154b8 <_Objects_Free> <== NOT EXECUTED 200f158: 90 12 23 50 or %o0, 0x350, %o0 ! 2034350 <_Message_queue_Information> <== 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 ) 200f15c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 200f160: 10 bf ff e7 b 200f0fc <== NOT EXECUTED 200f164: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED #endif the_message_queue->attribute_set = attribute_set; if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 200f168: 82 10 20 01 mov 1, %g1 200f16c: 10 bf ff f1 b 200f130 200f170: c2 27 bf f4 st %g1, [ %fp + -12 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f174: 03 00 80 d0 sethi %hi(0x2034000), %g1 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200f178: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f17c: 88 10 63 50 or %g1, 0x350, %g4 200f180: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 200f184: 03 00 00 3f sethi %hi(0xfc00), %g1 200f188: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f18c: 82 08 c0 01 and %g3, %g1, %g1 200f190: 80 a0 40 02 cmp %g1, %g2 200f194: 38 80 00 06 bgu,a 200f1ac 200f198: e4 24 20 0c st %l2, [ %l0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f19c: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200f1a0: 83 28 60 02 sll %g1, 2, %g1 200f1a4: e0 20 80 01 st %l0, [ %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; 200f1a8: e4 24 20 0c st %l2, [ %l0 + 0xc ] &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 200f1ac: c6 27 00 00 st %g3, [ %i4 ] 200f1b0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 200f1b4: b0 10 20 00 clr %i0 200f1b8: 82 00 7f ff add %g1, -1, %g1 200f1bc: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 200f1c0: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 200f1c4: 80 a0 a0 00 cmp %g2, 0 200f1c8: 12 80 00 04 bne 200f1d8 200f1cc: 01 00 00 00 nop _Thread_Dispatch(); 200f1d0: 40 00 1e 45 call 2016ae4 <_Thread_Dispatch> 200f1d4: 01 00 00 00 nop ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200f1d8: 81 c7 e0 08 ret 200f1dc: 81 e8 00 00 restore 02016508 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 2016508: 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 *) 201650c: 21 00 80 b0 sethi %hi(0x202c000), %l0 2016510: 92 10 00 18 mov %i0, %o1 2016514: 94 07 bf f4 add %fp, -12, %o2 2016518: 7f ff e2 c2 call 200f020 <_Objects_Get> 201651c: 90 14 20 cc or %l0, 0xcc, %o0 register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2016520: c2 07 bf f4 ld [ %fp + -12 ], %g1 2016524: 80 a0 60 00 cmp %g1, 0 2016528: 12 80 00 20 bne 20165a8 201652c: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2016530: a0 14 20 cc or %l0, 0xcc, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2016534: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2016538: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 201653c: 05 00 00 3f sethi %hi(0xfc00), %g2 2016540: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2016544: 82 08 40 02 and %g1, %g2, %g1 2016548: 80 a0 40 03 cmp %g1, %g3 201654c: 18 80 00 05 bgu 2016560 2016550: 94 10 20 05 mov 5, %o2 information->local_table[ index ] = the_object; 2016554: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2016558: 83 28 60 02 sll %g1, 2, %g1 201655c: c0 20 80 01 clr [ %g2 + %g1 ] case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, &the_message_queue->Object ); _CORE_message_queue_Close( 2016560: 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; 2016564: c0 26 20 0c clr [ %i0 + 0xc ] 2016568: 40 00 01 c0 call 2016c68 <_CORE_message_queue_Close> 201656c: 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 ); 2016570: 90 10 00 10 mov %l0, %o0 2016574: 7f ff e2 68 call 200ef14 <_Objects_Free> 2016578: 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 ) 201657c: 03 00 80 ad sethi %hi(0x202b400), %g1 2016580: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 202b660 <_Thread_Dispatch_disable_level> 2016584: b0 10 20 00 clr %i0 2016588: 84 00 bf ff add %g2, -1, %g2 201658c: c4 20 62 60 st %g2, [ %g1 + 0x260 ] 2016590: c6 00 62 60 ld [ %g1 + 0x260 ], %g3 2016594: 80 a0 e0 00 cmp %g3, 0 2016598: 02 80 00 09 be 20165bc 201659c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20165a0: 81 c7 e0 08 ret 20165a4: 81 e8 00 00 restore { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 20165a8: 80 a0 60 02 cmp %g1, 2 20165ac: 08 bf ff fd bleu 20165a0 20165b0: b0 10 20 04 mov 4, %i0 20165b4: 81 c7 e0 08 ret <== NOT EXECUTED 20165b8: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED _Thread_Dispatch(); 20165bc: 7f ff e7 cd call 20104f0 <_Thread_Dispatch> 20165c0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20165c4: 81 c7 e0 08 ret 20165c8: 81 e8 00 00 restore 0200f2a4 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 200f2a4: 9d e3 bf 90 save %sp, -112, %sp 200f2a8: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f2ac: 80 a6 60 00 cmp %i1, 0 200f2b0: 02 80 00 1c be 200f320 200f2b4: 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 *) 200f2b8: 11 00 80 d0 sethi %hi(0x2034000), %o0 200f2bc: 94 07 bf f4 add %fp, -12, %o2 200f2c0: 40 00 18 d5 call 2015614 <_Objects_Get> 200f2c4: 90 12 23 50 or %o0, 0x350, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f2c8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f2cc: 80 a0 60 00 cmp %g1, 0 200f2d0: 02 80 00 06 be 200f2e8 200f2d4: 80 a0 60 02 cmp %g1, 2 200f2d8: 08 80 00 12 bleu 200f320 200f2dc: b0 10 20 04 mov 4, %i0 200f2e0: 81 c7 e0 08 ret <== NOT EXECUTED 200f2e4: 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 ); 200f2e8: 40 00 13 7c call 20140d8 <_CORE_message_queue_Flush> 200f2ec: 90 02 20 14 add %o0, 0x14, %o0 200f2f0: 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 ) 200f2f4: 03 00 80 ce sethi %hi(0x2033800), %g1 200f2f8: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f2fc: b0 10 20 00 clr %i0 200f300: 84 00 bf ff add %g2, -1, %g2 200f304: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f308: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f30c: 80 a0 e0 00 cmp %g3, 0 200f310: 12 80 00 04 bne 200f320 200f314: 01 00 00 00 nop _Thread_Dispatch(); 200f318: 40 00 1d f3 call 2016ae4 <_Thread_Dispatch> 200f31c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f320: 81 c7 e0 08 ret 200f324: 81 e8 00 00 restore 0200f328 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 200f328: 9d e3 bf 90 save %sp, -112, %sp 200f32c: 92 10 00 18 mov %i0, %o1 register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 200f330: 80 a6 60 00 cmp %i1, 0 200f334: 02 80 00 1b be 200f3a0 200f338: b0 10 20 09 mov 9, %i0 200f33c: 11 00 80 d0 sethi %hi(0x2034000), %o0 200f340: 94 07 bf f4 add %fp, -12, %o2 200f344: 40 00 18 b4 call 2015614 <_Objects_Get> 200f348: 90 12 23 50 or %o0, 0x350, %o0 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 200f34c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f350: 80 a0 60 00 cmp %g1, 0 200f354: 22 80 00 07 be,a 200f370 200f358: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 200f35c: 80 a0 60 02 cmp %g1, 2 200f360: 08 80 00 10 bleu 200f3a0 200f364: b0 10 20 04 mov 4, %i0 200f368: 81 c7 e0 08 ret <== NOT EXECUTED 200f36c: 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; 200f370: 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 ) 200f374: 07 00 80 ce sethi %hi(0x2033800), %g3 200f378: c2 00 e1 60 ld [ %g3 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 200f37c: b0 10 20 00 clr %i0 200f380: 82 00 7f ff add %g1, -1, %g1 200f384: c2 20 e1 60 st %g1, [ %g3 + 0x160 ] 200f388: c4 00 e1 60 ld [ %g3 + 0x160 ], %g2 200f38c: 80 a0 a0 00 cmp %g2, 0 200f390: 12 80 00 04 bne 200f3a0 200f394: 01 00 00 00 nop _Thread_Dispatch(); 200f398: 40 00 1d d3 call 2016ae4 <_Thread_Dispatch> 200f39c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f3a0: 81 c7 e0 08 ret 200f3a4: 81 e8 00 00 restore 02016600 : void *buffer, size_t *size, uint32_t option_set, rtems_interval timeout ) { 2016600: 9d e3 bf 90 save %sp, -112, %sp register Message_queue_Control *the_message_queue; Objects_Locations location; boolean wait; if ( !buffer ) 2016604: 80 a6 60 00 cmp %i1, 0 2016608: 02 80 00 2b be 20166b4 201660c: 92 10 00 18 mov %i0, %o1 return RTEMS_INVALID_ADDRESS; if ( !size ) 2016610: 80 a6 a0 00 cmp %i2, 0 2016614: 02 80 00 28 be 20166b4 2016618: 94 07 bf f4 add %fp, -12, %o2 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get ( Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) 201661c: 11 00 80 b0 sethi %hi(0x202c000), %o0 2016620: 7f ff e2 80 call 200f020 <_Objects_Get> 2016624: 90 12 20 cc or %o0, 0xcc, %o0 ! 202c0cc <_Message_queue_Information> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 2016628: c2 07 bf f4 ld [ %fp + -12 ], %g1 201662c: 80 a0 60 00 cmp %g1, 0 2016630: 22 80 00 08 be,a 2016650 2016634: d2 02 20 08 ld [ %o0 + 8 ], %o1 2016638: 80 a0 60 02 cmp %g1, 2 201663c: 08 80 00 03 bleu 2016648 2016640: 90 10 20 04 mov 4, %o0 2016644: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2016648: 81 c7 e0 08 ret 201664c: 91 e8 00 08 restore %g0, %o0, %o0 2016650: 98 0e e0 01 and %i3, 1, %o4 if ( _Options_Is_no_wait( option_set ) ) wait = FALSE; else wait = TRUE; _CORE_message_queue_Seize( 2016654: 94 10 00 19 mov %i1, %o2 2016658: 96 10 00 1a mov %i2, %o3 201665c: 98 1b 20 01 xor %o4, 1, %o4 2016660: 9a 10 00 1c mov %i4, %o5 2016664: 40 00 01 a7 call 2016d00 <_CORE_message_queue_Seize> 2016668: 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 ) 201666c: 05 00 80 ad sethi %hi(0x202b400), %g2 2016670: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 2016674: 82 00 7f ff add %g1, -1, %g1 2016678: c2 20 a2 60 st %g1, [ %g2 + 0x260 ] 201667c: c6 00 a2 60 ld [ %g2 + 0x260 ], %g3 2016680: 80 a0 e0 00 cmp %g3, 0 2016684: 02 80 00 08 be 20166a4 2016688: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 201668c: 03 00 80 ad sethi %hi(0x202b400), %g1 <== NOT EXECUTED 2016690: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 202b740 <_Thread_Executing> 2016694: 40 00 00 36 call 201676c <_Message_queue_Translate_core_message_queue_return_code> 2016698: d0 00 a0 34 ld [ %g2 + 0x34 ], %o0 ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 201669c: 81 c7 e0 08 ret 20166a0: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 20166a4: 7f ff e7 93 call 20104f0 <_Thread_Dispatch> 20166a8: 01 00 00 00 nop size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 20166ac: 10 bf ff f9 b 2016690 20166b0: 03 00 80 ad sethi %hi(0x202b400), %g1 20166b4: 10 bf ff e5 b 2016648 <== NOT EXECUTED 20166b8: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED 020166bc : rtems_status_code rtems_message_queue_send( Objects_Id id, void *buffer, size_t size ) { 20166bc: 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 ) 20166c0: 80 a6 60 00 cmp %i1, 0 20166c4: 02 80 00 20 be 2016744 20166c8: 90 10 20 09 mov 9, %o0 20166cc: 11 00 80 b0 sethi %hi(0x202c000), %o0 20166d0: 92 10 00 18 mov %i0, %o1 20166d4: 90 12 20 cc or %o0, 0xcc, %o0 20166d8: 7f ff e2 52 call 200f020 <_Objects_Get> 20166dc: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 20166e0: c2 07 bf f4 ld [ %fp + -12 ], %g1 20166e4: 80 a0 60 00 cmp %g1, 0 20166e8: 12 80 00 19 bne 201674c 20166ec: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 20166f0: 94 10 00 1a mov %i2, %o2 20166f4: c0 23 a0 5c clr [ %sp + 0x5c ] 20166f8: c0 23 a0 60 clr [ %sp + 0x60 ] 20166fc: 92 10 00 19 mov %i1, %o1 2016700: 96 10 00 18 mov %i0, %o3 2016704: 98 10 20 00 clr %o4 2016708: 90 02 20 14 add %o0, 0x14, %o0 201670c: 1b 1f ff ff sethi %hi(0x7ffffc00), %o5 2016710: 40 00 01 c3 call 2016e1c <_CORE_message_queue_Submit> 2016714: 9a 13 63 ff or %o5, 0x3ff, %o5 ! 7fffffff 2016718: 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 ) 201671c: 05 00 80 ad sethi %hi(0x202b400), %g2 2016720: c2 00 a2 60 ld [ %g2 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 2016724: 82 00 7f ff add %g1, -1, %g1 2016728: c2 20 a2 60 st %g1, [ %g2 + 0x260 ] 201672c: c6 00 a2 60 ld [ %g2 + 0x260 ], %g3 2016730: 80 a0 e0 00 cmp %g3, 0 2016734: 02 80 00 0b be 2016760 2016738: 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); 201673c: 40 00 00 0c call 201676c <_Message_queue_Translate_core_message_queue_return_code> 2016740: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2016744: 81 c7 e0 08 ret 2016748: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 201674c: 08 bf ff fe bleu 2016744 2016750: 90 10 20 04 mov 4, %o0 2016754: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2016758: 81 c7 e0 08 ret <== NOT EXECUTED 201675c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2016760: 7f ff e7 64 call 20104f0 <_Thread_Dispatch> 2016764: 01 00 00 00 nop 2016768: 30 bf ff f5 b,a 201673c 020088e8 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, void *buffer, size_t size ) { 20088e8: 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 ) 20088ec: 80 a6 60 00 cmp %i1, 0 20088f0: 02 80 00 1f be 200896c 20088f4: 90 10 20 09 mov 9, %o0 20088f8: 11 00 80 88 sethi %hi(0x2022000), %o0 20088fc: 92 10 00 18 mov %i0, %o1 2008900: 90 12 22 68 or %o0, 0x268, %o0 2008904: 40 00 0a 46 call 200b21c <_Objects_Get> 2008908: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 200890c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008910: 80 a0 60 00 cmp %g1, 0 2008914: 12 80 00 18 bne 2008974 2008918: 80 a0 60 02 cmp %g1, 2 CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, boolean wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 200891c: 94 10 00 1a mov %i2, %o2 2008920: c0 23 a0 5c clr [ %sp + 0x5c ] 2008924: c0 23 a0 60 clr [ %sp + 0x60 ] 2008928: 92 10 00 19 mov %i1, %o1 200892c: 96 10 00 18 mov %i0, %o3 2008930: 98 10 20 00 clr %o4 2008934: 1b 20 00 00 sethi %hi(0x80000000), %o5 2008938: 40 00 06 0d call 200a16c <_CORE_message_queue_Submit> 200893c: 90 02 20 14 add %o0, 0x14, %o0 2008940: 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 ) 2008944: 03 00 80 86 sethi %hi(0x2021800), %g1 2008948: c4 00 60 80 ld [ %g1 + 0x80 ], %g2 ! 2021880 <_Thread_Dispatch_disable_level> 200894c: 84 00 bf ff add %g2, -1, %g2 2008950: c4 20 60 80 st %g2, [ %g1 + 0x80 ] 2008954: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 2008958: 80 a0 e0 00 cmp %g3, 0 200895c: 02 80 00 0b be 2008988 2008960: 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); 2008964: 7f ff ff d7 call 20088c0 <_Message_queue_Translate_core_message_queue_return_code> 2008968: 90 10 00 1a mov %i2, %o0 } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200896c: 81 c7 e0 08 ret 2008970: 91 e8 00 08 restore %g0, %o0, %o0 if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) 2008974: 08 bf ff fe bleu 200896c <== NOT EXECUTED 2008978: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED 200897c: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code(status); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008980: 81 c7 e0 08 ret <== NOT EXECUTED 2008984: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008988: 40 00 0f 59 call 200c6ec <_Thread_Dispatch> 200898c: 01 00 00 00 nop 2008990: 30 bf ff f5 b,a 2008964 02008c10 : void rtems_panic( const char *printf_format, ... ) { 2008c10: 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); 2008c14: 11 08 00 00 sethi %hi(0x20000000), %o0 <== NOT EXECUTED ... ) { va_list arglist; va_start(arglist, printf_format); 2008c18: 94 07 a0 48 add %fp, 0x48, %o2 <== NOT EXECUTED void rtems_panic( const char *printf_format, ... ) { 2008c1c: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED 2008c20: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 2008c24: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED 2008c28: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED 2008c2c: 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); 2008c30: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2008c34: 7f ff ff 88 call 2008a54 <== NOT EXECUTED 2008c38: d4 27 bf f4 st %o2, [ %fp + -12 ] <== NOT EXECUTED va_end(arglist); } 2008c3c: 81 c7 e0 08 ret <== NOT EXECUTED 2008c40: 81 e8 00 00 restore <== NOT EXECUTED 0200f570 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 200f570: 9d e3 bf 98 save %sp, -104, %sp register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 200f574: a8 96 20 00 orcc %i0, 0, %l4 200f578: 02 80 00 29 be 200f61c 200f57c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 200f580: 80 a6 60 00 cmp %i1, 0 200f584: 02 80 00 11 be 200f5c8 200f588: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 200f58c: 02 80 00 0f be 200f5c8 200f590: 80 a6 a0 00 cmp %i2, 0 return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f594: 12 80 00 04 bne 200f5a4 200f598: 80 a6 e0 00 cmp %i3, 0 ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 200f59c: 81 c7 e0 08 ret 200f5a0: 91 e8 20 08 restore %g0, 8, %o0 return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 200f5a4: 02 80 00 1e be 200f61c 200f5a8: b0 10 20 08 mov 8, %i0 200f5ac: 80 a6 80 1b cmp %i2, %i3 200f5b0: 0a 80 00 1b bcs 200f61c 200f5b4: 80 8e e0 07 btst 7, %i3 200f5b8: 12 80 00 19 bne 200f61c 200f5bc: 80 8e 60 07 btst 7, %i1 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 200f5c0: 02 80 00 04 be 200f5d0 200f5c4: 25 00 80 ce sethi %hi(0x2033800), %l2 200f5c8: 81 c7 e0 08 ret 200f5cc: 91 e8 20 09 restore %g0, 9, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200f5d0: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 200f5d4: 82 00 60 01 inc %g1 200f5d8: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] * the inactive chain of free partition control blocks. */ RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Allocate ( void ) { return (Partition_Control *) _Objects_Allocate( &_Partition_Information ); 200f5dc: 27 00 80 cd sethi %hi(0x2033400), %l3 200f5e0: 40 00 16 a8 call 2015080 <_Objects_Allocate> 200f5e4: 90 14 e2 e4 or %l3, 0x2e4, %o0 ! 20336e4 <_Partition_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 200f5e8: a2 92 20 00 orcc %o0, 0, %l1 200f5ec: 12 80 00 0e bne 200f624 200f5f0: 92 10 00 1b mov %i3, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f5f4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 200f5f8: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 200f5fc: 82 00 7f ff add %g1, -1, %g1 200f600: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] 200f604: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 200f608: 80 a0 a0 00 cmp %g2, 0 200f60c: 12 80 00 04 bne 200f61c 200f610: 01 00 00 00 nop 200f614: 40 00 1d 34 call 2016ae4 <_Thread_Dispatch> 200f618: 01 00 00 00 nop 200f61c: 81 c7 e0 08 ret 200f620: 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; 200f624: f8 24 60 1c st %i4, [ %l1 + 0x1c ] _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 200f628: f2 24 60 10 st %i1, [ %l1 + 0x10 ] the_partition->length = length; 200f62c: f4 24 60 14 st %i2, [ %l1 + 0x14 ] the_partition->buffer_size = buffer_size; 200f630: f6 24 60 18 st %i3, [ %l1 + 0x18 ] the_partition->attribute_set = attribute_set; the_partition->number_of_used_blocks = 0; 200f634: c0 24 60 20 clr [ %l1 + 0x20 ] _Chain_Initialize( &the_partition->Memory, starting_address, 200f638: 40 00 58 5e call 20257b0 <.udiv> 200f63c: 90 10 00 1a mov %i2, %o0 200f640: a0 04 60 24 add %l1, 0x24, %l0 200f644: 94 10 00 08 mov %o0, %o2 200f648: 92 10 00 19 mov %i1, %o1 200f64c: 90 10 00 10 mov %l0, %o0 200f650: 40 00 12 5d call 2013fc4 <_Chain_Initialize> 200f654: 96 10 00 1b mov %i3, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f658: 90 14 e2 e4 or %l3, 0x2e4, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200f65c: c6 04 60 08 ld [ %l1 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f660: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 200f664: 03 00 00 3f sethi %hi(0xfc00), %g1 200f668: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200f66c: 82 08 c0 01 and %g3, %g1, %g1 200f670: 80 a0 40 02 cmp %g1, %g2 200f674: 38 80 00 06 bgu,a 200f68c 200f678: e8 24 60 0c st %l4, [ %l1 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200f67c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200f680: 83 28 60 02 sll %g1, 2, %g1 200f684: e2 20 80 01 st %l1, [ %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; 200f688: e8 24 60 0c st %l4, [ %l1 + 0xc ] &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 200f68c: c6 27 40 00 st %g3, [ %i5 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f690: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 200f694: 10 bf ff da b 200f5fc 200f698: b0 10 20 00 clr %i0 0200f69c : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 200f69c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f6a0: 92 10 00 18 mov %i0, %o1 200f6a4: 94 07 bf f4 add %fp, -12, %o2 200f6a8: 31 00 80 cd sethi %hi(0x2033400), %i0 200f6ac: 40 00 17 da call 2015614 <_Objects_Get> 200f6b0: 90 16 22 e4 or %i0, 0x2e4, %o0 ! 20336e4 <_Partition_Information> register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f6b4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f6b8: 80 a0 60 00 cmp %g1, 0 200f6bc: 12 80 00 13 bne 200f708 200f6c0: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 200f6c4: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 200f6c8: 80 a0 60 00 cmp %g1, 0 200f6cc: 02 80 00 14 be 200f71c 200f6d0: 90 16 22 e4 or %i0, 0x2e4, %o0 200f6d4: 03 00 80 ce sethi %hi(0x2033800), %g1 200f6d8: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f6dc: b0 10 20 0c mov 0xc, %i0 200f6e0: 84 00 bf ff add %g2, -1, %g2 200f6e4: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f6e8: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f6ec: 80 a0 e0 00 cmp %g3, 0 200f6f0: 12 80 00 22 bne 200f778 200f6f4: 01 00 00 00 nop _Thread_Dispatch(); 200f6f8: 40 00 1c fb call 2016ae4 <_Thread_Dispatch> 200f6fc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f700: 81 c7 e0 08 ret 200f704: 81 e8 00 00 restore { register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f708: 80 a0 60 02 cmp %g1, 2 200f70c: 08 bf ff fd bleu 200f700 200f710: b0 10 20 04 mov 4, %i0 200f714: 81 c7 e0 08 ret <== NOT EXECUTED 200f718: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200f71c: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200f720: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200f724: 05 00 00 3f sethi %hi(0xfc00), %g2 200f728: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200f72c: 82 08 40 02 and %g1, %g2, %g1 200f730: 80 a0 40 03 cmp %g1, %g3 200f734: 18 80 00 04 bgu 200f744 200f738: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200f73c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200f740: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Partition_Free ( Partition_Control *the_partition ) { _Objects_Free( &_Partition_Information, &the_partition->Object ); 200f744: 40 00 17 5d call 20154b8 <_Objects_Free> 200f748: c0 22 60 0c clr [ %o1 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f74c: 03 00 80 ce sethi %hi(0x2033800), %g1 200f750: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f754: b0 10 20 00 clr %i0 200f758: 84 00 bf ff add %g2, -1, %g2 200f75c: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f760: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f764: 80 a0 e0 00 cmp %g3, 0 200f768: 12 80 00 04 bne 200f778 200f76c: 01 00 00 00 nop _Thread_Dispatch(); 200f770: 40 00 1c dd call 2016ae4 <_Thread_Dispatch> 200f774: 01 00 00 00 nop 200f778: 81 c7 e0 08 ret 200f77c: 81 e8 00 00 restore 0200f780 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 200f780: 9d e3 bf 90 save %sp, -112, %sp 200f784: 92 10 00 18 mov %i0, %o1 register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 200f788: 80 a6 60 00 cmp %i1, 0 200f78c: 02 80 00 1a be 200f7f4 200f790: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f794: 11 00 80 cd sethi %hi(0x2033400), %o0 200f798: 94 07 bf f4 add %fp, -12, %o2 200f79c: 40 00 17 9e call 2015614 <_Objects_Get> 200f7a0: 90 12 22 e4 or %o0, 0x2e4, %o0 return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f7a4: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f7a8: 80 a0 60 00 cmp %g1, 0 200f7ac: 12 80 00 14 bne 200f7fc 200f7b0: b0 10 00 08 mov %o0, %i0 RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 200f7b4: 40 00 11 f1 call 2013f78 <_Chain_Get> 200f7b8: 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 ) { 200f7bc: a0 92 20 00 orcc %o0, 0, %l0 200f7c0: 32 80 00 14 bne,a 200f810 200f7c4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f7c8: 03 00 80 ce sethi %hi(0x2033800), %g1 200f7cc: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f7d0: b0 10 20 0d mov 0xd, %i0 200f7d4: 84 00 bf ff add %g2, -1, %g2 200f7d8: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f7dc: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f7e0: 80 a0 e0 00 cmp %g3, 0 200f7e4: 12 80 00 04 bne 200f7f4 200f7e8: 01 00 00 00 nop _Thread_Dispatch(); 200f7ec: 40 00 1c be call 2016ae4 <_Thread_Dispatch> 200f7f0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_UNSATISFIED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f7f4: 81 c7 e0 08 ret 200f7f8: 81 e8 00 00 restore if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f7fc: 80 a0 60 02 cmp %g1, 2 200f800: 08 bf ff fd bleu 200f7f4 200f804: b0 10 20 04 mov 4, %i0 200f808: 81 c7 e0 08 ret <== NOT EXECUTED 200f80c: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { the_partition->number_of_used_blocks += 1; 200f810: 82 00 60 01 inc %g1 200f814: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f818: 05 00 80 ce sethi %hi(0x2033800), %g2 200f81c: c2 00 a1 60 ld [ %g2 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 200f820: 82 00 7f ff add %g1, -1, %g1 200f824: c2 20 a1 60 st %g1, [ %g2 + 0x160 ] 200f828: c6 00 a1 60 ld [ %g2 + 0x160 ], %g3 200f82c: 80 a0 e0 00 cmp %g3, 0 200f830: 02 80 00 05 be 200f844 200f834: 01 00 00 00 nop _Thread_Enable_dispatch(); *buffer = the_buffer; 200f838: e0 26 40 00 st %l0, [ %i1 ] <== NOT EXECUTED 200f83c: 81 c7 e0 08 ret 200f840: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Dispatch(); 200f844: 40 00 1c a8 call 2016ae4 <_Thread_Dispatch> 200f848: 01 00 00 00 nop 200f84c: 10 bf ff fc b 200f83c 200f850: e0 26 40 00 st %l0, [ %i1 ] 0200f888 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 200f888: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get ( Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) 200f88c: 11 00 80 cd sethi %hi(0x2033400), %o0 200f890: 92 10 00 18 mov %i0, %o1 200f894: 90 12 22 e4 or %o0, 0x2e4, %o0 200f898: 40 00 17 5f call 2015614 <_Objects_Get> 200f89c: 94 07 bf f4 add %fp, -12, %o2 register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 200f8a0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f8a4: 80 a0 60 00 cmp %g1, 0 200f8a8: 12 80 00 12 bne 200f8f0 200f8ac: b0 10 00 08 mov %o0, %i0 ) { void *starting; void *ending; starting = the_partition->starting_address; 200f8b0: c4 02 20 10 ld [ %o0 + 0x10 ], %g2 ending = _Addresses_Add_offset( starting, the_partition->length ); return ( 200f8b4: 80 a0 80 19 cmp %g2, %i1 200f8b8: 28 80 00 13 bleu,a 200f904 200f8bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f8c0: 03 00 80 ce sethi %hi(0x2033800), %g1 200f8c4: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200f8c8: 84 00 bf ff add %g2, -1, %g2 200f8cc: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200f8d0: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200f8d4: 80 a0 e0 00 cmp %g3, 0 200f8d8: 12 80 00 27 bne 200f974 200f8dc: 01 00 00 00 nop _Thread_Dispatch(); 200f8e0: 40 00 1c 81 call 2016ae4 <_Thread_Dispatch> 200f8e4: b0 10 20 09 mov 9, %i0 ! 9 200f8e8: 81 c7 e0 08 ret 200f8ec: 81 e8 00 00 restore 200f8f0: 80 a0 60 02 cmp %g1, 2 200f8f4: 08 bf ff fd bleu 200f8e8 200f8f8: b0 10 20 04 mov 4, %i0 200f8fc: 81 c7 e0 08 ret <== NOT EXECUTED 200f900: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 200f904: 82 00 80 01 add %g2, %g1, %g1 200f908: 80 a0 40 19 cmp %g1, %i1 200f90c: 0a bf ff ed bcs 200f8c0 200f910: 01 00 00 00 nop 200f914: d2 02 20 18 ld [ %o0 + 0x18 ], %o1 200f918: 40 00 58 52 call 2025a60 <.urem> 200f91c: 90 26 40 02 sub %i1, %g2, %o0 200f920: 80 a2 20 00 cmp %o0, 0 200f924: 12 bf ff e7 bne 200f8c0 200f928: 92 10 00 19 mov %i1, %o1 RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 200f92c: 40 00 11 87 call 2013f48 <_Chain_Append> 200f930: 90 06 20 24 add %i0, 0x24, %o0 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; 200f934: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 200f938: 82 00 7f ff add %g1, -1, %g1 200f93c: c2 26 20 20 st %g1, [ %i0 + 0x20 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f940: 07 00 80 ce sethi %hi(0x2033800), %g3 200f944: c2 00 e1 60 ld [ %g3 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 200f948: b0 10 20 00 clr %i0 200f94c: 82 00 7f ff add %g1, -1, %g1 200f950: c2 20 e1 60 st %g1, [ %g3 + 0x160 ] 200f954: c4 00 e1 60 ld [ %g3 + 0x160 ], %g2 200f958: 80 a0 a0 00 cmp %g2, 0 200f95c: 12 80 00 04 bne 200f96c 200f960: 01 00 00 00 nop _Thread_Dispatch(); 200f964: 40 00 1c 60 call 2016ae4 <_Thread_Dispatch> 200f968: 01 00 00 00 nop 200f96c: 81 c7 e0 08 ret 200f970: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f974: 81 c7 e0 08 ret <== NOT EXECUTED 200f978: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED 0200e7f4 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 200e7f4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get ( Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) 200e7f8: 92 10 00 18 mov %i0, %o1 200e7fc: 94 07 bf f4 add %fp, -12, %o2 200e800: 31 00 80 cd sethi %hi(0x2033400), %i0 200e804: 40 00 1b 84 call 2015614 <_Objects_Get> 200e808: 90 16 22 98 or %i0, 0x298, %o0 ! 2033698 <_Dual_ported_memory_Information> register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200e80c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200e810: 80 a0 60 00 cmp %g1, 0 200e814: 12 80 00 1a bne 200e87c 200e818: 92 10 00 08 mov %o0, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e81c: 90 16 22 98 or %i0, 0x298, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200e820: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200e824: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 200e828: 05 00 00 3f sethi %hi(0xfc00), %g2 200e82c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200e830: 82 08 40 02 and %g1, %g2, %g1 200e834: 80 a0 40 03 cmp %g1, %g3 200e838: 18 80 00 04 bgu 200e848 200e83c: 83 28 60 02 sll %g1, 2, %g1 information->local_table[ index ] = the_object; 200e840: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 200e844: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Dual_ported_memory_Free ( Dual_ported_memory_Control *the_port ) { _Objects_Free( &_Dual_ported_memory_Information, &the_port->Object ); 200e848: 40 00 1b 1c call 20154b8 <_Objects_Free> 200e84c: c0 22 60 0c clr [ %o1 + 0xc ] 200e850: 03 00 80 ce sethi %hi(0x2033800), %g1 200e854: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200e858: b0 10 20 00 clr %i0 200e85c: 84 00 bf ff add %g2, -1, %g2 200e860: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200e864: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200e868: 80 a0 e0 00 cmp %g3, 0 200e86c: 02 80 00 0a be 200e894 200e870: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e874: 81 c7 e0 08 ret <== NOT EXECUTED 200e878: 81 e8 00 00 restore <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 200e87c: 82 18 60 02 xor %g1, 2, %g1 200e880: 80 a0 00 01 cmp %g0, %g1 200e884: 84 60 20 00 subx %g0, 0, %g2 200e888: b0 08 a0 15 and %g2, 0x15, %i0 200e88c: 81 c7 e0 08 ret 200e890: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200e894: 40 00 20 94 call 2016ae4 <_Thread_Dispatch> 200e898: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200e89c: 81 c7 e0 08 ret 200e8a0: 81 e8 00 00 restore 0200fb90 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 200fb90: 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 *) 200fb94: 21 00 80 cd sethi %hi(0x2033400), %l0 200fb98: 92 10 00 18 mov %i0, %o1 200fb9c: 94 07 bf f4 add %fp, -12, %o2 200fba0: 40 00 16 9d call 2015614 <_Objects_Get> 200fba4: 90 14 23 30 or %l0, 0x330, %o0 Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200fba8: c2 07 bf f4 ld [ %fp + -12 ], %g1 200fbac: 80 a0 60 00 cmp %g1, 0 200fbb0: 12 80 00 20 bne 200fc30 200fbb4: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fbb8: a0 14 23 30 or %l0, 0x330, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200fbbc: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200fbc0: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 200fbc4: 05 00 00 3f sethi %hi(0xfc00), %g2 200fbc8: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 200fbcc: 82 08 40 02 and %g1, %g2, %g1 200fbd0: 80 a0 40 03 cmp %g1, %g3 200fbd4: 38 80 00 06 bgu,a 200fbec 200fbd8: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 200fbdc: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 200fbe0: 83 28 60 02 sll %g1, 2, %g1 200fbe4: 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; 200fbe8: 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 ); 200fbec: 40 00 22 bc call 20186dc <_Watchdog_Remove> 200fbf0: 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 ); 200fbf4: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_INACTIVE; 200fbf8: c0 26 20 38 clr [ %i0 + 0x38 ] 200fbfc: 40 00 16 2f call 20154b8 <_Objects_Free> 200fc00: 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 ) 200fc04: 03 00 80 ce sethi %hi(0x2033800), %g1 200fc08: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 200fc0c: b0 10 20 00 clr %i0 200fc10: 84 00 bf ff add %g2, -1, %g2 200fc14: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 200fc18: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 200fc1c: 80 a0 e0 00 cmp %g3, 0 200fc20: 02 80 00 0a be 200fc48 200fc24: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200fc28: 81 c7 e0 08 ret <== NOT EXECUTED 200fc2c: 81 e8 00 00 restore <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200fc30: 82 18 60 02 xor %g1, 2, %g1 200fc34: 80 a0 00 01 cmp %g0, %g1 200fc38: 84 60 20 00 subx %g0, 0, %g2 200fc3c: b0 08 a0 15 and %g2, 0x15, %i0 200fc40: 81 c7 e0 08 ret 200fc44: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200fc48: 40 00 1b a7 call 2016ae4 <_Thread_Dispatch> 200fc4c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200fc50: 81 c7 e0 08 ret 200fc54: 81 e8 00 00 restore 0200f000 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 200f000: 9d e3 bf 90 save %sp, -112, %sp 200f004: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 200f008: 80 a6 60 00 cmp %i1, 0 200f00c: 02 80 00 17 be 200f068 200f010: b0 10 20 09 mov 9, %i0 200f014: 11 00 80 79 sethi %hi(0x201e400), %o0 200f018: 94 07 bf f4 add %fp, -12, %o2 200f01c: 7f ff ea 5e call 2009994 <_Objects_Get> 200f020: 90 12 22 34 or %o0, 0x234, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f024: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f028: 80 a0 60 00 cmp %g1, 0 200f02c: 12 80 00 11 bne 200f070 200f030: 92 10 00 08 mov %o0, %o1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: *statistics = the_period->Statistics; 200f034: 90 10 00 19 mov %i1, %o0 200f038: 92 02 60 54 add %o1, 0x54, %o1 200f03c: 40 00 09 4c call 201156c 200f040: 94 10 20 38 mov 0x38, %o2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200f044: 03 00 80 79 sethi %hi(0x201e400), %g1 200f048: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201e7d0 <_Thread_Dispatch_disable_level> 200f04c: b0 10 20 00 clr %i0 200f050: 84 00 bf ff add %g2, -1, %g2 200f054: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 200f058: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 200f05c: 80 a0 e0 00 cmp %g3, 0 200f060: 02 80 00 0a be 200f088 200f064: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f068: 81 c7 e0 08 ret <== NOT EXECUTED 200f06c: 81 e8 00 00 restore <== NOT EXECUTED if ( !statistics ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f070: 82 18 60 02 xor %g1, 2, %g1 200f074: 80 a0 00 01 cmp %g0, %g1 200f078: 84 60 20 00 subx %g0, 0, %g2 200f07c: b0 08 a0 15 and %g2, 0x15, %i0 200f080: 81 c7 e0 08 ret 200f084: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 200f088: 7f ff ef 77 call 200ae64 <_Thread_Dispatch> 200f08c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f090: 81 c7 e0 08 ret 200f094: 81 e8 00 00 restore 0200f098 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 200f098: 9d e3 bf 88 save %sp, -120, %sp 200f09c: 92 10 00 18 mov %i0, %o1 Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 200f0a0: 80 a6 60 00 cmp %i1, 0 200f0a4: 02 80 00 21 be 200f128 200f0a8: b0 10 20 09 mov 9, %i0 200f0ac: 11 00 80 79 sethi %hi(0x201e400), %o0 200f0b0: 94 07 bf f4 add %fp, -12, %o2 200f0b4: 7f ff ea 38 call 2009994 <_Objects_Get> 200f0b8: 90 12 22 34 or %o0, 0x234, %o0 return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f0bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 200f0c0: 80 a0 60 00 cmp %g1, 0 200f0c4: 12 80 00 1b bne 200f130 200f0c8: b0 10 00 08 mov %o0, %i0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 200f0cc: c2 02 20 50 ld [ %o0 + 0x50 ], %g1 200f0d0: 80 a0 60 00 cmp %g1, 0 200f0d4: 02 80 00 03 be 200f0e0 200f0d8: 84 10 20 00 clr %g2 200f0dc: c4 00 60 08 ld [ %g1 + 8 ], %g2 status->state = the_period->state; 200f0e0: 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); 200f0e4: c4 26 40 00 st %g2, [ %i1 ] status->state = the_period->state; if ( status->state == RATE_MONOTONIC_INACTIVE ) { 200f0e8: 80 a0 60 00 cmp %g1, 0 200f0ec: 12 80 00 1b bne 200f158 200f0f0: 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; 200f0f4: 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; 200f0f8: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 200f0fc: 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; 200f100: c0 26 60 10 clr [ %i1 + 0x10 ] <== 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 ) 200f104: 03 00 80 79 sethi %hi(0x201e400), %g1 200f108: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201e7d0 <_Thread_Dispatch_disable_level> 200f10c: b0 10 20 00 clr %i0 200f110: 84 00 bf ff add %g2, -1, %g2 200f114: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 200f118: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 200f11c: 80 a0 e0 00 cmp %g3, 0 200f120: 02 80 00 0a be 200f148 200f124: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f128: 81 c7 e0 08 ret <== NOT EXECUTED 200f12c: 81 e8 00 00 restore <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 200f130: 82 18 60 02 xor %g1, 2, %g1 <== NOT EXECUTED 200f134: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200f138: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 200f13c: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 200f140: 81 c7 e0 08 ret <== NOT EXECUTED 200f144: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 200f148: 7f ff ef 47 call 200ae64 <_Thread_Dispatch> 200f14c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200f150: 81 c7 e0 08 ret 200f154: 81 e8 00 00 restore * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 200f158: a0 07 bf ec add %fp, -20, %l0 200f15c: 7f ff e6 c0 call 2008c5c <_TOD_Get_uptime> 200f160: 90 10 00 10 mov %l0, %o0 #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 200f164: 90 06 20 44 add %i0, 0x44, %o0 200f168: 92 10 00 10 mov %l0, %o1 200f16c: 7f ff f4 27 call 200c208 <_Timespec_Subtract> 200f170: 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( 200f174: 92 10 00 10 mov %l0, %o1 200f178: 94 06 60 10 add %i1, 0x10, %o2 200f17c: 11 00 80 7a sethi %hi(0x201e800), %o0 200f180: 7f ff f4 22 call 200c208 <_Timespec_Subtract> 200f184: 90 12 20 b8 or %o0, 0xb8, %o0 ! 201e8b8 <_Thread_Time_of_last_context_switch> 200f188: 30 bf ff df b,a 200f104 02006c2c : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 2006c2c: 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 *) 2006c30: 11 00 80 79 sethi %hi(0x201e400), %o0 2006c34: 92 10 00 18 mov %i0, %o1 2006c38: 90 12 22 34 or %o0, 0x234, %o0 2006c3c: 40 00 0b 56 call 2009994 <_Objects_Get> 2006c40: 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 ) { 2006c44: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c48: 80 a0 60 00 cmp %g1, 0 2006c4c: 12 80 00 15 bne 2006ca0 2006c50: a2 10 00 08 mov %o0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 2006c54: 25 00 80 7a sethi %hi(0x201e800), %l2 2006c58: c4 02 20 50 ld [ %o0 + 0x50 ], %g2 2006c5c: c2 04 a0 b0 ld [ %l2 + 0xb0 ], %g1 2006c60: 80 a0 80 01 cmp %g2, %g1 2006c64: 02 80 00 14 be 2006cb4 2006c68: 80 a6 60 00 cmp %i1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006c6c: 03 00 80 79 sethi %hi(0x201e400), %g1 2006c70: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201e7d0 <_Thread_Dispatch_disable_level> 2006c74: b0 10 20 17 mov 0x17, %i0 _Thread_Dispatch(); 2006c78: 84 00 bf ff add %g2, -1, %g2 2006c7c: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 2006c80: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 2006c84: 80 a0 e0 00 cmp %g3, 0 2006c88: 12 80 00 66 bne 2006e20 2006c8c: 01 00 00 00 nop 2006c90: 40 00 10 75 call 200ae64 <_Thread_Dispatch> 2006c94: 01 00 00 00 nop 2006c98: 81 c7 e0 08 ret 2006c9c: 81 e8 00 00 restore rtems_status_code return_value; rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 2006ca0: 80 a0 60 02 cmp %g1, 2 2006ca4: 02 bf ff fd be 2006c98 2006ca8: b0 10 20 04 mov 4, %i0 break; } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006cac: 81 c7 e0 08 ret <== NOT EXECUTED 2006cb0: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 2006cb4: 22 80 00 73 be,a 2006e80 2006cb8: d0 02 20 38 ld [ %o0 + 0x38 ], %o0 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 2006cbc: 7f ff ef 42 call 20029c4 2006cc0: 01 00 00 00 nop 2006cc4: a0 10 00 08 mov %o0, %l0 switch ( the_period->state ) { 2006cc8: e6 04 60 38 ld [ %l1 + 0x38 ], %l3 2006ccc: 80 a4 e0 02 cmp %l3, 2 2006cd0: 02 80 00 34 be 2006da0 2006cd4: 80 a4 e0 04 cmp %l3, 4 2006cd8: 02 80 00 54 be 2006e28 2006cdc: 80 a4 e0 00 cmp %l3, 0 2006ce0: 32 bf ff ee bne,a 2006c98 2006ce4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED /* * No need to update statistics -- there are not a period active */ _ISR_Enable( level ); 2006ce8: 7f ff ef 3b call 20029d4 2006cec: 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 ); 2006cf0: 40 00 07 db call 2008c5c <_TOD_Get_uptime> 2006cf4: 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; 2006cf8: c2 07 bf ec ld [ %fp + -20 ], %g1 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006cfc: c6 04 a0 b0 ld [ %l2 + 0xb0 ], %g3 #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; 2006d00: c2 24 60 44 st %g1, [ %l1 + 0x44 ] 2006d04: 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( 2006d08: 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; 2006d0c: c2 24 60 48 st %g1, [ %l1 + 0x48 ] #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006d10: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006d14: a0 07 bf e4 add %fp, -28, %l0 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006d18: c4 24 60 3c st %g2, [ %l1 + 0x3c ] 2006d1c: c2 00 e0 94 ld [ %g3 + 0x94 ], %g1 _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006d20: 94 10 00 10 mov %l0, %o2 #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec ran; the_period->owner_executed_at_period = 2006d24: c2 24 60 40 st %g1, [ %l1 + 0x40 ] _Thread_Executing->cpu_time_used; /* How much time time since last context switch */ _Timespec_Subtract( 2006d28: 11 00 80 7a sethi %hi(0x201e800), %o0 2006d2c: 40 00 15 37 call 200c208 <_Timespec_Subtract> 2006d30: 90 12 20 b8 or %o0, 0xb8, %o0 ! 201e8b8 <_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 ); 2006d34: 92 10 00 10 mov %l0, %o1 2006d38: 40 00 14 d1 call 200c07c <_Timespec_Add_to> 2006d3c: 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; 2006d40: 84 10 20 02 mov 2, %g2 Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006d44: 03 00 80 1c sethi %hi(0x2007000), %g1 2006d48: 82 10 62 54 or %g1, 0x254, %g1 ! 2007254 <_Rate_monotonic_Timeout> the_watchdog->id = id; 2006d4c: f0 24 60 30 st %i0, [ %l1 + 0x30 ] Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006d50: f2 24 60 1c st %i1, [ %l1 + 0x1c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2006d54: c0 24 60 18 clr [ %l1 + 0x18 ] the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2006d58: c0 24 60 34 clr [ %l1 + 0x34 ] _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 2006d5c: f2 24 60 4c st %i1, [ %l1 + 0x4c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006d60: 92 04 60 10 add %l1, 0x10, %o1 #else the_period->owner_ticks_executed_at_period = _Thread_Executing->ticks_executed; #endif the_period->state = RATE_MONOTONIC_ACTIVE; 2006d64: c4 24 60 38 st %g2, [ %l1 + 0x38 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2006d68: c2 24 60 2c st %g1, [ %l1 + 0x2c ] ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006d6c: 11 00 80 7a sethi %hi(0x201e800), %o0 2006d70: 40 00 15 f1 call 200c534 <_Watchdog_Insert> 2006d74: 90 12 20 d0 or %o0, 0xd0, %o0 ! 201e8d0 <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006d78: 05 00 80 79 sethi %hi(0x201e400), %g2 2006d7c: c2 00 a3 d0 ld [ %g2 + 0x3d0 ], %g1 ! 201e7d0 <_Thread_Dispatch_disable_level> 2006d80: 82 00 7f ff add %g1, -1, %g1 2006d84: c2 20 a3 d0 st %g1, [ %g2 + 0x3d0 ] 2006d88: c6 00 a3 d0 ld [ %g2 + 0x3d0 ], %g3 2006d8c: 80 a0 e0 00 cmp %g3, 0 2006d90: 02 80 00 22 be 2006e18 2006d94: 01 00 00 00 nop _Thread_Dispatch(); 2006d98: 81 c7 e0 08 ret <== NOT EXECUTED 2006d9c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006da0: 7f ff ff 43 call 2006aac <_Rate_monotonic_Update_statistics> 2006da4: 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; 2006da8: 82 10 20 01 mov 1, %g1 the_period->next_length = length; 2006dac: 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; 2006db0: c2 24 60 38 st %g1, [ %l1 + 0x38 ] the_period->next_length = length; _ISR_Enable( level ); 2006db4: 7f ff ef 08 call 20029d4 2006db8: 90 10 00 10 mov %l0, %o0 _Thread_Executing->Wait.id = the_period->Object.id; 2006dbc: c2 04 a0 b0 ld [ %l2 + 0xb0 ], %g1 2006dc0: c4 04 60 08 ld [ %l1 + 8 ], %g2 _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006dc4: 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; 2006dc8: c4 20 60 20 st %g2, [ %g1 + 0x20 ] _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006dcc: 40 00 13 75 call 200bba0 <_Thread_Set_state> 2006dd0: 13 00 00 10 sethi %hi(0x4000), %o1 /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 2006dd4: 7f ff ee fc call 20029c4 2006dd8: 01 00 00 00 nop local_state = the_period->state; 2006ddc: e0 04 60 38 ld [ %l1 + 0x38 ], %l0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006de0: e6 24 60 38 st %l3, [ %l1 + 0x38 ] _ISR_Enable( level ); 2006de4: 7f ff ee fc call 20029d4 2006de8: 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 ) 2006dec: 80 a4 20 03 cmp %l0, 3 2006df0: 02 80 00 32 be 2006eb8 2006df4: d0 04 a0 b0 ld [ %l2 + 0xb0 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006df8: 03 00 80 79 sethi %hi(0x201e400), %g1 2006dfc: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201e7d0 <_Thread_Dispatch_disable_level> 2006e00: 84 00 bf ff add %g2, -1, %g2 2006e04: c4 20 63 d0 st %g2, [ %g1 + 0x3d0 ] 2006e08: c6 00 63 d0 ld [ %g1 + 0x3d0 ], %g3 2006e0c: 80 a0 e0 00 cmp %g3, 0 2006e10: 12 bf ff e2 bne 2006d98 2006e14: 01 00 00 00 nop _Thread_Dispatch(); 2006e18: 40 00 10 13 call 200ae64 <_Thread_Dispatch> 2006e1c: b0 10 20 00 clr %i0 ! 0 2006e20: 81 c7 e0 08 ret 2006e24: 81 e8 00 00 restore case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 2006e28: 7f ff ff 21 call 2006aac <_Rate_monotonic_Update_statistics> 2006e2c: 90 10 00 11 mov %l1, %o0 _ISR_Enable( level ); 2006e30: 7f ff ee e9 call 20029d4 2006e34: 90 10 00 10 mov %l0, %o0 the_period->state = RATE_MONOTONIC_ACTIVE; 2006e38: 82 10 20 02 mov 2, %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2006e3c: f2 24 60 1c st %i1, [ %l1 + 0x1c ] the_period->next_length = length; 2006e40: f2 24 60 4c st %i1, [ %l1 + 0x4c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2006e44: 92 04 60 10 add %l1, 0x10, %o1 */ _Rate_monotonic_Update_statistics( the_period ); _ISR_Enable( level ); the_period->state = RATE_MONOTONIC_ACTIVE; 2006e48: c2 24 60 38 st %g1, [ %l1 + 0x38 ] 2006e4c: 11 00 80 7a sethi %hi(0x201e800), %o0 2006e50: 40 00 15 b9 call 200c534 <_Watchdog_Insert> 2006e54: 90 12 20 d0 or %o0, 0xd0, %o0 ! 201e8d0 <_Watchdog_Ticks_chain> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2006e58: 07 00 80 79 sethi %hi(0x201e400), %g3 2006e5c: c2 00 e3 d0 ld [ %g3 + 0x3d0 ], %g1 ! 201e7d0 <_Thread_Dispatch_disable_level> 2006e60: b0 10 20 06 mov 6, %i0 2006e64: 82 00 7f ff add %g1, -1, %g1 2006e68: c2 20 e3 d0 st %g1, [ %g3 + 0x3d0 ] 2006e6c: c4 00 e3 d0 ld [ %g3 + 0x3d0 ], %g2 2006e70: 80 a0 a0 00 cmp %g2, 0 2006e74: 02 bf ff 87 be 2006c90 2006e78: 01 00 00 00 nop 2006e7c: 30 bf ff e9 b,a 2006e20 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 2006e80: 80 a2 20 02 cmp %o0, 2 2006e84: 02 80 00 09 be 2006ea8 2006e88: b0 10 20 00 clr %i0 2006e8c: 80 a2 20 04 cmp %o0, 4 2006e90: 02 80 00 06 be 2006ea8 2006e94: b0 10 20 06 mov 6, %i0 2006e98: 80 a2 20 00 cmp %o0, 0 2006e9c: 02 80 00 03 be 2006ea8 2006ea0: b0 10 20 0b mov 0xb, %i0 2006ea4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2006ea8: 03 00 80 79 sethi %hi(0x201e400), %g1 2006eac: c4 00 63 d0 ld [ %g1 + 0x3d0 ], %g2 ! 201e7d0 <_Thread_Dispatch_disable_level> 2006eb0: 10 bf ff 73 b 2006c7c 2006eb4: 84 00 bf ff add %g2, -1, %g2 * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 2006eb8: 40 00 0f 2a call 200ab60 <_Thread_Clear_state> <== NOT EXECUTED 2006ebc: 13 00 00 10 sethi %hi(0x4000), %o1 <== NOT EXECUTED 2006ec0: 30 bf ff ce b,a 2006df8 <== NOT EXECUTED 02006ec4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 2006ec4: 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 ) 2006ec8: 80 a6 60 00 cmp %i1, 0 2006ecc: 02 80 00 4e be 2007004 2006ed0: 90 10 00 18 mov %i0, %o0 return; (*print)( context, "Period information by period\n" ); 2006ed4: 13 00 80 6f sethi %hi(0x201bc00), %o1 2006ed8: 9f c6 40 00 call %i1 2006edc: 92 12 60 60 or %o1, 0x60, %o1 ! 201bc60 #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 2006ee0: 90 10 00 18 mov %i0, %o0 2006ee4: 13 00 80 6f sethi %hi(0x201bc00), %o1 2006ee8: 9f c6 40 00 call %i1 2006eec: 92 12 60 80 or %o1, 0x80, %o1 ! 201bc80 #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 2006ef0: 90 10 00 18 mov %i0, %o0 2006ef4: 13 00 80 6f sethi %hi(0x201bc00), %o1 2006ef8: 9f c6 40 00 call %i1 2006efc: 92 12 60 a8 or %o1, 0xa8, %o1 ! 201bca8 Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 2006f00: 90 10 00 18 mov %i0, %o0 2006f04: 13 00 80 6f sethi %hi(0x201bc00), %o1 2006f08: 9f c6 40 00 call %i1 2006f0c: 92 12 60 d0 or %o1, 0xd0, %o1 ! 201bcd0 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 2006f10: 90 10 00 18 mov %i0, %o0 2006f14: 13 00 80 6f sethi %hi(0x201bc00), %o1 2006f18: 9f c6 40 00 call %i1 2006f1c: 92 12 61 20 or %o1, 0x120, %o1 ! 201bd20 /* * 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 ; 2006f20: 03 00 80 79 sethi %hi(0x201e400), %g1 2006f24: a6 10 62 34 or %g1, 0x234, %l3 ! 201e634 <_Rate_monotonic_Information> 2006f28: e4 04 e0 08 ld [ %l3 + 8 ], %l2 id <= _Rate_monotonic_Information.maximum_id ; 2006f2c: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 2006f30: 80 a4 80 01 cmp %l2, %g1 2006f34: 18 80 00 34 bgu 2007004 2006f38: 03 00 80 6f sethi %hi(0x201bc00), %g1 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006f3c: 05 00 80 6f sethi %hi(0x201bc00), %g2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006f40: b6 10 61 70 or %g1, 0x170, %i3 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { (*print)( context, "\n" ); 2006f44: b8 10 a0 a0 or %g2, 0xa0, %i4 2006f48: a8 07 bf 98 add %fp, -104, %l4 status = rtems_rate_monotonic_get_statistics( id, &the_stats ); if ( status != RTEMS_SUCCESSFUL ) continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006f4c: aa 07 bf d0 add %fp, -48, %l5 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006f50: ba 07 bf b0 add %fp, -80, %i5 2006f54: ac 07 bf e8 add %fp, -24, %l6 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 2006f58: b4 07 bf c8 add %fp, -56, %i2 2006f5c: 10 80 00 06 b 2006f74 2006f60: ae 07 bf f3 add %fp, -13, %l7 * 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++ ) { 2006f64: 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 ; 2006f68: 80 a0 40 12 cmp %g1, %l2 2006f6c: 0a 80 00 26 bcs 2007004 2006f70: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 2006f74: 90 10 00 12 mov %l2, %o0 2006f78: 40 00 20 22 call 200f000 2006f7c: 92 10 00 14 mov %l4, %o1 if ( status != RTEMS_SUCCESSFUL ) 2006f80: 80 a2 20 00 cmp %o0, 0 2006f84: 32 bf ff f8 bne,a 2006f64 2006f88: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 2006f8c: 92 10 00 15 mov %l5, %o1 2006f90: 40 00 20 42 call 200f098 2006f94: 90 10 00 12 mov %l2, %o0 if ( status != RTEMS_SUCCESSFUL ) 2006f98: 80 a2 20 00 cmp %o0, 0 2006f9c: 32 bf ff f2 bne,a 2006f64 2006fa0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED continue; name[ 0 ] = '\0'; if ( the_status.owner ) { 2006fa4: d0 07 bf d0 ld [ %fp + -48 ], %o0 /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); if ( status != RTEMS_SUCCESSFUL ) continue; name[ 0 ] = '\0'; 2006fa8: c0 2f bf f3 clrb [ %fp + -13 ] if ( the_status.owner ) { 2006fac: 80 a2 20 00 cmp %o0, 0 2006fb0: 12 80 00 4b bne 20070dc 2006fb4: a0 10 00 17 mov %l7, %l0 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 2006fb8: d8 1f bf 98 ldd [ %fp + -104 ], %o4 <== NOT EXECUTED 2006fbc: 94 10 00 12 mov %l2, %o2 2006fc0: 92 10 00 1b mov %i3, %o1 2006fc4: 96 10 00 10 mov %l0, %o3 2006fc8: 9f c6 40 00 call %i1 2006fcc: 90 10 00 18 mov %i0, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006fd0: c2 07 bf 98 ld [ %fp + -104 ], %g1 */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 2006fd4: 94 10 00 16 mov %l6, %o2 2006fd8: 90 10 00 1d mov %i5, %o0 /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 2006fdc: 80 a0 60 00 cmp %g1, 0 2006fe0: 12 80 00 0b bne 200700c 2006fe4: 92 10 00 1c mov %i4, %o1 (*print)( context, "\n" ); 2006fe8: 9f c6 40 00 call %i1 2006fec: 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 ; 2006ff0: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 id++ ) { 2006ff4: 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 ; 2006ff8: 80 a0 40 12 cmp %g1, %l2 2006ffc: 1a bf ff df bcc 2006f78 2007000: 90 10 00 12 mov %l2, %o0 2007004: 81 c7 e0 08 ret 2007008: 81 e8 00 00 restore */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 200700c: 40 00 14 36 call 200c0e4 <_Timespec_Divide_by_integer> 2007010: 92 10 00 01 mov %g1, %o1 &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 2007014: d0 07 bf a4 ld [ %fp + -92 ], %o0 2007018: 40 00 49 da call 2019780 <.div> 200701c: 92 10 23 e8 mov 0x3e8, %o1 2007020: a2 10 00 08 mov %o0, %l1 2007024: d0 07 bf ac ld [ %fp + -84 ], %o0 2007028: 40 00 49 d6 call 2019780 <.div> 200702c: 92 10 23 e8 mov 0x3e8, %o1 2007030: c2 07 bf e8 ld [ %fp + -24 ], %g1 2007034: a0 10 00 08 mov %o0, %l0 2007038: d0 07 bf ec ld [ %fp + -20 ], %o0 200703c: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 2007040: 40 00 49 d0 call 2019780 <.div> 2007044: 92 10 23 e8 mov 0x3e8, %o1 2007048: d8 07 bf a8 ld [ %fp + -88 ], %o4 200704c: d4 07 bf a0 ld [ %fp + -96 ], %o2 2007050: 96 10 00 11 mov %l1, %o3 2007054: 9a 10 00 10 mov %l0, %o5 2007058: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 200705c: 13 00 80 6f sethi %hi(0x201bc00), %o1 2007060: 90 10 00 18 mov %i0, %o0 2007064: 9f c6 40 00 call %i1 2007068: 92 12 61 88 or %o1, 0x188, %o1 * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 200706c: d2 07 bf 98 ld [ %fp + -104 ], %o1 2007070: 94 10 00 16 mov %l6, %o2 2007074: 40 00 14 1c call 200c0e4 <_Timespec_Divide_by_integer> 2007078: 90 10 00 1a mov %i2, %o0 &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 200707c: d0 07 bf bc ld [ %fp + -68 ], %o0 2007080: 40 00 49 c0 call 2019780 <.div> 2007084: 92 10 23 e8 mov 0x3e8, %o1 2007088: a2 10 00 08 mov %o0, %l1 200708c: d0 07 bf c4 ld [ %fp + -60 ], %o0 2007090: 40 00 49 bc call 2019780 <.div> 2007094: 92 10 23 e8 mov 0x3e8, %o1 2007098: c2 07 bf e8 ld [ %fp + -24 ], %g1 200709c: a0 10 00 08 mov %o0, %l0 20070a0: d0 07 bf ec ld [ %fp + -20 ], %o0 20070a4: c2 23 a0 5c st %g1, [ %sp + 0x5c ] 20070a8: 40 00 49 b6 call 2019780 <.div> 20070ac: 92 10 23 e8 mov 0x3e8, %o1 20070b0: d4 07 bf b8 ld [ %fp + -72 ], %o2 20070b4: d8 07 bf c0 ld [ %fp + -64 ], %o4 20070b8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] 20070bc: 96 10 00 11 mov %l1, %o3 20070c0: 9a 10 00 10 mov %l0, %o5 20070c4: 90 10 00 18 mov %i0, %o0 20070c8: 13 00 80 6f sethi %hi(0x201bc00), %o1 20070cc: 9f c6 40 00 call %i1 20070d0: 92 12 61 a8 or %o1, 0x1a8, %o1 ! 201bda8 /* * 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 ; 20070d4: 10 bf ff a4 b 2006f64 20070d8: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 continue; name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 20070dc: 92 10 20 05 mov 5, %o1 20070e0: 40 00 00 8f call 200731c 20070e4: 94 10 00 17 mov %l7, %o2 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 20070e8: 10 bf ff b5 b 2006fbc 20070ec: d8 1f bf 98 ldd [ %fp + -104 ], %o4 0200710c : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 200710c: 9d e3 bf 98 save %sp, -104, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007110: 25 00 80 79 sethi %hi(0x201e400), %l2 2007114: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 ! 201e7d0 <_Thread_Dispatch_disable_level> 2007118: 82 00 60 01 inc %g1 200711c: c2 24 a3 d0 st %g1, [ %l2 + 0x3d0 ] /* * 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 ; 2007120: 03 00 80 79 sethi %hi(0x201e400), %g1 2007124: a2 10 62 34 or %g1, 0x234, %l1 ! 201e634 <_Rate_monotonic_Information> 2007128: e0 04 60 08 ld [ %l1 + 8 ], %l0 id <= _Rate_monotonic_Information.maximum_id ; 200712c: c2 04 60 0c ld [ %l1 + 0xc ], %g1 2007130: 80 a4 00 01 cmp %l0, %g1 2007134: 18 80 00 09 bgu 2007158 2007138: 01 00 00 00 nop id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 200713c: 40 00 00 13 call 2007188 2007140: 90 10 00 10 mov %l0, %o0 /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 2007144: c2 04 60 0c ld [ %l1 + 0xc ], %g1 id++ ) { 2007148: 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 ; 200714c: 80 a0 40 10 cmp %g1, %l0 2007150: 1a bf ff fb bcc 200713c 2007154: 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 ) 2007158: c2 04 a3 d0 ld [ %l2 + 0x3d0 ], %g1 200715c: 82 00 7f ff add %g1, -1, %g1 2007160: c2 24 a3 d0 st %g1, [ %l2 + 0x3d0 ] 2007164: c4 04 a3 d0 ld [ %l2 + 0x3d0 ], %g2 2007168: 80 a0 a0 00 cmp %g2, 0 200716c: 02 80 00 04 be 200717c 2007170: 01 00 00 00 nop 2007174: 81 c7 e0 08 ret <== NOT EXECUTED 2007178: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200717c: 40 00 0f 3a call 200ae64 <_Thread_Dispatch> 2007180: 81 e8 00 00 restore 2007184: 01 00 00 00 nop 02010170 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 2010170: 9d e3 bf 98 save %sp, -104, %sp Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 2010174: a8 96 20 00 orcc %i0, 0, %l4 2010178: 02 80 00 58 be 20102d8 201017c: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !starting_address ) 2010180: 80 a6 60 00 cmp %i1, 0 2010184: 02 80 00 06 be 201019c 2010188: 80 a7 60 00 cmp %i5, 0 return RTEMS_INVALID_ADDRESS; if ( !id ) 201018c: 02 80 00 04 be 201019c 2010190: 80 8e 60 07 btst 7, %i1 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 2010194: 02 80 00 04 be 20101a4 2010198: 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 ) _Thread_Dispatch(); 201019c: 81 c7 e0 08 ret 20101a0: 91 e8 20 09 restore %g0, 9, %o0 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 20101a4: 7f ff ea 5e call 200ab1c 20101a8: 01 00 00 00 nop 20101ac: a2 10 00 08 mov %o0, %l1 20101b0: 25 00 80 ce sethi %hi(0x2033800), %l2 20101b4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 20101b8: 80 a0 60 00 cmp %g1, 0 20101bc: 02 80 00 0b be 20101e8 20101c0: 03 00 80 ce sethi %hi(0x2033800), %g1 20101c4: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 20101c8: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2033b40 <_System_state_Current> <== NOT EXECUTED 20101cc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20101d0: 08 80 00 05 bleu 20101e4 <== NOT EXECUTED 20101d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20101d8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20101dc: 40 00 13 7c call 2014fcc <_Internal_error_Occurred> <== NOT EXECUTED 20101e0: 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; 20101e4: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 20101e8: 27 00 80 ce sethi %hi(0x2033800), %l3 20101ec: c6 00 62 40 ld [ %g1 + 0x240 ], %g3 20101f0: e0 04 e2 38 ld [ %l3 + 0x238 ], %l0 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20101f4: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20101f8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20101fc: 80 a0 60 00 cmp %g1, 0 2010200: 22 80 00 12 be,a 2010248 2010204: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010208: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 201020c: c2 00 e0 08 ld [ %g3 + 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; 2010210: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 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; 2010214: 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; 2010218: 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; 201021c: c6 24 20 6c st %g3, [ %l0 + 0x6c ] the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2010220: 80 a0 a0 02 cmp %g2, 2 2010224: 12 80 00 2f bne 20102e0 2010228: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 201022c: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2010230: 82 00 60 01 inc %g1 2010234: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2010238: 7f ff ea 3d call 200ab2c 201023c: 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 ); 2010240: 10 80 00 0f b 201027c 2010244: 23 00 80 cd sethi %hi(0x2033400), %l1 /* * 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 ) ) { 2010248: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 201024c: 32 80 00 48 bne,a 201036c <== NOT EXECUTED 2010250: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010254: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010258: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201025c: 12 80 00 41 bne 2010360 <== NOT EXECUTED 2010260: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010264: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010268: 82 00 60 01 inc %g1 <== NOT EXECUTED 201026c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010270: 7f ff ea 2f call 200ab2c <== NOT EXECUTED 2010274: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010278: 23 00 80 cd sethi %hi(0x2033400), %l1 <== NOT EXECUTED 201027c: 40 00 13 81 call 2015080 <_Objects_Allocate> 2010280: 90 14 63 7c or %l1, 0x37c, %o0 ! 203377c <_Region_Information> the_region = _Region_Allocate(); if ( !the_region ) { 2010284: a0 92 20 00 orcc %o0, 0, %l0 2010288: 32 80 00 4e bne,a 20103c0 201028c: 90 04 20 68 add %l0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010290: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 2010294: 82 00 60 01 inc %g1 2010298: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] _RTEMS_Unlock_allocator(); 201029c: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 20102a0: 94 10 20 00 clr %o2 20102a4: d2 02 20 08 ld [ %o0 + 8 ], %o1 20102a8: 40 00 10 d0 call 20145e8 <_CORE_mutex_Surrender> 20102ac: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20102b0: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20102b4: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 20102b8: 82 00 7f ff add %g1, -1, %g1 20102bc: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] 20102c0: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 20102c4: 80 a0 a0 00 cmp %g2, 0 20102c8: 12 80 00 04 bne 20102d8 20102cc: 01 00 00 00 nop 20102d0: 40 00 1a 05 call 2016ae4 <_Thread_Dispatch> 20102d4: 01 00 00 00 nop 20102d8: 81 c7 e0 08 ret 20102dc: 81 e8 00 00 restore 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20102e0: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 20102e4: 12 bf ff d5 bne 2010238 <== NOT EXECUTED 20102e8: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20102ec: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 20102f0: c4 00 e0 14 ld [ %g3 + 0x14 ], %g2 <== NOT EXECUTED 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++; 20102f4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20102f8: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20102fc: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED current = executing->current_priority; if ( current == ceiling ) { 2010300: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2010304: 02 80 00 4e be 201043c <== NOT EXECUTED 2010308: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 201030c: 1a 80 00 42 bcc 2010414 <== NOT EXECUTED 2010310: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010314: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 2010318: 82 00 60 01 inc %g1 <== NOT EXECUTED 201031c: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010320: 7f ff ea 03 call 200ab2c <== NOT EXECUTED 2010324: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010328: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 201032c: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010330: 40 00 18 bd call 2016624 <_Thread_Change_priority> <== NOT EXECUTED 2010334: 94 10 20 00 clr %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 ) 2010338: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 201033c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010340: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED 2010344: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 <== NOT EXECUTED 2010348: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201034c: 12 bf ff cc bne 201027c <== NOT EXECUTED 2010350: 23 00 80 cd sethi %hi(0x2033400), %l1 <== NOT EXECUTED _Thread_Dispatch(); 2010354: 40 00 19 e4 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2010358: 01 00 00 00 nop <== NOT EXECUTED 201035c: 30 bf ff c8 b,a 201027c <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010360: 02 80 00 13 be 20103ac <== NOT EXECUTED 2010364: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010368: c4 04 20 08 ld [ %l0 + 8 ], %g2 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201036c: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 2010370: c4 20 e0 20 st %g2, [ %g3 + 0x20 ] <== NOT EXECUTED 2010374: 82 00 60 01 inc %g1 <== 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; 2010378: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED 201037c: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED 2010380: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED 2010384: 82 04 20 10 add %l0, 0x10, %g1 <== NOT EXECUTED 2010388: c2 20 e0 44 st %g1, [ %g3 + 0x44 ] <== NOT EXECUTED 201038c: 7f ff e9 e8 call 200ab2c <== NOT EXECUTED 2010390: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010394: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 2010398: 92 10 20 00 clr %o1 <== NOT EXECUTED 201039c: 40 00 10 6f call 2014558 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 20103a0: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 20103a4: 10 bf ff b6 b 201027c <== NOT EXECUTED 20103a8: 23 00 80 cd sethi %hi(0x2033400), %l1 <== 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; 20103ac: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20103b0: 7f ff e9 df call 200ab2c <== NOT EXECUTED 20103b4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20103b8: 10 bf ff b1 b 201027c <== NOT EXECUTED 20103bc: 23 00 80 cd sethi %hi(0x2033400), %l1 <== NOT EXECUTED if ( !the_region ) { _RTEMS_Unlock_allocator(); return RTEMS_TOO_MANY; } the_region->maximum_segment_size = 20103c0: 92 10 00 19 mov %i1, %o1 20103c4: 94 10 00 1a mov %i2, %o2 20103c8: 40 00 12 b4 call 2014e98 <_Heap_Initialize> 20103cc: 96 10 00 1b mov %i3, %o3 _Heap_Initialize(&the_region->Memory, starting_address, length, page_size); if ( !the_region->maximum_segment_size ) { 20103d0: 80 a2 20 00 cmp %o0, 0 20103d4: 12 80 00 1e bne 201044c 20103d8: 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 ); 20103dc: 90 14 63 7c or %l1, 0x37c, %o0 20103e0: 40 00 14 36 call 20154b8 <_Objects_Free> 20103e4: 92 10 00 10 mov %l0, %o1 20103e8: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20103ec: 82 00 60 01 inc %g1 20103f0: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 20103f4: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 20103f8: 94 10 20 00 clr %o2 20103fc: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010400: 40 00 10 7a call 20145e8 <_CORE_mutex_Surrender> 2010404: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010408: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 201040c: 10 bf ff ab b 20102b8 2010410: b0 10 20 08 mov 8, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010414: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010418: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 201041c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010420: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 2010424: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010428: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 201042c: 7f ff e9 c0 call 200ab2c <== NOT EXECUTED 2010430: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED * the inactive chain of free region control blocks. */ RTEMS_INLINE_ROUTINE Region_Control *_Region_Allocate( void ) { return (Region_Control *) _Objects_Allocate( &_Region_Information ); 2010434: 10 bf ff 92 b 201027c <== NOT EXECUTED 2010438: 23 00 80 cd sethi %hi(0x2033400), %l1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 201043c: 7f ff e9 bc call 200ab2c <== NOT EXECUTED 2010440: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010444: 10 bf ff 8e b 201027c <== NOT EXECUTED 2010448: 23 00 80 cd sethi %hi(0x2033400), %l1 <== NOT EXECUTED 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( 201044c: 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; 2010450: f2 24 20 50 st %i1, [ %l0 + 0x50 ] the_region->length = length; 2010454: f4 24 20 54 st %i2, [ %l0 + 0x54 ] the_region->page_size = page_size; 2010458: f6 24 20 58 st %i3, [ %l0 + 0x58 ] the_region->attribute_set = attribute_set; 201045c: f8 24 20 60 st %i4, [ %l0 + 0x60 ] the_region->number_of_used_blocks = 0; 2010460: c0 24 20 64 clr [ %l0 + 0x64 ] _Thread_queue_Initialize( 2010464: 93 37 20 02 srl %i4, 2, %o1 2010468: 94 10 20 40 mov 0x40, %o2 201046c: 92 0a 60 01 and %o1, 1, %o1 2010470: 40 00 1c 44 call 2017580 <_Thread_queue_Initialize> 2010474: 96 10 20 06 mov 6, %o3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2010478: 90 14 63 7c or %l1, 0x37c, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 201047c: c6 04 20 08 ld [ %l0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2010480: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2010484: 03 00 00 3f sethi %hi(0xfc00), %g1 2010488: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 201048c: 82 08 c0 01 and %g3, %g1, %g1 2010490: 80 a0 40 02 cmp %g1, %g2 2010494: 38 80 00 06 bgu,a 20104ac 2010498: c6 27 40 00 st %g3, [ %i5 ] <== NOT EXECUTED information->local_table[ index ] = the_object; 201049c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 20104a0: 83 28 60 02 sll %g1, 2, %g1 20104a4: e0 20 80 01 st %l0, [ %g2 + %g1 ] &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 20104a8: c6 27 40 00 st %g3, [ %i5 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20104ac: c2 04 a1 60 ld [ %l2 + 0x160 ], %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; 20104b0: e8 24 20 0c st %l4, [ %l0 + 0xc ] 20104b4: 82 00 60 01 inc %g1 20104b8: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] _RTEMS_Unlock_allocator(); 20104bc: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 20104c0: 94 10 20 00 clr %o2 20104c4: d2 02 20 08 ld [ %o0 + 8 ], %o1 20104c8: 40 00 10 48 call 20145e8 <_CORE_mutex_Surrender> 20104cc: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20104d0: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20104d4: 10 bf ff 79 b 20102b8 20104d8: b0 10 20 00 clr %i0 020104dc : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 20104dc: 9d e3 bf 90 save %sp, -112, %sp register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 20104e0: 7f ff e9 8f call 200ab1c 20104e4: 01 00 00 00 nop 20104e8: a2 10 00 08 mov %o0, %l1 20104ec: 25 00 80 ce sethi %hi(0x2033800), %l2 20104f0: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 20104f4: 80 a0 60 00 cmp %g1, 0 20104f8: 02 80 00 0b be 2010524 20104fc: 27 00 80 ce sethi %hi(0x2033800), %l3 2010500: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2010504: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2033b40 <_System_state_Current> <== NOT EXECUTED 2010508: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 201050c: 08 80 00 06 bleu 2010524 <== NOT EXECUTED 2010510: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010514: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010518: 40 00 12 ad call 2014fcc <_Internal_error_Occurred> <== NOT EXECUTED 201051c: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010520: 27 00 80 ce sethi %hi(0x2033800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010524: 09 00 80 ce sethi %hi(0x2033800), %g4 2010528: e0 04 e2 38 ld [ %l3 + 0x238 ], %l0 201052c: c4 01 22 40 ld [ %g4 + 0x240 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010530: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010534: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2010538: 80 a0 60 00 cmp %g1, 0 201053c: 22 80 00 36 be,a 2010614 2010540: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010544: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010548: 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; 201054c: 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; 2010550: 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; 2010554: 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; 2010558: 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 ) || 201055c: 80 a0 e0 02 cmp %g3, 2 2010560: 12 80 00 56 bne 20106b8 2010564: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2010568: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 201056c: 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++; 2010570: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010574: 02 80 00 7c be 2010764 2010578: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 201057c: 7f ff e9 6c call 200ab2c 2010580: 90 10 00 11 mov %l1, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010584: 92 10 00 18 mov %i0, %o1 2010588: 21 00 80 cd sethi %hi(0x2033400), %l0 201058c: 94 07 bf f4 add %fp, -12, %o2 2010590: 40 00 14 0d call 20155c4 <_Objects_Get_no_protection> 2010594: 90 14 23 7c or %l0, 0x37c, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010598: c2 07 bf f4 ld [ %fp + -12 ], %g1 201059c: 80 a0 60 01 cmp %g1, 1 20105a0: 02 80 00 33 be 201066c 20105a4: 92 10 00 08 mov %o0, %o1 20105a8: 80 a0 60 01 cmp %g1, 1 20105ac: 1a 80 00 5f bcc 2010728 20105b0: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { 20105b4: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 20105b8: 80 a0 60 00 cmp %g1, 0 20105bc: 22 80 00 99 be,a 2010820 20105c0: 90 14 23 7c or %l0, 0x37c, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20105c4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20105c8: 82 00 60 01 inc %g1 20105cc: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } _RTEMS_Unlock_allocator(); 20105d0: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 20105d4: 94 10 20 00 clr %o2 20105d8: d2 02 20 08 ld [ %o0 + 8 ], %o1 20105dc: 40 00 10 03 call 20145e8 <_CORE_mutex_Surrender> 20105e0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20105e4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20105e8: b0 10 20 0c mov 0xc, %i0 20105ec: 82 00 7f ff add %g1, -1, %g1 20105f0: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] 20105f4: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 20105f8: 80 a0 a0 00 cmp %g2, 0 20105fc: 12 80 00 49 bne 2010720 2010600: 01 00 00 00 nop _Thread_Dispatch(); 2010604: 40 00 19 38 call 2016ae4 <_Thread_Dispatch> 2010608: 01 00 00 00 nop 201060c: 81 c7 e0 08 ret 2010610: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2010614: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010618: 12 80 00 30 bne 20106d8 <== NOT EXECUTED 201061c: c6 04 e2 38 ld [ %l3 + 0x238 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010620: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010624: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010628: 22 80 00 6a be,a 20107d0 <== NOT EXECUTED 201062c: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010630: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010634: 12 80 00 29 bne 20106d8 <== NOT EXECUTED 2010638: 82 10 20 02 mov 2, %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; 201063c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010640: 7f ff e9 3b call 200ab2c <== NOT EXECUTED 2010644: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010648: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 201064c: 21 00 80 cd sethi %hi(0x2033400), %l0 <== NOT EXECUTED 2010650: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2010654: 40 00 13 dc call 20155c4 <_Objects_Get_no_protection> <== NOT EXECUTED 2010658: 90 14 23 7c or %l0, 0x37c, %o0 <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 201065c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010660: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010664: 12 bf ff d2 bne 20105ac <== NOT EXECUTED 2010668: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201066c: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 2010670: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010674: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010678: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 201067c: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010680: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010684: 40 00 0f d9 call 20145e8 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010688: 90 02 20 10 add %o0, 0x10, %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 ) 201068c: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 2010690: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010694: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED 2010698: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 <== NOT EXECUTED 201069c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20106a0: 12 80 00 24 bne 2010730 <== NOT EXECUTED 20106a4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20106a8: 40 00 19 0f call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 20106ac: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 20106b0: 81 c7 e0 08 ret <== NOT EXECUTED 20106b4: 81 e8 00 00 restore <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 20106b8: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 20106bc: 12 bf ff b0 bne 201057c <== NOT EXECUTED 20106c0: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20106c4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20106c8: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20106cc: 02 80 00 26 be 2010764 <== NOT EXECUTED 20106d0: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 20106d4: 30 bf ff aa b,a 201057c <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20106d8: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED ) { register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); 20106dc: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 20106e0: c8 01 22 40 ld [ %g4 + 0x240 ], %g4 <== NOT EXECUTED 20106e4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20106e8: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 20106ec: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED 20106f0: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 20106f4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 20106f8: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 20106fc: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010700: 7f ff e9 0b call 200ab2c <== NOT EXECUTED 2010704: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010708: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 201070c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010710: 40 00 0f 92 call 2014558 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010714: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010718: 10 bf ff 9c b 2010588 <== NOT EXECUTED 201071c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _RTEMS_Unlock_allocator(); return RTEMS_RESOURCE_IN_USE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2010720: 81 c7 e0 08 ret <== NOT EXECUTED 2010724: 81 e8 00 00 restore <== NOT EXECUTED register Region_Control *the_region; Objects_Locations location; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 2010728: 02 80 00 04 be 2010738 201072c: 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 ) _Thread_Dispatch(); 2010730: 81 c7 e0 08 ret <== NOT EXECUTED 2010734: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010738: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 201073c: 82 00 60 01 inc %g1 2010740: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010744: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 2010748: 94 10 20 00 clr %o2 201074c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010750: 40 00 0f a6 call 20145e8 <_CORE_mutex_Surrender> 2010754: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010758: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 201075c: 10 bf ff a4 b 20105ec 2010760: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010764: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2010768: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 201076c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010770: 02 80 00 28 be 2010810 <== NOT EXECUTED 2010774: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2010778: 1a 80 00 1c bcc 20107e8 <== NOT EXECUTED 201077c: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010780: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 2010784: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010788: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 201078c: 7f ff e8 e8 call 200ab2c <== NOT EXECUTED 2010790: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010794: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010798: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 201079c: 40 00 17 a2 call 2016624 <_Thread_Change_priority> <== NOT EXECUTED 20107a0: 94 10 20 00 clr %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 ) 20107a4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 <== NOT EXECUTED 20107a8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20107ac: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] <== NOT EXECUTED 20107b0: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 <== NOT EXECUTED 20107b4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20107b8: 32 bf ff 74 bne,a 2010588 <== NOT EXECUTED 20107bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 20107c0: 40 00 18 c9 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 20107c4: 01 00 00 00 nop <== NOT EXECUTED 20107c8: 10 bf ff 70 b 2010588 <== NOT EXECUTED 20107cc: 92 10 00 18 mov %i0, %o1 <== 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++; 20107d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20107d4: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 20107d8: 7f ff e8 d5 call 200ab2c <== NOT EXECUTED 20107dc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 20107e0: 10 bf ff 6a b 2010588 <== NOT EXECUTED 20107e4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 20107e8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 20107ec: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 20107f0: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 20107f4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20107f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20107fc: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010800: 7f ff e8 cb call 200ab2c <== NOT EXECUTED 2010804: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010808: 10 bf ff 60 b 2010588 <== NOT EXECUTED 201080c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010810: 7f ff e8 c7 call 200ab2c <== NOT EXECUTED 2010814: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2010818: 10 bf ff 5c b 2010588 <== NOT EXECUTED 201081c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2010820: c2 02 60 08 ld [ %o1 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2010824: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2010828: 05 00 00 3f sethi %hi(0xfc00), %g2 201082c: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2010830: 82 08 40 02 and %g1, %g2, %g1 2010834: 80 a0 40 03 cmp %g1, %g3 2010838: 18 80 00 05 bgu 201084c 201083c: 01 00 00 00 nop information->local_table[ index ] = the_object; 2010840: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2010844: 83 28 60 02 sll %g1, 2, %g1 2010848: c0 20 80 01 clr [ %g2 + %g1 ] RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 201084c: 40 00 13 1b call 20154b8 <_Objects_Free> 2010850: c0 22 60 0c clr [ %o1 + 0xc ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010854: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 2010858: 82 00 60 01 inc %g1 201085c: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks == 0 ) { _Objects_Close( &_Region_Information, &the_region->Object ); _Region_Free( the_region ); _RTEMS_Unlock_allocator(); 2010860: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 2010864: 94 10 20 00 clr %o2 2010868: d2 02 20 08 ld [ %o0 + 8 ], %o1 201086c: 40 00 0f 5f call 20145e8 <_CORE_mutex_Surrender> 2010870: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010874: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 2010878: 10 bf ff 5d b 20105ec 201087c: b0 10 20 00 clr %i0 02010880 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 2010880: 9d e3 bf 90 save %sp, -112, %sp 2010884: a8 10 00 18 mov %i0, %l4 Objects_Locations location; uint32_t amount_extended; Heap_Extend_status heap_status; rtems_status_code status; if ( !starting_address ) 2010888: 80 a6 60 00 cmp %i1, 0 201088c: 02 80 00 59 be 20109f0 2010890: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010894: 7f ff e8 a2 call 200ab1c 2010898: 01 00 00 00 nop 201089c: a4 10 00 08 mov %o0, %l2 20108a0: 23 00 80 ce sethi %hi(0x2033800), %l1 20108a4: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 20108a8: 80 a0 60 00 cmp %g1, 0 20108ac: 02 80 00 0b be 20108d8 20108b0: 27 00 80 ce sethi %hi(0x2033800), %l3 20108b4: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 20108b8: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2033b40 <_System_state_Current> <== NOT EXECUTED 20108bc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 20108c0: 08 80 00 06 bleu 20108d8 <== NOT EXECUTED 20108c4: 90 10 20 00 clr %o0 <== NOT EXECUTED 20108c8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20108cc: 40 00 11 c0 call 2014fcc <_Internal_error_Occurred> <== NOT EXECUTED 20108d0: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 20108d4: 27 00 80 ce sethi %hi(0x2033800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 20108d8: 09 00 80 ce sethi %hi(0x2033800), %g4 20108dc: e0 04 e2 38 ld [ %l3 + 0x238 ], %l0 20108e0: c4 01 22 40 ld [ %g4 + 0x240 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 20108e4: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 20108e8: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 20108ec: 80 a0 60 00 cmp %g1, 0 20108f0: 22 80 00 42 be,a 20109f8 20108f4: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 20108f8: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 20108fc: 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; 2010900: 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; 2010904: 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; 2010908: 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; 201090c: 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 ) || 2010910: 80 a0 e0 02 cmp %g3, 2 2010914: 02 80 00 61 be 2010a98 2010918: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 201091c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010920: 22 80 00 60 be,a 2010aa0 <== NOT EXECUTED 2010924: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2010928: 7f ff e8 81 call 200ab2c 201092c: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 2010930: 92 10 00 14 mov %l4, %o1 2010934: 11 00 80 cd sethi %hi(0x2033400), %o0 2010938: 94 07 bf f4 add %fp, -12, %o2 201093c: 40 00 13 22 call 20155c4 <_Objects_Get_no_protection> 2010940: 90 12 23 7c or %o0, 0x37c, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 2010944: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010948: 80 a0 60 01 cmp %g1, 1 201094c: 02 80 00 40 be 2010a4c 2010950: a0 10 00 08 mov %o0, %l0 2010954: 80 a0 60 01 cmp %g1, 1 2010958: 1a 80 00 70 bcc 2010b18 201095c: 80 a0 60 02 cmp %g1, 2 _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: heap_status = _Heap_Extend( 2010960: 92 10 00 19 mov %i1, %o1 2010964: 94 10 00 1a mov %i2, %o2 2010968: 90 02 20 68 add %o0, 0x68, %o0 201096c: 96 07 bf f0 add %fp, -16, %o3 2010970: 40 00 10 64 call 2014b00 <_Heap_Extend> 2010974: b0 10 20 09 mov 9, %i0 starting_address, length, &amount_extended ); switch ( heap_status ) { 2010978: 80 a2 20 01 cmp %o0, 1 201097c: 02 80 00 0c be 20109ac 2010980: 01 00 00 00 nop 2010984: 1a 80 00 8e bcc 2010bbc 2010988: 82 1a 20 02 xor %o0, 2, %g1 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 201098c: c6 07 bf f0 ld [ %fp + -16 ], %g3 2010990: c4 04 20 54 ld [ %l0 + 0x54 ], %g2 the_region->maximum_segment_size += amount_extended; 2010994: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 2010998: 84 00 80 03 add %g2, %g3, %g2 the_region->maximum_segment_size += amount_extended; 201099c: 82 00 40 03 add %g1, %g3, %g1 &amount_extended ); switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 20109a0: c4 24 20 54 st %g2, [ %l0 + 0x54 ] the_region->maximum_segment_size += amount_extended; 20109a4: c2 24 20 5c st %g1, [ %l0 + 0x5c ] 20109a8: b0 10 20 00 clr %i0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20109ac: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 20109b0: 82 00 60 01 inc %g1 20109b4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] break; case HEAP_EXTEND_NOT_IMPLEMENTED: status = RTEMS_NOT_IMPLEMENTED; break; } _RTEMS_Unlock_allocator(); 20109b8: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 20109bc: 94 10 20 00 clr %o2 20109c0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20109c4: 40 00 0f 09 call 20145e8 <_CORE_mutex_Surrender> 20109c8: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20109cc: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 20109d0: 82 00 7f ff add %g1, -1, %g1 20109d4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 20109d8: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 20109dc: 80 a0 a0 00 cmp %g2, 0 20109e0: 12 80 00 2c bne 2010a90 20109e4: 01 00 00 00 nop _Thread_Dispatch(); 20109e8: 40 00 18 3f call 2016ae4 <_Thread_Dispatch> 20109ec: 01 00 00 00 nop 20109f0: 81 c7 e0 08 ret 20109f4: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 20109f8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 20109fc: 12 80 00 4d bne 2010b30 <== NOT EXECUTED 2010a00: c6 04 e2 38 ld [ %l3 + 0x238 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010a04: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010a08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010a0c: 12 80 00 47 bne 2010b28 <== NOT EXECUTED 2010a10: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010a14: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010a18: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010a1c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010a20: 7f ff e8 43 call 200ab2c <== NOT EXECUTED 2010a24: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010a28: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 2010a2c: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED 2010a30: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 2010a34: 40 00 12 e4 call 20155c4 <_Objects_Get_no_protection> <== NOT EXECUTED 2010a38: 90 12 23 7c or %o0, 0x37c, %o0 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 2010a3c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010a40: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010a44: 12 bf ff c5 bne 2010958 <== NOT EXECUTED 2010a48: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010a4c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010a50: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010a54: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010a58: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 2010a5c: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010a60: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010a64: 40 00 0e e1 call 20145e8 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010a68: 90 02 20 10 add %o0, 0x10, %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 ) 2010a6c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010a70: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010a74: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010a78: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 2010a7c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010a80: 12 80 00 28 bne 2010b20 <== NOT EXECUTED 2010a84: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2010a88: 40 00 18 17 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2010a8c: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2010a90: 81 c7 e0 08 ret <== NOT EXECUTED 2010a94: 81 e8 00 00 restore <== NOT EXECUTED 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++; 2010a98: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010a9c: 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++; 2010aa0: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010aa4: 12 bf ff a1 bne 2010928 2010aa8: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010aac: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2010ab0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010ab4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010ab8: 02 80 00 50 be 2010bf8 <== NOT EXECUTED 2010abc: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2010ac0: 1a 80 00 44 bcc 2010bd0 <== NOT EXECUTED 2010ac4: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010ac8: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010acc: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010ad0: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010ad4: 7f ff e8 16 call 200ab2c <== NOT EXECUTED 2010ad8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010adc: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010ae0: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010ae4: 40 00 16 d0 call 2016624 <_Thread_Change_priority> <== NOT EXECUTED 2010ae8: 94 10 20 00 clr %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 ) 2010aec: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010af0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010af4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010af8: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 2010afc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010b00: 32 bf ff 8d bne,a 2010934 <== NOT EXECUTED 2010b04: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED _Thread_Dispatch(); 2010b08: 40 00 17 f7 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2010b0c: 01 00 00 00 nop <== NOT EXECUTED 2010b10: 10 bf ff 89 b 2010934 <== NOT EXECUTED 2010b14: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 2010b18: 02 80 00 18 be 2010b78 2010b1c: 01 00 00 00 nop 2010b20: 81 c7 e0 08 ret <== NOT EXECUTED 2010b24: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010b28: 02 80 00 1f be 2010ba4 <== NOT EXECUTED 2010b2c: c6 04 e2 38 ld [ %l3 + 0x238 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010b30: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED if ( !starting_address ) return RTEMS_INVALID_ADDRESS; status = RTEMS_SUCCESSFUL; _RTEMS_Lock_allocator(); /* to prevent deletion */ 2010b34: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2010b38: c8 01 22 40 ld [ %g4 + 0x240 ], %g4 <== NOT EXECUTED 2010b3c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010b40: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2010b44: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010b48: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2010b4c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2010b50: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2010b54: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010b58: 7f ff e7 f5 call 200ab2c <== NOT EXECUTED 2010b5c: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010b60: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 2010b64: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010b68: 40 00 0e 7c call 2014558 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010b6c: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 2010b70: 10 bf ff 71 b 2010934 <== NOT EXECUTED 2010b74: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 2010b78: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010b7c: 82 00 60 01 inc %g1 2010b80: c2 24 61 60 st %g1, [ %l1 + 0x160 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010b84: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 2010b88: 94 10 20 00 clr %o2 2010b8c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010b90: 40 00 0e 96 call 20145e8 <_CORE_mutex_Surrender> 2010b94: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010b98: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010b9c: 10 bf ff 8d b 20109d0 2010ba0: b0 10 20 04 mov 4, %i0 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; 2010ba4: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2010ba8: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010bac: 7f ff e7 e0 call 200ab2c <== NOT EXECUTED 2010bb0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010bb4: 10 bf ff 60 b 2010934 <== NOT EXECUTED 2010bb8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 2010bbc: 80 a0 00 01 cmp %g0, %g1 2010bc0: 84 60 20 00 subx %g0, 0, %g2 2010bc4: b0 08 bf e8 and %g2, -24, %i0 2010bc8: 10 bf ff 79 b 20109ac 2010bcc: b0 06 20 18 add %i0, 0x18, %i0 ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010bd0: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010bd4: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010bd8: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010bdc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010be0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010be4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010be8: 7f ff e7 d1 call 200ab2c <== NOT EXECUTED 2010bec: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010bf0: 10 bf ff 51 b 2010934 <== NOT EXECUTED 2010bf4: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010bf8: 7f ff e7 cd call 200ab2c <== NOT EXECUTED 2010bfc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010c00: 10 bf ff 4d b 2010934 <== NOT EXECUTED 2010c04: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED 02010c08 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 2010c08: 9d e3 bf 90 save %sp, -112, %sp 2010c0c: aa 10 00 18 mov %i0, %l5 register Region_Control *the_region; Objects_Locations location; Thread_Control *executing; void *the_segment; if ( !segment ) 2010c10: 80 a7 20 00 cmp %i4, 0 2010c14: 02 80 00 4e be 2010d4c 2010c18: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; *segment = NULL; if ( size == 0 ) 2010c1c: 80 a6 60 00 cmp %i1, 0 2010c20: 02 80 00 c8 be 2010f40 2010c24: c0 27 00 00 clr [ %i4 ] return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010c28: 7f ff e7 bd call 200ab1c 2010c2c: 01 00 00 00 nop 2010c30: a4 10 00 08 mov %o0, %l2 2010c34: 23 00 80 ce sethi %hi(0x2033800), %l1 2010c38: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 2010c3c: 80 a0 60 00 cmp %g1, 0 2010c40: 02 80 00 0b be 2010c6c 2010c44: 29 00 80 ce sethi %hi(0x2033800), %l4 2010c48: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2010c4c: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2033b40 <_System_state_Current> <== NOT EXECUTED 2010c50: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2010c54: 08 80 00 06 bleu 2010c6c <== NOT EXECUTED 2010c58: 90 10 20 00 clr %o0 <== NOT EXECUTED 2010c5c: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010c60: 40 00 10 db call 2014fcc <_Internal_error_Occurred> <== NOT EXECUTED 2010c64: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 2010c68: 29 00 80 ce sethi %hi(0x2033800), %l4 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2010c6c: 27 00 80 ce sethi %hi(0x2033800), %l3 2010c70: e0 05 22 38 ld [ %l4 + 0x238 ], %l0 2010c74: c4 04 e2 40 ld [ %l3 + 0x240 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2010c78: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2010c7c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2010c80: 80 a0 60 00 cmp %g1, 0 2010c84: 22 80 00 34 be,a 2010d54 2010c88: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2010c8c: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2010c90: 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; 2010c94: 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; 2010c98: 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; 2010c9c: 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; 2010ca0: 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 ) || 2010ca4: 80 a0 e0 02 cmp %g3, 2 2010ca8: 02 80 00 54 be 2010df8 2010cac: c8 24 20 64 st %g4, [ %l0 + 0x64 ] 2010cb0: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2010cb4: 22 80 00 53 be,a 2010e00 <== NOT EXECUTED 2010cb8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2010cbc: 7f ff e7 9c call 200ab2c 2010cc0: 90 10 00 12 mov %l2, %o0 executing = _Thread_Executing; 2010cc4: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 2010cc8: 11 00 80 cd sethi %hi(0x2033400), %o0 2010ccc: 92 10 00 15 mov %l5, %o1 2010cd0: 90 12 23 7c or %o0, 0x37c, %o0 2010cd4: 40 00 12 3c call 20155c4 <_Objects_Get_no_protection> 2010cd8: 94 07 bf f4 add %fp, -12, %o2 the_region = _Region_Get( id, &location ); switch ( location ) { 2010cdc: c2 07 bf f4 ld [ %fp + -12 ], %g1 2010ce0: 80 a0 60 01 cmp %g1, 1 2010ce4: 02 80 00 32 be 2010dac 2010ce8: a0 10 00 08 mov %o0, %l0 2010cec: 80 a0 60 01 cmp %g1, 1 2010cf0: 1a 80 00 62 bcc 2010e78 2010cf4: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) { 2010cf8: c2 02 20 5c ld [ %o0 + 0x5c ], %g1 2010cfc: 80 a6 40 01 cmp %i1, %g1 2010d00: 28 80 00 a0 bleu,a 2010f80 2010d04: 90 02 20 68 add %o0, 0x68, %o0 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010d08: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010d0c: 82 00 60 01 inc %g1 2010d10: c2 24 61 60 st %g1, [ %l1 + 0x160 ] _RTEMS_Unlock_allocator(); 2010d14: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 2010d18: 94 10 20 00 clr %o2 2010d1c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010d20: 40 00 0e 32 call 20145e8 <_CORE_mutex_Surrender> 2010d24: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010d28: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010d2c: 82 00 7f ff add %g1, -1, %g1 2010d30: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2010d34: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 2010d38: 80 a0 a0 00 cmp %g2, 0 2010d3c: 12 80 00 81 bne 2010f40 2010d40: 01 00 00 00 nop _Thread_Dispatch(); 2010d44: 40 00 17 68 call 2016ae4 <_Thread_Dispatch> 2010d48: b0 10 20 08 mov 8, %i0 ! 8 2010d4c: 81 c7 e0 08 ret 2010d50: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2010d54: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2010d58: 12 80 00 4e bne 2010e90 <== NOT EXECUTED 2010d5c: c6 05 22 38 ld [ %l4 + 0x238 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010d60: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2010d64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2010d68: 12 80 00 48 bne 2010e88 <== NOT EXECUTED 2010d6c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2010d70: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2010d74: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010d78: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2010d7c: 7f ff e7 6c call 200ab2c <== NOT EXECUTED 2010d80: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010d84: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010d88: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED 2010d8c: 90 12 23 7c or %o0, 0x37c, %o0 <== NOT EXECUTED 2010d90: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 2010d94: 40 00 12 0c call 20155c4 <_Objects_Get_no_protection> <== NOT EXECUTED 2010d98: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2010d9c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2010da0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2010da4: 12 bf ff d3 bne 2010cf0 <== NOT EXECUTED 2010da8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010dac: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010db0: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010db4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 2010db8: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 <== NOT EXECUTED 2010dbc: 94 10 20 00 clr %o2 <== NOT EXECUTED 2010dc0: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 2010dc4: 40 00 0e 09 call 20145e8 <_CORE_mutex_Surrender> <== NOT EXECUTED 2010dc8: 90 02 20 10 add %o0, 0x10, %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 ) 2010dcc: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010dd0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010dd4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010dd8: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 2010ddc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010de0: 12 80 00 28 bne 2010e80 <== NOT EXECUTED 2010de4: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2010de8: 40 00 17 3f call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2010dec: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2010df0: 81 c7 e0 08 ret <== NOT EXECUTED 2010df4: 81 e8 00 00 restore <== NOT EXECUTED 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++; 2010df8: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010dfc: 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++; 2010e00: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2010e04: 12 bf ff ae bne 2010cbc 2010e08: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2010e0c: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 2010e10: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2010e14: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2010e18: 02 80 00 56 be 2010f70 <== NOT EXECUTED 2010e1c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2010e20: 1a 80 00 4a bcc 2010f48 <== NOT EXECUTED 2010e24: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010e28: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010e2c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010e30: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2010e34: 7f ff e7 3e call 200ab2c <== NOT EXECUTED 2010e38: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 2010e3c: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 2010e40: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 2010e44: 40 00 15 f8 call 2016624 <_Thread_Change_priority> <== NOT EXECUTED 2010e48: 94 10 20 00 clr %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 ) 2010e4c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 2010e50: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010e54: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010e58: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 2010e5c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2010e60: 32 bf ff 9a bne,a 2010cc8 <== NOT EXECUTED 2010e64: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED _Thread_Dispatch(); 2010e68: 40 00 17 1f call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2010e6c: 01 00 00 00 nop <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010e70: 10 bf ff 96 b 2010cc8 <== NOT EXECUTED 2010e74: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2010e78: 02 80 00 18 be 2010ed8 2010e7c: 01 00 00 00 nop _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 2010e80: 81 c7 e0 08 ret <== NOT EXECUTED 2010e84: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2010e88: 02 80 00 28 be 2010f28 <== NOT EXECUTED 2010e8c: c6 05 22 38 ld [ %l4 + 0x238 ], %g3 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010e90: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 2010e94: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2010e98: c8 04 e2 40 ld [ %l3 + 0x240 ], %g4 <== NOT EXECUTED 2010e9c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2010ea0: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2010ea4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2010ea8: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2010eac: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2010eb0: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2010eb4: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2010eb8: 7f ff e7 1d call 200ab2c <== NOT EXECUTED 2010ebc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010ec0: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 <== NOT EXECUTED 2010ec4: 92 10 20 00 clr %o1 <== NOT EXECUTED 2010ec8: 40 00 0d a4 call 2014558 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2010ecc: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED executing = _Thread_Executing; 2010ed0: 10 bf ff 7e b 2010cc8 <== NOT EXECUTED 2010ed4: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED 2010ed8: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010edc: 82 00 60 01 inc %g1 2010ee0: c2 24 61 60 st %g1, [ %l1 + 0x160 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2010ee4: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 2010ee8: 94 10 20 00 clr %o2 2010eec: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010ef0: 40 00 0d be call 20145e8 <_CORE_mutex_Surrender> 2010ef4: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010ef8: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010efc: b0 10 20 04 mov 4, %i0 _Thread_Dispatch(); 2010f00: 82 00 7f ff add %g1, -1, %g1 2010f04: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2010f08: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 2010f0c: 80 a0 a0 00 cmp %g2, 0 2010f10: 12 80 00 6d bne 20110c4 2010f14: 01 00 00 00 nop 2010f18: 40 00 16 f3 call 2016ae4 <_Thread_Dispatch> 2010f1c: 01 00 00 00 nop 2010f20: 81 c7 e0 08 ret 2010f24: 81 e8 00 00 restore 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; 2010f28: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 2010f2c: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2010f30: 7f ff e6 ff call 200ab2c <== NOT EXECUTED 2010f34: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010f38: 10 bf ff 64 b 2010cc8 <== NOT EXECUTED 2010f3c: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 2010f40: 81 c7 e0 08 ret <== NOT EXECUTED 2010f44: 91 e8 20 08 restore %g0, 8, %o0 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2010f48: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2010f4c: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 2010f50: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2010f54: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2010f58: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2010f5c: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 2010f60: 7f ff e6 f3 call 200ab2c <== NOT EXECUTED 2010f64: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); executing = _Thread_Executing; 2010f68: 10 bf ff 58 b 2010cc8 <== NOT EXECUTED 2010f6c: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 2010f70: 7f ff e6 ef call 200ab2c <== NOT EXECUTED 2010f74: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2010f78: 10 bf ff 54 b 2010cc8 <== NOT EXECUTED 2010f7c: f0 04 e2 40 ld [ %l3 + 0x240 ], %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uint32_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 2010f80: 40 00 0e ae call 2014a38 <_Heap_Allocate> 2010f84: 92 10 00 19 mov %i1, %o1 the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 2010f88: a4 92 20 00 orcc %o0, 0, %l2 2010f8c: 02 80 00 17 be 2010fe8 2010f90: 80 8e a0 01 btst 1, %i2 the_region->number_of_used_blocks += 1; 2010f94: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010f98: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 2010f9c: 82 00 60 01 inc %g1 2010fa0: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2010fa4: 84 00 a0 01 inc %g2 2010fa8: c4 24 61 60 st %g2, [ %l1 + 0x160 ] _RTEMS_Unlock_allocator(); 2010fac: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 2010fb0: 94 10 20 00 clr %o2 2010fb4: d2 02 20 08 ld [ %o0 + 8 ], %o1 2010fb8: 40 00 0d 8c call 20145e8 <_CORE_mutex_Surrender> 2010fbc: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2010fc0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010fc4: 82 00 7f ff add %g1, -1, %g1 2010fc8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2010fcc: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 2010fd0: 80 a0 a0 00 cmp %g2, 0 2010fd4: 02 80 00 12 be 201101c 2010fd8: 01 00 00 00 nop *segment = the_segment; 2010fdc: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED 2010fe0: 81 c7 e0 08 ret 2010fe4: 91 e8 20 00 restore %g0, 0, %o0 return RTEMS_SUCCESSFUL; } if ( _Options_Is_no_wait( option_set ) ) { 2010fe8: 02 80 00 11 be 201102c 2010fec: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2010ff0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2010ff4: 82 00 60 01 inc %g1 2010ff8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] _RTEMS_Unlock_allocator(); 2010ffc: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 2011000: 94 10 20 00 clr %o2 2011004: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011008: 40 00 0d 78 call 20145e8 <_CORE_mutex_Surrender> 201100c: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011010: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011014: 10 bf ff bb b 2010f00 2011018: b0 10 20 0d mov 0xd, %i0 _Thread_Dispatch(); 201101c: 40 00 16 b2 call 2016ae4 <_Thread_Dispatch> 2011020: 01 00 00 00 nop _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { the_region->number_of_used_blocks += 1; _RTEMS_Unlock_allocator(); *segment = the_segment; 2011024: 10 bf ff ef b 2010fe0 2011028: e4 27 00 00 st %l2, [ %i4 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201102c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011030: 25 00 80 ce sethi %hi(0x2033800), %l2 2011034: 82 00 60 01 inc %g1 2011038: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 201103c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011040: 82 00 60 01 inc %g1 2011044: c2 24 61 60 st %g1, [ %l1 + 0x160 ] * 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(); 2011048: d0 05 22 38 ld [ %l4 + 0x238 ], %o0 201104c: 94 10 20 00 clr %o2 2011050: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011054: 40 00 0d 65 call 20145e8 <_CORE_mutex_Surrender> 2011058: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201105c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011060: 82 00 7f ff add %g1, -1, %g1 2011064: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2011068: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 201106c: 80 a0 a0 00 cmp %g2, 0 2011070: 02 80 00 17 be 20110cc 2011074: 01 00 00 00 nop 2011078: 82 10 20 01 mov 1, %g1 ! 1 executing->Wait.queue = &the_region->Wait_queue; 201107c: 90 04 20 10 add %l0, 0x10, %o0 executing->Wait.id = id; 2011080: ea 26 20 20 st %l5, [ %i0 + 0x20 ] executing->Wait.count = size; 2011084: f2 26 20 24 st %i1, [ %i0 + 0x24 ] executing->Wait.return_argument = segment; 2011088: 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 ); 201108c: 92 10 00 1b mov %i3, %o1 * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); executing->Wait.queue = &the_region->Wait_queue; 2011090: d0 26 20 44 st %o0, [ %i0 + 0x44 ] 2011094: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 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 ); 2011098: 15 00 80 5d sethi %hi(0x2017400), %o2 201109c: 40 00 18 2b call 2017148 <_Thread_queue_Enqueue_with_handler> 20110a0: 94 12 a2 88 or %o2, 0x288, %o2 ! 2017688 <_Thread_queue_Timeout> 20110a4: c2 04 a1 60 ld [ %l2 + 0x160 ], %g1 20110a8: 82 00 7f ff add %g1, -1, %g1 20110ac: c2 24 a1 60 st %g1, [ %l2 + 0x160 ] 20110b0: c4 04 a1 60 ld [ %l2 + 0x160 ], %g2 20110b4: 80 a0 a0 00 cmp %g2, 0 20110b8: 02 80 00 09 be 20110dc 20110bc: 01 00 00 00 nop _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 20110c0: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 <== NOT EXECUTED 20110c4: 81 c7 e0 08 ret <== NOT EXECUTED 20110c8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 20110cc: 40 00 16 86 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 20110d0: 01 00 00 00 nop <== NOT EXECUTED 20110d4: 10 bf ff ea b 201107c <== NOT EXECUTED 20110d8: 82 10 20 01 mov 1, %g1 ! 1 <== NOT EXECUTED 20110dc: 40 00 16 82 call 2016ae4 <_Thread_Dispatch> 20110e0: 01 00 00 00 nop 20110e4: f0 06 20 34 ld [ %i0 + 0x34 ], %i0 20110e8: 81 c7 e0 08 ret 20110ec: 81 e8 00 00 restore 02011128 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 2011128: 9d e3 bf 90 save %sp, -112, %sp #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 201112c: 7f ff e6 7c call 200ab1c 2011130: 01 00 00 00 nop 2011134: a4 10 00 08 mov %o0, %l2 2011138: 23 00 80 ce sethi %hi(0x2033800), %l1 201113c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 2011140: 80 a0 60 00 cmp %g1, 0 2011144: 02 80 00 0b be 2011170 2011148: 27 00 80 ce sethi %hi(0x2033800), %l3 201114c: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2011150: c4 00 63 40 ld [ %g1 + 0x340 ], %g2 ! 2033b40 <_System_state_Current> <== NOT EXECUTED 2011154: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED 2011158: 08 80 00 06 bleu 2011170 <== NOT EXECUTED 201115c: 90 10 20 00 clr %o0 <== NOT EXECUTED 2011160: 92 10 20 00 clr %o1 <== NOT EXECUTED 2011164: 40 00 0f 9a call 2014fcc <_Internal_error_Occurred> <== NOT EXECUTED 2011168: 94 10 20 12 mov 0x12, %o2 <== NOT EXECUTED 201116c: 27 00 80 ce sethi %hi(0x2033800), %l3 <== NOT EXECUTED Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2011170: 09 00 80 ce sethi %hi(0x2033800), %g4 2011174: e0 04 e2 38 ld [ %l3 + 0x238 ], %l0 2011178: c4 01 22 40 ld [ %g4 + 0x240 ], %g2 executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 201117c: c0 20 a0 34 clr [ %g2 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2011180: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 2011184: 80 a0 60 00 cmp %g1, 0 2011188: 22 80 00 38 be,a 2011268 201118c: c2 04 20 6c ld [ %l0 + 0x6c ], %g1 <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_LOCKED; 2011190: c0 24 20 60 clr [ %l0 + 0x60 ] the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; 2011194: 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; 2011198: 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; 201119c: 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; 20111a0: 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; 20111a4: 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 ) || 20111a8: 80 a0 e0 02 cmp %g3, 2 20111ac: 12 80 00 58 bne 201130c 20111b0: c8 24 20 64 st %g4, [ %l0 + 0x64 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 20111b4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20111b8: 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++; 20111bc: 82 00 60 01 inc %g1 if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 20111c0: 02 80 00 7c be 20113b0 20111c4: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] _ISR_Enable( level ); 20111c8: 7f ff e6 59 call 200ab2c 20111cc: 90 10 00 12 mov %l2, %o0 RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 20111d0: 92 10 00 18 mov %i0, %o1 20111d4: 11 00 80 cd sethi %hi(0x2033400), %o0 20111d8: 94 07 bf f4 add %fp, -12, %o2 20111dc: 40 00 10 fa call 20155c4 <_Objects_Get_no_protection> 20111e0: 90 12 23 7c or %o0, 0x37c, %o0 the_region = _Region_Get( id, &location ); switch ( location ) { 20111e4: c2 07 bf f4 ld [ %fp + -12 ], %g1 20111e8: 80 a0 60 01 cmp %g1, 1 20111ec: 02 80 00 35 be 20112c0 20111f0: a0 10 00 08 mov %o0, %l0 20111f4: 80 a0 60 01 cmp %g1, 1 20111f8: 1a 80 00 5f bcc 2011374 20111fc: 80 a0 60 02 cmp %g1, 2 RTEMS_INLINE_ROUTINE boolean _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 2011200: 92 10 00 19 mov %i1, %o1 2011204: 40 00 0e 72 call 2014bcc <_Heap_Free> 2011208: 90 02 20 68 add %o0, 0x68, %o0 status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) { 201120c: 80 a2 20 00 cmp %o0, 0 2011210: 32 80 00 97 bne,a 201146c 2011214: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011218: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 201121c: 82 00 60 01 inc %g1 2011220: c2 24 61 60 st %g1, [ %l1 + 0x160 ] _RTEMS_Unlock_allocator(); 2011224: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 2011228: 94 10 20 00 clr %o2 201122c: d2 02 20 08 ld [ %o0 + 8 ], %o1 2011230: 40 00 0c ee call 20145e8 <_CORE_mutex_Surrender> 2011234: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011238: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 201123c: b0 10 20 09 mov 9, %i0 2011240: 82 00 7f ff add %g1, -1, %g1 2011244: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2011248: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 201124c: 80 a0 a0 00 cmp %g2, 0 2011250: 12 80 00 8c bne 2011480 2011254: 01 00 00 00 nop _Thread_Dispatch(); 2011258: 40 00 16 23 call 2016ae4 <_Thread_Dispatch> 201125c: 01 00 00 00 nop 2011260: 81 c7 e0 08 ret 2011264: 81 e8 00 00 restore /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 2011268: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 201126c: 12 80 00 30 bne 201132c <== NOT EXECUTED 2011270: c6 04 e2 38 ld [ %l3 + 0x238 ], %g3 <== NOT EXECUTED switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2011274: c2 04 20 50 ld [ %l0 + 0x50 ], %g1 <== NOT EXECUTED 2011278: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201127c: 22 80 00 68 be,a 201141c <== NOT EXECUTED 2011280: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 <== NOT EXECUTED 2011284: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2011288: 12 80 00 29 bne 201132c <== NOT EXECUTED 201128c: 82 10 20 02 mov 2, %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; 2011290: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 2011294: 7f ff e6 26 call 200ab2c <== NOT EXECUTED 2011298: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Region_Control *_Region_Get ( Objects_Id id, Objects_Locations *location ) { return (Region_Control *) 201129c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 20112a0: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED 20112a4: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 20112a8: 40 00 10 c7 call 20155c4 <_Objects_Get_no_protection> <== NOT EXECUTED 20112ac: 90 12 23 7c or %o0, 0x37c, %o0 <== NOT EXECUTED #endif int status; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 20112b0: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 20112b4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 20112b8: 12 bf ff d0 bne 20111f8 <== NOT EXECUTED 20112bc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20112c0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 20112c4: 82 00 60 01 inc %g1 <== NOT EXECUTED 20112c8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); 20112cc: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 20112d0: 94 10 20 00 clr %o2 <== NOT EXECUTED 20112d4: d2 02 20 08 ld [ %o0 + 8 ], %o1 <== NOT EXECUTED 20112d8: 40 00 0c c4 call 20145e8 <_CORE_mutex_Surrender> <== NOT EXECUTED 20112dc: 90 02 20 10 add %o0, 0x10, %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 ) 20112e0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 20112e4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20112e8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 20112ec: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 20112f0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20112f4: 12 80 00 22 bne 201137c <== NOT EXECUTED 20112f8: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 20112fc: 40 00 15 fa call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2011300: b0 10 20 19 mov 0x19, %i0 ! 19 <== NOT EXECUTED 2011304: 81 c7 e0 08 ret <== NOT EXECUTED 2011308: 81 e8 00 00 restore <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 201130c: 80 a0 e0 03 cmp %g3, 3 <== NOT EXECUTED 2011310: 12 bf ff ae bne 20111c8 <== NOT EXECUTED 2011314: 01 00 00 00 nop <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2011318: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 201131c: 82 00 60 01 inc %g1 <== NOT EXECUTED if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2011320: 02 80 00 24 be 20113b0 <== NOT EXECUTED 2011324: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED 2011328: 30 bf ff a8 b,a 20111c8 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201132c: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED #ifdef RTEMS_REGION_FREE_SHRED_PATTERN uint32_t size; #endif int status; _RTEMS_Lock_allocator(); 2011330: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED 2011334: c8 01 22 40 ld [ %g4 + 0x240 ], %g4 <== NOT EXECUTED 2011338: 82 00 60 01 inc %g1 <== NOT EXECUTED 201133c: c4 21 20 20 st %g2, [ %g4 + 0x20 ] <== NOT EXECUTED 2011340: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 2011344: 84 00 e0 10 add %g3, 0x10, %g2 <== NOT EXECUTED 2011348: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 201134c: c4 21 20 44 st %g2, [ %g4 + 0x44 ] <== NOT EXECUTED 2011350: c2 20 e0 40 st %g1, [ %g3 + 0x40 ] <== NOT EXECUTED 2011354: 7f ff e5 f6 call 200ab2c <== NOT EXECUTED 2011358: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 201135c: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 <== NOT EXECUTED 2011360: 92 10 20 00 clr %o1 <== NOT EXECUTED 2011364: 40 00 0c 7d call 2014558 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 2011368: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED 201136c: 10 bf ff 9a b 20111d4 <== NOT EXECUTED 2011370: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 2011374: 02 80 00 04 be 2011384 2011378: 01 00 00 00 nop the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ return RTEMS_SUCCESSFUL; 201137c: 81 c7 e0 08 ret <== NOT EXECUTED 2011380: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED 2011384: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011388: 82 00 60 01 inc %g1 201138c: c2 24 61 60 st %g1, [ %l1 + 0x160 ] case OBJECTS_REMOTE: /* this error cannot be returned */ _RTEMS_Unlock_allocator(); return RTEMS_INTERNAL_ERROR; case OBJECTS_ERROR: _RTEMS_Unlock_allocator(); 2011390: d0 04 e2 38 ld [ %l3 + 0x238 ], %o0 2011394: 94 10 20 00 clr %o2 2011398: d2 02 20 08 ld [ %o0 + 8 ], %o1 201139c: 40 00 0c 93 call 20145e8 <_CORE_mutex_Surrender> 20113a0: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20113a4: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 20113a8: 10 bf ff a6 b 2011240 20113ac: b0 10 20 04 mov 4, %i0 */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 20113b0: c6 04 20 5c ld [ %l0 + 0x5c ], %g3 <== NOT EXECUTED current = executing->current_priority; 20113b4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 20113b8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 20113bc: 02 80 00 28 be 201145c <== NOT EXECUTED 20113c0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 20113c4: 1a 80 00 1c bcc 2011434 <== NOT EXECUTED 20113c8: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20113cc: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 20113d0: 82 00 60 01 inc %g1 <== NOT EXECUTED 20113d4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 20113d8: 7f ff e5 d5 call 200ab2c <== NOT EXECUTED 20113dc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED _Thread_Change_priority( 20113e0: d2 04 20 5c ld [ %l0 + 0x5c ], %o1 <== NOT EXECUTED 20113e4: d0 04 20 6c ld [ %l0 + 0x6c ], %o0 <== NOT EXECUTED 20113e8: 40 00 14 8f call 2016624 <_Thread_Change_priority> <== NOT EXECUTED 20113ec: 94 10 20 00 clr %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 ) 20113f0: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 <== NOT EXECUTED 20113f4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20113f8: c2 24 61 60 st %g1, [ %l1 + 0x160 ] <== NOT EXECUTED 20113fc: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 <== NOT EXECUTED 2011400: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2011404: 32 bf ff 74 bne,a 20111d4 <== NOT EXECUTED 2011408: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED _Thread_Dispatch(); 201140c: 40 00 15 b6 call 2016ae4 <_Thread_Dispatch> <== NOT EXECUTED 2011410: 01 00 00 00 nop <== NOT EXECUTED 2011414: 10 bf ff 70 b 20111d4 <== NOT EXECUTED 2011418: 92 10 00 18 mov %i0, %o1 <== 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++; 201141c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2011420: c2 24 20 64 st %g1, [ %l0 + 0x64 ] <== NOT EXECUTED _ISR_Enable( level ); 2011424: 7f ff e5 c2 call 200ab2c <== NOT EXECUTED 2011428: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 201142c: 10 bf ff 6a b 20111d4 <== NOT EXECUTED 2011430: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2011434: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2011438: c8 24 20 60 st %g4, [ %l0 + 0x60 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 201143c: c0 24 20 64 clr [ %l0 + 0x64 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2011440: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 2011444: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2011448: c2 20 a0 1c st %g1, [ %g2 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 201144c: 7f ff e5 b8 call 200ab2c <== NOT EXECUTED 2011450: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011454: 10 bf ff 60 b 20111d4 <== NOT EXECUTED 2011458: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 201145c: 7f ff e5 b4 call 200ab2c <== NOT EXECUTED 2011460: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 2011464: 10 bf ff 5c b 20111d4 <== NOT EXECUTED 2011468: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator internally */ 201146c: 90 10 00 10 mov %l0, %o0 if ( !status ) { _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ADDRESS; } the_region->number_of_used_blocks -= 1; 2011470: 82 00 7f ff add %g1, -1, %g1 _Region_Process_queue(the_region); /* unlocks allocator internally */ 2011474: b0 10 20 00 clr %i0 2011478: 40 00 26 f6 call 201b050 <_Region_Process_queue> 201147c: c2 24 20 64 st %g1, [ %l0 + 0x64 ] 2011480: 81 c7 e0 08 ret 2011484: 81 e8 00 00 restore 02005aa4 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 2005aa4: 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 ) ) 2005aa8: aa 96 20 00 orcc %i0, 0, %l5 2005aac: 02 80 00 12 be 2005af4 2005ab0: b0 10 20 03 mov 3, %i0 return RTEMS_INVALID_NAME; if ( !id ) 2005ab4: 80 a7 20 00 cmp %i4, 0 2005ab8: 02 80 00 0f be 2005af4 2005abc: b0 10 20 09 mov 9, %i0 return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 2005ac0: a4 8e a0 40 andcc %i2, 0x40, %l2 2005ac4: 12 80 00 0e bne 2005afc 2005ac8: a0 0e a0 30 and %i2, 0x30, %l0 2005acc: 80 8e a0 80 btst 0x80, %i2 2005ad0: 12 80 00 0c bne 2005b00 2005ad4: 80 a4 20 10 cmp %l0, 0x10 RTEMS_INLINE_ROUTINE boolean _Attributes_Is_counting_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE); 2005ad8: 80 a0 00 10 cmp %g0, %l0 2005adc: a2 60 3f ff subx %g0, -1, %l1 if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 2005ae0: 80 a4 60 00 cmp %l1, 0 2005ae4: 12 80 00 17 bne 2005b40 2005ae8: 80 a6 60 01 cmp %i1, 1 2005aec: 08 80 00 15 bleu 2005b40 2005af0: b0 10 20 0a mov 0xa, %i0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2005af4: 81 c7 e0 08 ret 2005af8: 81 e8 00 00 restore #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005afc: 80 a4 20 10 cmp %l0, 0x10 2005b00: 12 80 00 0b bne 2005b2c 2005b04: 80 a4 20 20 cmp %l0, 0x20 2005b08: 80 8e a0 04 btst 4, %i2 2005b0c: 02 80 00 06 be 2005b24 2005b10: 80 a4 a0 00 cmp %l2, 0 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 2005b14: 02 bf ff f1 be 2005ad8 2005b18: 80 8e a0 80 btst 0x80, %i2 2005b1c: 02 bf ff f0 be 2005adc 2005b20: 80 a0 00 10 cmp %g0, %l0 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 2005b24: 81 c7 e0 08 ret 2005b28: 91 e8 20 0b restore %g0, 0xb, %o0 #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 2005b2c: 12 bf ff fe bne 2005b24 2005b30: 80 8e a0 04 btst 4, %i2 2005b34: 12 bf ff f8 bne 2005b14 2005b38: 80 a4 a0 00 cmp %l2, 0 2005b3c: 30 bf ff fa b,a 2005b24 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005b40: 29 00 80 66 sethi %hi(0x2019800), %l4 2005b44: c2 05 20 40 ld [ %l4 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 2005b48: 82 00 60 01 inc %g1 2005b4c: c2 25 20 40 st %g1, [ %l4 + 0x40 ] * the inactive chain of free semaphore control blocks. */ RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Allocate( void ) { return (Semaphore_Control *) _Objects_Allocate( &_Semaphore_Information ); 2005b50: 31 00 80 65 sethi %hi(0x2019400), %i0 2005b54: 40 00 07 4d call 2007888 <_Objects_Allocate> 2005b58: 90 16 22 f0 or %i0, 0x2f0, %o0 ! 20196f0 <_Semaphore_Information> _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 2005b5c: a6 92 20 00 orcc %o0, 0, %l3 2005b60: 12 80 00 0e bne 2005b98 2005b64: 80 a4 60 00 cmp %l1, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2005b68: c2 05 20 40 ld [ %l4 + 0x40 ], %g1 2005b6c: b0 10 20 05 mov 5, %i0 _Thread_Dispatch(); 2005b70: 82 00 7f ff add %g1, -1, %g1 2005b74: c2 25 20 40 st %g1, [ %l4 + 0x40 ] 2005b78: c4 05 20 40 ld [ %l4 + 0x40 ], %g2 2005b7c: 80 a0 a0 00 cmp %g2, 0 2005b80: 12 80 00 04 bne 2005b90 2005b84: 01 00 00 00 nop 2005b88: 40 00 0d c5 call 200929c <_Thread_Dispatch> 2005b8c: 01 00 00 00 nop 2005b90: 81 c7 e0 08 ret 2005b94: 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 ) ) { 2005b98: 12 80 00 1e bne 2005c10 2005b9c: f4 24 e0 10 st %i2, [ %l3 + 0x10 ] CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 2005ba0: 80 a4 a0 00 cmp %l2, 0 2005ba4: 02 80 00 39 be 2005c88 2005ba8: 80 8e a0 80 btst 0x80, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 2005bac: 82 10 20 02 mov 2, %g1 2005bb0: c2 27 bf e8 st %g1, [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 2005bb4: 80 a4 20 10 cmp %l0, 0x10 2005bb8: 12 80 00 39 bne 2005c9c 2005bbc: 82 10 20 02 mov 2, %g1 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005bc0: c2 07 bf e8 ld [ %fp + -24 ], %g1 2005bc4: 80 a0 60 01 cmp %g1, 1 2005bc8: 18 80 00 3d bgu 2005cbc 2005bcc: c0 27 bf e0 clr [ %fp + -32 ] case CORE_MUTEX_DISCIPLINES_FIFO: case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; 2005bd0: c0 27 bf e4 clr [ %fp + -28 ] the_mutex_attributes.only_owner_release = FALSE; } the_mutex_attributes.priority_ceiling = priority_ceiling; mutex_status = _CORE_mutex_Initialize( 2005bd4: 82 1e 60 01 xor %i1, 1, %g1 2005bd8: 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; 2005bdc: f6 27 bf ec st %i3, [ %fp + -20 ] mutex_status = _CORE_mutex_Initialize( 2005be0: 94 60 3f ff subx %g0, -1, %o2 2005be4: 90 04 e0 14 add %l3, 0x14, %o0 2005be8: 40 00 04 9b call 2006e54 <_CORE_mutex_Initialize> 2005bec: 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 ) { 2005bf0: 80 a2 20 06 cmp %o0, 6 2005bf4: 12 80 00 14 bne 2005c44 2005bf8: 90 16 22 f0 or %i0, 0x2f0, %o0 RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005bfc: 40 00 08 31 call 2007cc0 <_Objects_Free> <== NOT EXECUTED 2005c00: 92 10 00 13 mov %l3, %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 ) 2005c04: c2 05 20 40 ld [ %l4 + 0x40 ], %g1 <== NOT EXECUTED 2005c08: 10 bf ff da b 2005b70 <== NOT EXECUTED 2005c0c: b0 10 20 13 mov 0x13, %i0 <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) 2005c10: 80 8e a0 04 btst 4, %i2 2005c14: 22 80 00 04 be,a 2005c24 2005c18: c0 27 bf f4 clr [ %fp + -12 ] the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 2005c1c: 82 10 20 01 mov 1, %g1 2005c20: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005c24: 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; 2005c28: c0 27 bf e0 clr [ %fp + -32 ] the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 2005c2c: c0 27 bf ec clr [ %fp + -20 ] _CORE_semaphore_Initialize( 2005c30: 94 10 00 19 mov %i1, %o2 /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 2005c34: 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( 2005c38: 90 04 e0 14 add %l3, 0x14, %o0 2005c3c: 40 00 05 43 call 2007148 <_CORE_semaphore_Initialize> 2005c40: 92 07 bf f0 add %fp, -16, %o1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005c44: 90 16 22 f0 or %i0, 0x2f0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 2005c48: c6 04 e0 08 ld [ %l3 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005c4c: c4 12 20 10 lduh [ %o0 + 0x10 ], %g2 2005c50: 03 00 00 3f sethi %hi(0xfc00), %g1 2005c54: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2005c58: 82 08 c0 01 and %g3, %g1, %g1 2005c5c: 80 a0 40 02 cmp %g1, %g2 2005c60: 38 80 00 06 bgu,a 2005c78 2005c64: ea 24 e0 0c st %l5, [ %l3 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005c68: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005c6c: 83 28 60 02 sll %g1, 2, %g1 2005c70: e6 20 80 01 st %l3, [ %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; 2005c74: ea 24 e0 0c st %l5, [ %l3 + 0xc ] &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 2005c78: c6 27 00 00 st %g3, [ %i4 ] 2005c7c: c2 05 20 40 ld [ %l4 + 0x40 ], %g1 2005c80: 10 bf ff bc b 2005b70 2005c84: b0 10 20 00 clr %i0 if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 2005c88: 02 80 00 08 be 2005ca8 2005c8c: 80 8e a0 04 btst 4, %i2 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 2005c90: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 2005c94: 10 bf ff c8 b 2005bb4 <== NOT EXECUTED 2005c98: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED the_mutex_attributes.only_owner_release = TRUE; break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; the_mutex_attributes.only_owner_release = FALSE; 2005c9c: 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; 2005ca0: 10 bf ff cd b 2005bd4 2005ca4: c2 27 bf e0 st %g1, [ %fp + -32 ] if ( _Attributes_Is_inherit_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; else if ( _Attributes_Is_priority( attribute_set ) ) 2005ca8: 22 bf ff c3 be,a 2005bb4 2005cac: c0 27 bf e8 clr [ %fp + -24 ] the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 2005cb0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2005cb4: 10 bf ff c0 b 2005bb4 <== NOT EXECUTED 2005cb8: c2 27 bf e8 st %g1, [ %fp + -24 ] <== NOT EXECUTED if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; switch ( the_mutex_attributes.discipline ) { 2005cbc: 80 a0 60 03 cmp %g1, 3 2005cc0: 18 bf ff c6 bgu 2005bd8 2005cc4: 82 1e 60 01 xor %i1, 1, %g1 case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 2005cc8: 82 10 20 01 mov 1, %g1 2005ccc: 10 bf ff c2 b 2005bd4 2005cd0: c2 27 bf e4 st %g1, [ %fp + -28 ] 02005cd4 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 2005cd4: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2005cd8: 21 00 80 65 sethi %hi(0x2019400), %l0 2005cdc: 92 10 00 18 mov %i0, %o1 2005ce0: 94 07 bf f4 add %fp, -12, %o2 2005ce4: 40 00 08 3a call 2007dcc <_Objects_Get> 2005ce8: 90 14 22 f0 or %l0, 0x2f0, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005cec: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005cf0: 80 a0 60 00 cmp %g1, 0 2005cf4: 12 80 00 19 bne 2005d58 2005cf8: b0 10 00 08 mov %o0, %i0 2005cfc: 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) ) { 2005d00: 84 88 60 30 andcc %g1, 0x30, %g2 2005d04: 22 80 00 1a be,a 2005d6c 2005d08: 90 02 20 14 add %o0, 0x14, %o0 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 2005d0c: c2 02 20 64 ld [ %o0 + 0x64 ], %g1 2005d10: 80 a0 60 00 cmp %g1, 0 2005d14: 12 80 00 35 bne 2005de8 2005d18: 80 a0 a0 20 cmp %g2, 0x20 2005d1c: 02 80 00 34 be 2005dec 2005d20: 90 06 20 14 add %i0, 0x14, %o0 2005d24: 03 00 80 66 sethi %hi(0x2019800), %g1 2005d28: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 2005d2c: b0 10 20 0c mov 0xc, %i0 2005d30: 84 00 bf ff add %g2, -1, %g2 2005d34: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 2005d38: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 2005d3c: 80 a0 e0 00 cmp %g3, 0 2005d40: 12 80 00 28 bne 2005de0 2005d44: 01 00 00 00 nop _Thread_Dispatch(); 2005d48: 40 00 0d 55 call 200929c <_Thread_Dispatch> 2005d4c: 01 00 00 00 nop 2005d50: 81 c7 e0 08 ret 2005d54: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2005d58: 80 a0 60 02 cmp %g1, 2 2005d5c: 08 bf ff fd bleu 2005d50 2005d60: b0 10 20 04 mov 4, %i0 2005d64: 81 c7 e0 08 ret <== NOT EXECUTED 2005d68: 91 e8 20 19 restore %g0, 0x19, %o0 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 2005d6c: 92 10 20 00 clr %o1 2005d70: 40 00 04 f2 call 2007138 <_CORE_semaphore_Flush> 2005d74: 94 10 20 02 mov 2, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005d78: 90 14 22 f0 or %l0, 0x2f0, %o0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2005d7c: c2 06 20 08 ld [ %i0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005d80: c6 12 20 10 lduh [ %o0 + 0x10 ], %g3 2005d84: 05 00 00 3f sethi %hi(0xfc00), %g2 2005d88: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2005d8c: 82 08 40 02 and %g1, %g2, %g1 2005d90: 80 a0 40 03 cmp %g1, %g3 2005d94: 38 80 00 06 bgu,a 2005dac 2005d98: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2005d9c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2 2005da0: 83 28 60 02 sll %g1, 2, %g1 2005da4: 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; 2005da8: c0 26 20 0c clr [ %i0 + 0xc ] RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 2005dac: 40 00 07 c5 call 2007cc0 <_Objects_Free> 2005db0: 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 ) 2005db4: 03 00 80 66 sethi %hi(0x2019800), %g1 2005db8: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 2005dbc: b0 10 20 00 clr %i0 2005dc0: 84 00 bf ff add %g2, -1, %g2 2005dc4: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 2005dc8: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 2005dcc: 80 a0 e0 00 cmp %g3, 0 2005dd0: 12 80 00 04 bne 2005de0 2005dd4: 01 00 00 00 nop _Thread_Dispatch(); 2005dd8: 40 00 0d 31 call 200929c <_Thread_Dispatch> 2005ddc: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005de0: 81 c7 e0 08 ret 2005de4: 81 e8 00 00 restore !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 2005de8: 90 06 20 14 add %i0, 0x14, %o0 2005dec: 92 10 20 00 clr %o1 2005df0: 40 00 04 15 call 2006e44 <_CORE_mutex_Flush> 2005df4: 94 10 20 04 mov 4, %o2 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2005df8: 10 bf ff e1 b 2005d7c 2005dfc: 90 14 22 f0 or %l0, 0x2f0, %o0 020062a0 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 20062a0: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 20062a4: 11 00 80 6e sethi %hi(0x201b800), %o0 20062a8: 92 10 00 18 mov %i0, %o1 20062ac: 90 12 21 48 or %o0, 0x148, %o0 20062b0: 40 00 08 9a call 2008518 <_Objects_Get> 20062b4: 94 07 bf f4 add %fp, -12, %o2 register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 20062b8: c2 07 bf f4 ld [ %fp + -12 ], %g1 20062bc: 80 a0 60 00 cmp %g1, 0 20062c0: 12 80 00 16 bne 2006318 20062c4: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 20062c8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 20062cc: 80 88 60 30 btst 0x30, %g1 20062d0: 12 80 00 16 bne 2006328 20062d4: 90 02 20 14 add %o0, 0x14, %o0 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 20062d8: 92 10 20 00 clr %o1 <== NOT EXECUTED 20062dc: 40 00 05 6a call 2007884 <_CORE_semaphore_Flush> <== NOT EXECUTED 20062e0: 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 ) 20062e4: 03 00 80 6e sethi %hi(0x201b800), %g1 20062e8: c4 00 62 90 ld [ %g1 + 0x290 ], %g2 ! 201ba90 <_Thread_Dispatch_disable_level> 20062ec: b0 10 20 00 clr %i0 20062f0: 84 00 bf ff add %g2, -1, %g2 20062f4: c4 20 62 90 st %g2, [ %g1 + 0x290 ] 20062f8: c6 00 62 90 ld [ %g1 + 0x290 ], %g3 20062fc: 80 a0 e0 00 cmp %g3, 0 2006300: 12 80 00 04 bne 2006310 2006304: 01 00 00 00 nop _Thread_Dispatch(); 2006308: 40 00 0d 7c call 20098f8 <_Thread_Dispatch> 200630c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006310: 81 c7 e0 08 ret 2006314: 81 e8 00 00 restore { register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 2006318: 08 bf ff fe bleu 2006310 <== NOT EXECUTED 200631c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED 2006320: 81 c7 e0 08 ret <== NOT EXECUTED 2006324: 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) ) { _CORE_mutex_Flush( 2006328: 92 10 20 00 clr %o1 200632c: 40 00 04 99 call 2007590 <_CORE_mutex_Flush> 2006330: 94 10 20 01 mov 1, %o2 2006334: 30 bf ff ec b,a 20062e4 02005e00 : rtems_status_code rtems_semaphore_obtain( rtems_id id, uint32_t option_set, rtems_interval timeout ) { 2005e00: 9d e3 bf 90 save %sp, -112, %sp Objects_Id id, Objects_Locations *location, ISR_Level *level ) { return (Semaphore_Control *) 2005e04: 11 00 80 65 sethi %hi(0x2019400), %o0 2005e08: 92 10 00 18 mov %i0, %o1 2005e0c: 90 12 22 f0 or %o0, 0x2f0, %o0 2005e10: 94 07 bf f4 add %fp, -12, %o2 2005e14: 40 00 07 d0 call 2007d54 <_Objects_Get_isr_disable> 2005e18: 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 ) { 2005e1c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2005e20: 80 a0 60 00 cmp %g1, 0 2005e24: 12 80 00 19 bne 2005e88 2005e28: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2005e2c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2005e30: 80 88 60 30 btst 0x30, %g1 2005e34: 12 80 00 1b bne 2005ea0 2005e38: 23 00 80 66 sethi %hi(0x2019800), %l1 Thread_Control *executing; ISR_Level level = *level_p; /* disabled when you get here */ executing = _Thread_Executing; 2005e3c: 27 00 80 66 sethi %hi(0x2019800), %l3 2005e40: e4 04 e1 20 ld [ %l3 + 0x120 ], %l2 ! 2019920 <_Thread_Executing> Watchdog_Interval timeout, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005e44: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 2005e48: c0 24 a0 34 clr [ %l2 + 0x34 ] if ( the_semaphore->count != 0 ) { 2005e4c: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 2005e50: 80 a0 60 00 cmp %g1, 0 2005e54: 12 80 00 8f bne 2006090 2005e58: 80 8e 60 01 btst 1, %i1 the_semaphore->count -= 1; _ISR_Enable( level ); return; } if ( !wait ) { 2005e5c: 02 80 00 73 be 2006028 2005e60: 01 00 00 00 nop _ISR_Enable( level ); 2005e64: 7f ff ef ea call 2001e0c 2005e68: 01 00 00 00 nop executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 2005e6c: 82 10 20 01 mov 1, %g1 ! 1 2005e70: c2 24 a0 34 st %g1, [ %l2 + 0x34 ] id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2005e74: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 2005e78: 40 00 00 f4 call 2006248 <_Semaphore_Translate_core_semaphore_return_code> 2005e7c: d0 00 60 34 ld [ %g1 + 0x34 ], %o0 _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e80: 81 c7 e0 08 ret 2005e84: 91 e8 00 08 restore %g0, %o0, %o0 register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 2005e88: 80 a0 60 02 cmp %g1, 2 2005e8c: 08 bf ff fd bleu 2005e80 2005e90: 90 10 20 04 mov 4, %o0 2005e94: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED return _Semaphore_Translate_core_semaphore_return_code( _Thread_Executing->Wait.return_code ); } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2005e98: 81 c7 e0 08 ret <== NOT EXECUTED 2005e9c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2005ea0: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2005ea4: 80 a0 60 00 cmp %g1, 0 2005ea8: 02 80 00 0e be 2005ee0 2005eac: 27 00 80 66 sethi %hi(0x2019800), %l3 2005eb0: 80 8e 60 01 btst 1, %i1 2005eb4: 12 80 00 0c bne 2005ee4 2005eb8: c6 04 e1 20 ld [ %l3 + 0x120 ], %g3 2005ebc: 03 00 80 66 sethi %hi(0x2019800), %g1 2005ec0: c4 00 62 20 ld [ %g1 + 0x220 ], %g2 ! 2019a20 <_System_state_Current> 2005ec4: 80 a0 a0 01 cmp %g2, 1 2005ec8: 08 80 00 07 bleu 2005ee4 2005ecc: 90 10 20 00 clr %o0 2005ed0: 92 10 20 00 clr %o1 <== NOT EXECUTED 2005ed4: 40 00 06 40 call 20077d4 <_Internal_error_Occurred> <== NOT EXECUTED 2005ed8: 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; 2005edc: 27 00 80 66 sethi %hi(0x2019800), %l3 <== NOT EXECUTED 2005ee0: c6 04 e1 20 ld [ %l3 + 0x120 ], %g3 ! 2019920 <_Thread_Executing> CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { Thread_Control *executing; ISR_Level level = *level_p; 2005ee4: d0 07 bf f0 ld [ %fp + -16 ], %o0 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 2005ee8: c0 20 e0 34 clr [ %g3 + 0x34 ] if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 2005eec: c2 04 20 64 ld [ %l0 + 0x64 ], %g1 2005ef0: 80 a0 60 00 cmp %g1, 0 2005ef4: 22 80 00 37 be,a 2005fd0 2005ef8: c2 04 20 70 ld [ %l0 + 0x70 ], %g1 the_mutex->lock = CORE_MUTEX_LOCKED; 2005efc: c0 24 20 64 clr [ %l0 + 0x64 ] the_mutex->holder = executing; 2005f00: c6 24 20 70 st %g3, [ %l0 + 0x70 ] the_mutex->holder_id = executing->Object.id; 2005f04: c2 00 e0 08 ld [ %g3 + 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; 2005f08: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 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; 2005f0c: 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; 2005f10: c2 24 20 74 st %g1, [ %l0 + 0x74 ] the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005f14: 80 a0 a0 02 cmp %g2, 2 2005f18: 12 80 00 24 bne 2005fa8 2005f1c: c8 24 20 68 st %g4, [ %l0 + 0x68 ] _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; 2005f20: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2005f24: 82 00 60 01 inc %g1 2005f28: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 2005f2c: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 2005f30: 80 a0 a0 03 cmp %g2, 3 2005f34: 12 80 00 20 bne 2005fb4 2005f38: 01 00 00 00 nop */ { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; 2005f3c: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED current = executing->current_priority; 2005f40: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 <== NOT EXECUTED if ( current == ceiling ) { 2005f44: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2005f48: 02 80 00 79 be 200612c <== NOT EXECUTED 2005f4c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED _ISR_Enable( level ); return 0; } if ( current > ceiling ) { 2005f50: 1a 80 00 6d bcc 2006104 <== NOT EXECUTED 2005f54: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2005f58: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2005f5c: 82 00 60 01 inc %g1 <== NOT EXECUTED 2005f60: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Enable( level ); 2005f64: 7f ff ef aa call 2001e0c <== NOT EXECUTED 2005f68: 01 00 00 00 nop <== NOT EXECUTED _Thread_Change_priority( 2005f6c: d2 04 20 60 ld [ %l0 + 0x60 ], %o1 <== NOT EXECUTED 2005f70: d0 04 20 70 ld [ %l0 + 0x70 ], %o0 <== NOT EXECUTED 2005f74: 40 00 0b 9a call 2008ddc <_Thread_Change_priority> <== NOT EXECUTED 2005f78: 94 10 20 00 clr %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 ) 2005f7c: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 <== NOT EXECUTED 2005f80: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2005f84: c2 24 60 40 st %g1, [ %l1 + 0x40 ] <== NOT EXECUTED 2005f88: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 <== NOT EXECUTED 2005f8c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2005f90: 32 80 00 0c bne,a 2005fc0 <== NOT EXECUTED 2005f94: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 2005f98: 40 00 0c c1 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2005f9c: 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( 2005fa0: 10 80 00 08 b 2005fc0 <== NOT EXECUTED 2005fa4: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED 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; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 2005fa8: 80 a0 a0 03 cmp %g2, 3 <== NOT EXECUTED 2005fac: 22 bf ff de be,a 2005f24 <== NOT EXECUTED 2005fb0: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) executing->resource_count++; if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( level ); 2005fb4: 7f ff ef 96 call 2001e0c 2005fb8: 01 00 00 00 nop 2005fbc: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 2005fc0: 40 00 00 98 call 2006220 <_Semaphore_Translate_core_mutex_return_code> 2005fc4: 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 */ } 2005fc8: 81 c7 e0 08 ret 2005fcc: 91 e8 00 08 restore %g0, %o0, %o0 /* * 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 ) ) { 2005fd0: 80 a0 40 03 cmp %g1, %g3 2005fd4: 12 80 00 0d bne 2006008 2005fd8: 80 8e 60 01 btst 1, %i1 switch ( the_mutex->Attributes.lock_nesting_behavior ) { 2005fdc: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 2005fe0: 80 a0 60 00 cmp %g1, 0 2005fe4: 12 80 00 40 bne 20060e4 2005fe8: 80 a0 60 01 cmp %g1, 1 case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 2005fec: c2 04 20 68 ld [ %l0 + 0x68 ], %g1 2005ff0: 82 00 60 01 inc %g1 2005ff4: c2 24 20 68 st %g1, [ %l0 + 0x68 ] _ISR_Enable( level ); 2005ff8: 7f ff ef 85 call 2001e0c 2005ffc: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 2006000: 10 bf ff f0 b 2005fc0 2006004: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 2006008: 02 80 00 28 be 20060a8 200600c: c6 04 e1 20 ld [ %l3 + 0x120 ], %g3 2006010: 7f ff ef 7f call 2001e0c 2006014: d0 07 bf f0 ld [ %fp + -16 ], %o0 2006018: c4 04 e1 20 ld [ %l3 + 0x120 ], %g2 200601c: 82 10 20 01 mov 1, %g1 2006020: 10 bf ff e7 b 2005fbc 2006024: c2 20 a0 34 st %g1, [ %g2 + 0x34 ] rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006028: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 200602c: 82 00 60 01 inc %g1 2006030: c2 24 60 40 st %g1, [ %l1 + 0x40 ] RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2006034: 82 10 20 01 mov 1, %g1 2006038: 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; 200603c: f0 24 a0 20 st %i0, [ %l2 + 0x20 ] return; } _Thread_Disable_dispatch(); _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 2006040: a0 04 20 14 add %l0, 0x14, %l0 2006044: e0 24 a0 44 st %l0, [ %l2 + 0x44 ] executing->Wait.id = id; _ISR_Enable( level ); 2006048: 7f ff ef 71 call 2001e0c 200604c: 01 00 00 00 nop _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 2006050: 90 10 00 10 mov %l0, %o0 2006054: 92 10 00 1a mov %i2, %o1 2006058: 15 00 80 27 sethi %hi(0x2009c00), %o2 200605c: 40 00 0e 29 call 2009900 <_Thread_queue_Enqueue_with_handler> 2006060: 94 12 a2 40 or %o2, 0x240, %o2 ! 2009e40 <_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 ) 2006064: c2 04 60 40 ld [ %l1 + 0x40 ], %g1 2006068: 82 00 7f ff add %g1, -1, %g1 200606c: c2 24 60 40 st %g1, [ %l1 + 0x40 ] 2006070: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 2006074: 80 a0 a0 00 cmp %g2, 0 2006078: 32 bf ff 80 bne,a 2005e78 200607c: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED _Thread_Dispatch(); 2006080: 40 00 0c 87 call 200929c <_Thread_Dispatch> 2006084: 01 00 00 00 nop id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 2006088: 10 bf ff 7c b 2005e78 200608c: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 /* disabled when you get here */ executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 2006090: 82 00 7f ff add %g1, -1, %g1 2006094: c2 24 20 5c st %g1, [ %l0 + 0x5c ] _ISR_Enable( level ); 2006098: 7f ff ef 5d call 2001e0c 200609c: 01 00 00 00 nop 20060a0: 10 bf ff 76 b 2005e78 20060a4: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20060a8: c4 04 60 40 ld [ %l1 + 0x40 ], %g2 20060ac: 82 10 20 01 mov 1, %g1 20060b0: c2 24 20 44 st %g1, [ %l0 + 0x44 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Seize( 20060b4: f0 20 e0 20 st %i0, [ %g3 + 0x20 ] 20060b8: 84 00 a0 01 inc %g2 20060bc: a0 04 20 14 add %l0, 0x14, %l0 20060c0: c4 24 60 40 st %g2, [ %l1 + 0x40 ] 20060c4: e0 20 e0 44 st %l0, [ %g3 + 0x44 ] 20060c8: 7f ff ef 51 call 2001e0c 20060cc: d0 07 bf f0 ld [ %fp + -16 ], %o0 20060d0: 90 10 00 10 mov %l0, %o0 20060d4: 40 00 03 99 call 2006f38 <_CORE_mutex_Seize_interrupt_blocking> 20060d8: 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( 20060dc: 10 bf ff b9 b 2005fc0 20060e0: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 20060e4: 12 bf ff c9 bne 2006008 20060e8: 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; 20060ec: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 20060f0: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED _ISR_Enable( level ); 20060f4: 7f ff ef 46 call 2001e0c <== NOT EXECUTED 20060f8: 01 00 00 00 nop <== NOT EXECUTED 20060fc: 10 bf ff b1 b 2005fc0 <== NOT EXECUTED 2006100: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 2006104: c2 20 e0 34 st %g1, [ %g3 + 0x34 ] <== NOT EXECUTED the_mutex->lock = CORE_MUTEX_UNLOCKED; 2006108: c8 24 20 64 st %g4, [ %l0 + 0x64 ] <== NOT EXECUTED the_mutex->nest_count = 0; /* undo locking above */ 200610c: c0 24 20 68 clr [ %l0 + 0x68 ] <== NOT EXECUTED executing->resource_count--; /* undo locking above */ 2006110: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 <== NOT EXECUTED 2006114: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2006118: c2 20 e0 1c st %g1, [ %g3 + 0x1c ] <== NOT EXECUTED _ISR_Enable( level ); 200611c: 7f ff ef 3c call 2001e0c <== NOT EXECUTED 2006120: 01 00 00 00 nop <== NOT EXECUTED 2006124: 10 bf ff a7 b 2005fc0 <== NOT EXECUTED 2006128: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; if ( current == ceiling ) { _ISR_Enable( level ); 200612c: 7f ff ef 38 call 2001e0c <== NOT EXECUTED 2006130: 01 00 00 00 nop <== NOT EXECUTED 2006134: 10 bf ff a3 b 2005fc0 <== NOT EXECUTED 2006138: c2 04 e1 20 ld [ %l3 + 0x120 ], %g1 <== NOT EXECUTED 0200613c : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 200613c: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get ( Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) 2006140: 11 00 80 65 sethi %hi(0x2019400), %o0 2006144: 92 10 00 18 mov %i0, %o1 2006148: 90 12 22 f0 or %o0, 0x2f0, %o0 200614c: 40 00 07 20 call 2007dcc <_Objects_Get> 2006150: 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 ) { 2006154: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006158: 80 a0 60 00 cmp %g1, 0 200615c: 12 80 00 16 bne 20061b4 2006160: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 2006164: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006168: 80 88 60 30 btst 0x30, %g1 200616c: 02 80 00 17 be 20061c8 2006170: 92 10 00 18 mov %i0, %o1 mutex_status = _CORE_mutex_Surrender( 2006174: 94 10 20 00 clr %o2 2006178: 40 00 03 94 call 2006fc8 <_CORE_mutex_Surrender> 200617c: 90 02 20 14 add %o0, 0x14, %o0 2006180: 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 ) 2006184: 03 00 80 66 sethi %hi(0x2019800), %g1 2006188: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 200618c: 84 00 bf ff add %g2, -1, %g2 2006190: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 2006194: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 2006198: 80 a0 e0 00 cmp %g3, 0 200619c: 02 80 00 1e be 2006214 20061a0: 01 00 00 00 nop &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 20061a4: 40 00 00 1f call 2006220 <_Semaphore_Translate_core_mutex_return_code> 20061a8: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20061ac: 81 c7 e0 08 ret 20061b0: 91 e8 00 08 restore %g0, %o0, %o0 Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 20061b4: 08 bf ff fe bleu 20061ac 20061b8: 90 10 20 04 mov 4, %o0 20061bc: 90 10 20 19 mov 0x19, %o0 <== NOT EXECUTED _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20061c0: 81 c7 e0 08 ret <== NOT EXECUTED 20061c4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 20061c8: 94 10 20 00 clr %o2 20061cc: 40 00 03 ee call 2007184 <_CORE_semaphore_Surrender> 20061d0: 90 02 20 14 add %o0, 0x14, %o0 20061d4: b0 10 00 08 mov %o0, %i0 20061d8: 03 00 80 66 sethi %hi(0x2019800), %g1 20061dc: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 ! 2019840 <_Thread_Dispatch_disable_level> 20061e0: 84 00 bf ff add %g2, -1, %g2 20061e4: c4 20 60 40 st %g2, [ %g1 + 0x40 ] 20061e8: c6 00 60 40 ld [ %g1 + 0x40 ], %g3 20061ec: 80 a0 e0 00 cmp %g3, 0 20061f0: 02 80 00 06 be 2006208 20061f4: 01 00 00 00 nop &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return 20061f8: 40 00 00 14 call 2006248 <_Semaphore_Translate_core_semaphore_return_code> 20061fc: 90 10 00 18 mov %i0, %o0 _Semaphore_Translate_core_semaphore_return_code( semaphore_status ); } } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006200: 81 c7 e0 08 ret 2006204: 91 e8 00 08 restore %g0, %o0, %o0 _Thread_Dispatch(); 2006208: 40 00 0c 25 call 200929c <_Thread_Dispatch> 200620c: 01 00 00 00 nop 2006210: 30 bf ff fa b,a 20061f8 2006214: 40 00 0c 22 call 200929c <_Thread_Dispatch> 2006218: 01 00 00 00 nop 200621c: 30 bf ff e2 b,a 20061a4 02017084 : */ void rtems_shutdown_executive( uint32_t result ) { 2017084: 9d e3 bf 98 save %sp, -104, %sp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 2017088: 33 00 80 66 sethi %hi(0x2019800), %i1 201708c: c2 06 62 20 ld [ %i1 + 0x220 ], %g1 ! 2019a20 <_System_state_Current> 2017090: 80 a0 60 04 cmp %g1, 4 2017094: 02 80 00 0c be 20170c4 2017098: 11 00 80 61 sethi %hi(0x2018400), %o0 #if defined(__USE_INIT_FINI__) extern void _fini( void ); atexit( _fini ); 201709c: 7f ff e0 01 call 200f0a0 20170a0: 90 12 20 c4 or %o0, 0xc4, %o0 ! 20184c4 <_fini> * routine which initialized the system. */ RTEMS_INLINE_ROUTINE void _Thread_Stop_multitasking( void ) { _Context_Switch( &_Thread_Executing->Registers, &_Thread_BSP_context ); 20170a4: 03 00 80 66 sethi %hi(0x2019800), %g1 20170a8: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_Thread_Executing> 20170ac: 84 10 20 04 mov 4, %g2 20170b0: b0 06 20 e0 add %i0, 0xe0, %i0 20170b4: c4 26 62 20 st %g2, [ %i1 + 0x220 ] 20170b8: 33 00 80 65 sethi %hi(0x2019400), %i1 20170bc: 7f ff cf 07 call 200acd8 <_CPU_Context_switch> 20170c0: 93 ee 63 b8 restore %i1, 0x3b8, %o1 20170c4: 81 c7 e0 08 ret <== NOT EXECUTED 20170c8: 81 e8 00 00 restore <== NOT EXECUTED 02011c88 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 2011c88: 9d e3 bf 90 save %sp, -112, %sp 2011c8c: 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 ) 2011c90: 80 a6 60 00 cmp %i1, 0 2011c94: 02 80 00 1b be 2011d00 2011c98: 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 ) ) { 2011c9c: 80 a2 60 00 cmp %o1, 0 2011ca0: 12 80 00 1a bne 2011d08 2011ca4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2011ca8: 23 00 80 ce sethi %hi(0x2033800), %l1 2011cac: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 2011cb0: 82 00 60 01 inc %g1 2011cb4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 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; 2011cb8: 03 00 80 ce sethi %hi(0x2033800), %g1 2011cbc: e0 00 62 40 ld [ %g1 + 0x240 ], %l0 ! 2033a40 <_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; 2011cc0: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 2011cc4: f0 04 21 70 ld [ %l0 + 0x170 ], %i0 asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 2011cc8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1 2011ccc: 80 a0 60 00 cmp %g1, 0 2011cd0: 32 80 00 2c bne,a 2011d80 2011cd4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2011cd8: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011cdc: b0 10 20 0b mov 0xb, %i0 2011ce0: 82 00 7f ff add %g1, -1, %g1 2011ce4: c2 24 61 60 st %g1, [ %l1 + 0x160 ] 2011ce8: c4 04 61 60 ld [ %l1 + 0x160 ], %g2 2011cec: 80 a0 a0 00 cmp %g2, 0 2011cf0: 12 80 00 0b bne 2011d1c 2011cf4: 01 00 00 00 nop _Thread_Dispatch(); 2011cf8: 40 00 13 7b call 2016ae4 <_Thread_Dispatch> 2011cfc: 01 00 00 00 nop 2011d00: 81 c7 e0 08 ret 2011d04: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2011d08: 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 ) { 2011d0c: 80 a0 a0 04 cmp %g2, 4 2011d10: 08 80 00 05 bleu 2011d24 2011d14: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2011d18: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2011d1c: 81 c7 e0 08 ret 2011d20: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2011d24: 80 a0 60 01 cmp %g1, 1 2011d28: 12 bf ff f6 bne 2011d00 2011d2c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2011d30: 83 28 a0 02 sll %g2, 2, %g1 2011d34: 05 00 80 ce sethi %hi(0x2033800), %g2 2011d38: 84 10 a0 c0 or %g2, 0xc0, %g2 ! 20338c0 <_Objects_Information_table> 2011d3c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2011d40: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2011d44: 80 a2 20 00 cmp %o0, 0 2011d48: 02 bf ff f5 be 2011d1c 2011d4c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2011d50: 40 00 0e 31 call 2015614 <_Objects_Get> 2011d54: 94 07 bf f4 add %fp, -12, %o2 if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2011d58: c2 07 bf f4 ld [ %fp + -12 ], %g1 2011d5c: a0 10 00 08 mov %o0, %l0 2011d60: 80 a0 60 00 cmp %g1, 0 2011d64: 02 bf ff d8 be 2011cc4 2011d68: 23 00 80 ce sethi %hi(0x2033800), %l1 2011d6c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2011d70: 18 bf ff e4 bgu 2011d00 <== NOT EXECUTED 2011d74: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2011d78: 81 c7 e0 08 ret <== NOT EXECUTED 2011d7c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { if ( asr->is_enabled ) { 2011d80: 80 a0 60 00 cmp %g1, 0 2011d84: 02 80 00 19 be 2011de8 2011d88: 01 00 00 00 nop rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2011d8c: 7f ff e3 64 call 200ab1c 2011d90: 01 00 00 00 nop *signal_set |= signals; 2011d94: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 2011d98: 82 10 40 19 or %g1, %i1, %g1 2011d9c: c2 26 20 54 st %g1, [ %i0 + 0x54 ] _ISR_Enable( _level ); 2011da0: 7f ff e3 63 call 200ab2c 2011da4: 01 00 00 00 nop _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = TRUE; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011da8: 03 00 80 ce sethi %hi(0x2033800), %g1 2011dac: c4 00 62 28 ld [ %g1 + 0x228 ], %g2 ! 2033a28 <_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; 2011db0: 86 10 20 01 mov 1, %g3 if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 2011db4: 80 a0 a0 00 cmp %g2, 0 2011db8: 02 80 00 09 be 2011ddc 2011dbc: c6 24 20 78 st %g3, [ %l0 + 0x78 ] 2011dc0: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2011dc4: c4 00 62 40 ld [ %g1 + 0x240 ], %g2 ! 2033a40 <_Thread_Executing> <== NOT EXECUTED 2011dc8: 80 a4 00 02 cmp %l0, %g2 <== NOT EXECUTED 2011dcc: 12 80 00 04 bne 2011ddc <== NOT EXECUTED 2011dd0: 01 00 00 00 nop <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 2011dd4: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2011dd8: c6 20 62 e8 st %g3, [ %g1 + 0x2e8 ] ! 2033ae8 <_ISR_Signals_to_thread_executing> <== 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 ) 2011ddc: c2 04 61 60 ld [ %l1 + 0x160 ], %g1 2011de0: 10 bf ff c0 b 2011ce0 2011de4: b0 10 20 00 clr %i0 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 2011de8: 7f ff e3 4d call 200ab1c 2011dec: 01 00 00 00 nop *signal_set |= signals; 2011df0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 2011df4: 82 10 40 19 or %g1, %i1, %g1 2011df8: c2 26 20 58 st %g1, [ %i0 + 0x58 ] _ISR_Enable( _level ); 2011dfc: 7f ff e3 4c call 200ab2c 2011e00: 01 00 00 00 nop 2011e04: 30 bf ff f6 b,a 2011ddc 020029c4 : /* * Check if blown */ boolean rtems_stack_checker_is_blown( void ) { 20029c4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 20029c8: 21 00 80 78 sethi %hi(0x201e000), %l0 <== NOT EXECUTED 20029cc: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 ! 201e030 <_Thread_Executing> <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 20029d0: d0 00 60 d4 ld [ %g1 + 0xd4 ], %o0 <== NOT EXECUTED 20029d4: 80 a7 80 08 cmp %fp, %o0 <== NOT EXECUTED 20029d8: 0a 80 00 07 bcs 20029f4 <== NOT EXECUTED 20029dc: b0 10 20 00 clr %i0 <== NOT EXECUTED 20029e0: c2 00 60 d0 ld [ %g1 + 0xd0 ], %g1 <== NOT EXECUTED 20029e4: 82 02 00 01 add %o0, %g1, %g1 <== NOT EXECUTED 20029e8: 80 a0 40 1e cmp %g1, %fp <== NOT EXECUTED 20029ec: 84 60 3f ff subx %g0, -1, %g2 <== NOT EXECUTED 20029f0: b0 10 00 02 mov %g2, %i0 <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 20029f4: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED 20029f8: c4 00 61 fc ld [ %g1 + 0x1fc ], %g2 ! 201d9fc <== NOT EXECUTED 20029fc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2002a00: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2002a04: 12 80 00 0d bne 2002a38 <== NOT EXECUTED 2002a08: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return FALSE. */ if ( sp_ok && pattern_ok ) 2002a0c: 80 8e 20 ff btst 0xff, %i0 <== NOT EXECUTED 2002a10: 22 80 00 06 be,a 2002a28 <== NOT EXECUTED 2002a14: d0 04 20 30 ld [ %l0 + 0x30 ], %o0 <== NOT EXECUTED 2002a18: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED 2002a1c: 12 80 00 05 bne 2002a30 <== NOT EXECUTED 2002a20: 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 ); 2002a24: d0 04 20 30 ld [ %l0 + 0x30 ], %o0 <== NOT EXECUTED 2002a28: 7f ff ff cd call 200295c <== NOT EXECUTED 2002a2c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED return TRUE; } 2002a30: 81 c7 e0 08 ret <== NOT EXECUTED 2002a34: 81 e8 00 00 restore <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { pattern_ok = (!memcmp( 2002a38: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED 2002a3c: 13 00 80 77 sethi %hi(0x201dc00), %o1 <== NOT EXECUTED 2002a40: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 2002a44: 40 00 39 30 call 2010f04 <== NOT EXECUTED 2002a48: 92 12 61 6c or %o1, 0x16c, %o1 <== NOT EXECUTED 2002a4c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 2002a50: 92 60 3f ff subx %g0, -1, %o1 <== NOT EXECUTED 2002a54: 10 bf ff ee b 2002a0c <== NOT EXECUTED 2002a58: 82 10 00 09 mov %o1, %g1 <== NOT EXECUTED 02002940 : } void rtems_stack_checker_report_usage( void ) { rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 2002940: 13 00 80 10 sethi %hi(0x2004000), %o1 <== NOT EXECUTED 2002944: 90 10 20 00 clr %o0 <== NOT EXECUTED 2002948: 92 12 62 b8 or %o1, 0x2b8, %o1 <== NOT EXECUTED 200294c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2002950: 7f ff ff e2 call 20028d8 <== NOT EXECUTED 2002954: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2002958: 01 00 00 00 nop 020028d8 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 20028d8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if (Stack_check_Initialized == 0) 20028dc: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED 20028e0: c4 00 61 fc ld [ %g1 + 0x1fc ], %g2 ! 201d9fc <== NOT EXECUTED 20028e4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20028e8: 02 80 00 14 be 2002938 <== NOT EXECUTED 20028ec: 23 00 80 76 sethi %hi(0x201d800), %l1 <== NOT EXECUTED return; print_context = context; print_handler = print; 20028f0: 21 00 80 76 sethi %hi(0x201d800), %l0 <== NOT EXECUTED ) { if (Stack_check_Initialized == 0) return; print_context = context; 20028f4: f0 24 62 00 st %i0, [ %l1 + 0x200 ] <== NOT EXECUTED print_handler = print; 20028f8: f2 24 22 04 st %i1, [ %l0 + 0x204 ] <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 20028fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2002900: 13 00 80 6c sethi %hi(0x201b000), %o1 <== NOT EXECUTED 2002904: 9f c6 40 00 call %i1 <== NOT EXECUTED 2002908: 92 12 60 08 or %o1, 8, %o1 ! 201b008 <== NOT EXECUTED (*print)( context, 200290c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2002910: 13 00 80 6c sethi %hi(0x201b000), %o1 <== NOT EXECUTED 2002914: 9f c6 40 00 call %i1 <== NOT EXECUTED 2002918: 92 12 60 20 or %o1, 0x20, %o1 ! 201b020 <== 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 ); 200291c: 11 00 80 09 sethi %hi(0x2002400), %o0 <== NOT EXECUTED 2002920: 40 00 18 bc call 2008c10 <== NOT EXECUTED 2002924: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20027c8 <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 2002928: 7f ff ff a8 call 20027c8 <== NOT EXECUTED 200292c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED print_context = NULL; 2002930: c0 24 62 00 clr [ %l1 + 0x200 ] <== NOT EXECUTED print_handler = NULL; 2002934: c0 24 22 04 clr [ %l0 + 0x204 ] <== NOT EXECUTED 2002938: 81 c7 e0 08 ret <== NOT EXECUTED 200293c: 81 e8 00 00 restore <== NOT EXECUTED 02002b2c : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 2002b2c: 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; 2002b30: c4 06 20 d4 ld [ %i0 + 0xd4 ], %g2 ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 2002b34: 80 a7 80 02 cmp %fp, %g2 2002b38: 0a 80 00 07 bcs 2002b54 2002b3c: 90 00 a0 08 add %g2, 8, %o0 return FALSE; } if ( sp > (the_stack->area + the_stack->size) ) { 2002b40: c2 06 20 d0 ld [ %i0 + 0xd0 ], %g1 2002b44: 82 00 80 01 add %g2, %g1, %g1 2002b48: 80 a7 80 01 cmp %fp, %g1 2002b4c: 28 80 00 0a bleu,a 2002b74 2002b50: 13 00 80 77 sethi %hi(0x201dc00), %o1 /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 2002b54: 13 00 80 77 sethi %hi(0x201dc00), %o1 <== NOT EXECUTED 2002b58: 94 10 20 10 mov 0x10, %o2 <== NOT EXECUTED 2002b5c: 40 00 38 ea call 2010f04 <== NOT EXECUTED 2002b60: 92 12 61 6c or %o1, 0x16c, %o1 <== NOT EXECUTED 2002b64: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED 2002b68: b2 60 3f ff subx %g0, -1, %i1 <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 2002b6c: 7f ff ff 7c call 200295c <== NOT EXECUTED 2002b70: 81 e8 00 00 restore <== NOT EXECUTED /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 2002b74: 94 10 20 10 mov 0x10, %o2 2002b78: 40 00 38 e3 call 2010f04 2002b7c: 92 12 61 6c or %o1, 0x16c, %o1 2002b80: 80 a2 20 00 cmp %o0, 0 2002b84: 02 80 00 04 be 2002b94 2002b88: 01 00 00 00 nop (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 2002b8c: 7f ff ff 74 call 200295c <== NOT EXECUTED 2002b90: 93 e8 20 00 restore %g0, 0, %o1 <== NOT EXECUTED 2002b94: 81 c7 e0 08 ret 2002b98: 81 e8 00 00 restore 02008a38 : const char * rtems_status_text( rtems_status_code status ) { 2008a38: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 2008a3c: 11 00 80 a4 sethi %hi(0x2029000), %o0 <== NOT EXECUTED 2008a40: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20293a0 <== NOT EXECUTED 2008a44: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2008a48: 40 00 31 a3 call 20150d4 <== NOT EXECUTED 2008a4c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2008a50: 01 00 00 00 nop 020063d8 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 20063d8: 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 ) ) { 20063dc: 92 96 20 00 orcc %i0, 0, %o1 20063e0: 12 80 00 20 bne 2006460 20063e4: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20063e8: 21 00 80 66 sethi %hi(0x2019800), %l0 20063ec: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 20063f0: 82 00 60 01 inc %g1 20063f4: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 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; 20063f8: 03 00 80 66 sethi %hi(0x2019800), %g1 20063fc: f0 00 61 20 ld [ %g1 + 0x120 ], %i0 ! 2019920 <_Thread_Executing> 2006400: 07 00 80 65 sethi %hi(0x2019400), %g3 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; 2006404: c0 27 bf f4 clr [ %fp + -12 ] 2006408: a2 10 e3 a0 or %g3, 0x3a0, %l1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_information = _Objects_Get_information( the_thread->Object.id ); 200640c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2006410: 85 30 60 16 srl %g1, 0x16, %g2 2006414: 84 08 a0 1c and %g2, 0x1c, %g2 2006418: c6 04 40 02 ld [ %l1 + %g2 ], %g3 200641c: 83 30 60 1b srl %g1, 0x1b, %g1 2006420: 83 28 60 02 sll %g1, 2, %g1 2006424: d0 00 c0 01 ld [ %g3 + %g1 ], %o0 if ( !the_information ) { 2006428: 80 a2 20 00 cmp %o0, 0 200642c: 12 80 00 13 bne 2006478 2006430: 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 ) 2006434: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 <== NOT EXECUTED 2006438: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200643c: c2 24 20 40 st %g1, [ %l0 + 0x40 ] <== NOT EXECUTED 2006440: c4 04 20 40 ld [ %l0 + 0x40 ], %g2 <== NOT EXECUTED 2006444: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2006448: 12 80 00 04 bne 2006458 <== NOT EXECUTED 200644c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Dispatch(); 2006450: 40 00 0b 93 call 200929c <_Thread_Dispatch> <== NOT EXECUTED 2006454: 01 00 00 00 nop <== NOT EXECUTED 2006458: 81 c7 e0 08 ret 200645c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2006460: 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 ) { 2006464: 80 a0 a0 04 cmp %g2, 4 2006468: 08 80 00 1b bleu 20064d4 200646c: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006470: 81 c7 e0 08 ret <== NOT EXECUTED 2006474: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ID; /* This should never happen if _Thread_Get() works right */ } _Thread_Close( the_information, the_thread ); 2006478: 40 00 0a ff call 2009074 <_Thread_Close> 200647c: 92 10 00 18 mov %i0, %o1 2006480: c4 06 20 08 ld [ %i0 + 8 ], %g2 2006484: 92 10 00 18 mov %i0, %o1 if ( !_Objects_Is_class_valid( the_class ) ) return NULL; the_api = _Objects_Get_API( id ); return _Objects_Information_table[ the_api ][ the_class ]; 2006488: 83 30 a0 16 srl %g2, 0x16, %g1 200648c: 82 08 60 1c and %g1, 0x1c, %g1 2006490: c6 04 40 01 ld [ %l1 + %g1 ], %g3 2006494: 85 30 a0 1b srl %g2, 0x1b, %g2 2006498: 85 28 a0 02 sll %g2, 2, %g2 200649c: 40 00 06 09 call 2007cc0 <_Objects_Free> 20064a0: d0 00 c0 02 ld [ %g3 + %g2 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20064a4: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20064a8: b0 10 20 00 clr %i0 20064ac: 82 00 7f ff add %g1, -1, %g1 20064b0: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 20064b4: c4 04 20 40 ld [ %l0 + 0x40 ], %g2 20064b8: 80 a0 a0 00 cmp %g2, 0 20064bc: 12 80 00 04 bne 20064cc 20064c0: 01 00 00 00 nop _Thread_Dispatch(); 20064c4: 40 00 0b 76 call 200929c <_Thread_Dispatch> 20064c8: 01 00 00 00 nop 20064cc: 81 c7 e0 08 ret 20064d0: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 20064d4: 80 a0 60 01 cmp %g1, 1 20064d8: 12 bf ff e0 bne 2006458 20064dc: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 20064e0: 85 28 a0 02 sll %g2, 2, %g2 20064e4: 07 00 80 65 sethi %hi(0x2019400), %g3 20064e8: a2 10 e3 a0 or %g3, 0x3a0, %l1 ! 20197a0 <_Objects_Information_table> 20064ec: c2 04 40 02 ld [ %l1 + %g2 ], %g1 20064f0: d0 00 60 04 ld [ %g1 + 4 ], %o0 if ( !information ) { 20064f4: 80 a2 20 00 cmp %o0, 0 20064f8: 02 bf ff f5 be 20064cc 20064fc: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006500: 40 00 06 33 call 2007dcc <_Objects_Get> 2006504: 94 07 bf f4 add %fp, -12, %o2 register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006508: c2 07 bf f4 ld [ %fp + -12 ], %g1 200650c: b0 10 00 08 mov %o0, %i0 2006510: 80 a0 60 00 cmp %g1, 0 2006514: 02 bf ff be be 200640c 2006518: 21 00 80 66 sethi %hi(0x2019800), %l0 200651c: 80 a0 60 02 cmp %g1, 2 2006520: 18 bf ff ce bgu 2006458 2006524: b0 10 20 19 mov 0x19, %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006528: 81 c7 e0 08 ret 200652c: 91 e8 20 04 restore %g0, 4, %o0 02007ce4 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 2007ce4: 9d e3 bf 90 save %sp, -112, %sp 2007ce8: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !note ) 2007cec: 80 a6 a0 00 cmp %i2, 0 2007cf0: 02 80 00 3b be 2007ddc 2007cf4: 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 ) 2007cf8: 80 a6 60 0f cmp %i1, 0xf 2007cfc: 18 80 00 38 bgu 2007ddc 2007d00: 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 ) || 2007d04: 80 a2 60 00 cmp %o1, 0 2007d08: 12 80 00 09 bne 2007d2c 2007d0c: 07 00 80 7c sethi %hi(0x201f000), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007d10: c2 00 e2 90 ld [ %g3 + 0x290 ], %g1 ! 201f290 <_Thread_Executing> 2007d14: 87 2e 60 02 sll %i1, 2, %g3 2007d18: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 2007d1c: c2 00 80 03 ld [ %g2 + %g3 ], %g1 2007d20: c2 26 80 00 st %g1, [ %i2 ] 2007d24: 81 c7 e0 08 ret 2007d28: 91 e8 20 00 restore %g0, 0, %o0 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007d2c: c2 00 e2 90 ld [ %g3 + 0x290 ], %g1 2007d30: c4 00 60 08 ld [ %g1 + 8 ], %g2 2007d34: 80 a2 40 02 cmp %o1, %g2 2007d38: 22 bf ff f8 be,a 2007d18 2007d3c: 87 2e 60 02 sll %i1, 2, %g3 <== 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); 2007d40: 83 32 60 18 srl %o1, 0x18, %g1 2007d44: 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 ) { 2007d48: 80 a0 a0 04 cmp %g2, 4 2007d4c: 08 80 00 04 bleu 2007d5c 2007d50: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007d54: 81 c7 e0 08 ret <== NOT EXECUTED 2007d58: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007d5c: 80 a0 60 01 cmp %g1, 1 2007d60: 12 80 00 1f bne 2007ddc 2007d64: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007d68: 83 28 a0 02 sll %g2, 2, %g1 2007d6c: 05 00 80 7c sethi %hi(0x201f000), %g2 2007d70: 84 10 a1 10 or %g2, 0x110, %g2 ! 201f110 <_Objects_Information_table> 2007d74: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007d78: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007d7c: 80 a2 20 00 cmp %o0, 0 2007d80: 02 80 00 17 be 2007ddc 2007d84: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007d88: 40 00 07 79 call 2009b6c <_Objects_Get> 2007d8c: 94 07 bf f4 add %fp, -12, %o2 *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007d90: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d94: 80 a0 60 00 cmp %g1, 0 2007d98: 12 80 00 13 bne 2007de4 2007d9c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 2007da0: c6 02 21 70 ld [ %o0 + 0x170 ], %g3 2007da4: 83 2e 60 02 sll %i1, 2, %g1 2007da8: c4 00 c0 01 ld [ %g3 + %g1 ], %g2 2007dac: c4 26 80 00 st %g2, [ %i2 ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007db0: 07 00 80 7c sethi %hi(0x201f000), %g3 2007db4: c2 00 e1 b0 ld [ %g3 + 0x1b0 ], %g1 ! 201f1b0 <_Thread_Dispatch_disable_level> 2007db8: b0 10 20 00 clr %i0 2007dbc: 82 00 7f ff add %g1, -1, %g1 2007dc0: c2 20 e1 b0 st %g1, [ %g3 + 0x1b0 ] 2007dc4: c4 00 e1 b0 ld [ %g3 + 0x1b0 ], %g2 2007dc8: 80 a0 a0 00 cmp %g2, 0 2007dcc: 12 80 00 04 bne 2007ddc 2007dd0: 01 00 00 00 nop _Thread_Dispatch(); 2007dd4: 40 00 0c 5e call 200af4c <_Thread_Dispatch> 2007dd8: 01 00 00 00 nop 2007ddc: 81 c7 e0 08 ret 2007de0: 81 e8 00 00 restore *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007de4: 18 bf ff fe bgu 2007ddc <== NOT EXECUTED 2007de8: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 2007dec: 81 c7 e0 08 ret <== NOT EXECUTED 2007df0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02006bc0 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 2006bc0: 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 ) ) { 2006bc4: 92 96 20 00 orcc %i0, 0, %o1 2006bc8: 12 80 00 19 bne 2006c2c 2006bcc: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2006bd0: 05 00 80 74 sethi %hi(0x201d000), %g2 <== NOT EXECUTED 2006bd4: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1 ! 201d020 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2006bd8: 82 00 60 01 inc %g1 <== NOT EXECUTED 2006bdc: c2 20 a0 20 st %g1, [ %g2 + 0x20 ] <== 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; 2006be0: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED 2006be4: d0 00 61 00 ld [ %g1 + 0x100 ], %o0 ! 201d100 <_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; 2006be8: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2006bec: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2006bf0: 80 88 60 02 btst 2, %g1 2006bf4: 02 80 00 15 be 2006c48 2006bf8: 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 ) 2006bfc: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1 2006c00: b0 10 20 0f mov 0xf, %i0 2006c04: 82 00 7f ff add %g1, -1, %g1 2006c08: c2 20 a0 20 st %g1, [ %g2 + 0x20 ] 2006c0c: c4 00 a0 20 ld [ %g2 + 0x20 ], %g2 2006c10: 80 a0 a0 00 cmp %g2, 0 2006c14: 12 80 00 0b bne 2006c40 2006c18: 01 00 00 00 nop _Thread_Dispatch(); 2006c1c: 40 00 0b 80 call 2009a1c <_Thread_Dispatch> 2006c20: 01 00 00 00 nop 2006c24: 81 c7 e0 08 ret 2006c28: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2006c2c: 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 ) { 2006c30: 80 a0 a0 04 cmp %g2, 4 2006c34: 08 80 00 08 bleu 2006c54 2006c38: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006c3c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2006c40: 81 c7 e0 08 ret <== NOT EXECUTED 2006c44: 81 e8 00 00 restore <== 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 ) 2006c48: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1 2006c4c: 10 bf ff ee b 2006c04 2006c50: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2006c54: 80 a0 60 01 cmp %g1, 1 2006c58: 12 bf ff f3 bne 2006c24 2006c5c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006c60: 83 28 a0 02 sll %g2, 2, %g1 2006c64: 05 00 80 73 sethi %hi(0x201cc00), %g2 2006c68: 84 10 a3 80 or %g2, 0x380, %g2 ! 201cf80 <_Objects_Information_table> 2006c6c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2006c70: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2006c74: 80 a2 20 00 cmp %o0, 0 2006c78: 02 bf ff f2 be 2006c40 2006c7c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006c80: 40 00 06 6f call 200863c <_Objects_Get> 2006c84: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006c88: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006c8c: 80 a0 60 00 cmp %g1, 0 2006c90: 02 bf ff d7 be 2006bec 2006c94: 05 00 80 74 sethi %hi(0x201d000), %g2 2006c98: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2006c9c: 18 bf ff e2 bgu 2006c24 <== NOT EXECUTED 2006ca0: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2006ca4: 81 c7 e0 08 ret <== NOT EXECUTED 2006ca8: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200719c : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 200719c: 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 ) ) { 20071a0: 92 96 20 00 orcc %i0, 0, %o1 20071a4: 12 80 00 1b bne 2007210 20071a8: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20071ac: 21 00 80 75 sethi %hi(0x201d400), %l0 20071b0: c2 04 20 f0 ld [ %l0 + 0xf0 ], %g1 ! 201d4f0 <_Thread_Dispatch_disable_level> 20071b4: 82 00 60 01 inc %g1 20071b8: c2 24 20 f0 st %g1, [ %l0 + 0xf0 ] 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; 20071bc: 03 00 80 75 sethi %hi(0x201d400), %g1 20071c0: d0 00 61 d0 ld [ %g1 + 0x1d0 ], %o0 ! 201d5d0 <_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; 20071c4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 20071c8: 94 10 00 19 mov %i1, %o2 20071cc: 40 00 0e 80 call 200abcc <_Thread_Restart> 20071d0: 92 10 20 00 clr %o1 20071d4: 80 a2 20 00 cmp %o0, 0 20071d8: 12 80 00 15 bne 200722c 20071dc: 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 ) 20071e0: c2 04 20 f0 ld [ %l0 + 0xf0 ], %g1 20071e4: b0 10 20 0e mov 0xe, %i0 20071e8: 82 00 7f ff add %g1, -1, %g1 20071ec: c2 24 20 f0 st %g1, [ %l0 + 0xf0 ] 20071f0: c4 04 20 f0 ld [ %l0 + 0xf0 ], %g2 20071f4: 80 a0 a0 00 cmp %g2, 0 20071f8: 12 80 00 0b bne 2007224 20071fc: 01 00 00 00 nop _Thread_Dispatch(); 2007200: 40 00 0b 54 call 2009f50 <_Thread_Dispatch> 2007204: 01 00 00 00 nop 2007208: 81 c7 e0 08 ret 200720c: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2007210: 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 ) { 2007214: 80 a0 a0 04 cmp %g2, 4 2007218: 08 80 00 08 bleu 2007238 200721c: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007220: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007224: 81 c7 e0 08 ret <== NOT EXECUTED 2007228: 81 e8 00 00 restore <== 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 ) 200722c: c2 04 20 f0 ld [ %l0 + 0xf0 ], %g1 2007230: 10 bf ff ee b 20071e8 2007234: b0 10 20 00 clr %i0 *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007238: 80 a0 60 01 cmp %g1, 1 200723c: 12 bf ff f3 bne 2007208 2007240: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007244: 83 28 a0 02 sll %g2, 2, %g1 2007248: 05 00 80 75 sethi %hi(0x201d400), %g2 200724c: 84 10 a0 50 or %g2, 0x50, %g2 ! 201d450 <_Objects_Information_table> 2007250: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007254: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007258: 80 a2 20 00 cmp %o0, 0 200725c: 02 bf ff f2 be 2007224 2007260: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007264: 40 00 06 43 call 2008b70 <_Objects_Get> 2007268: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200726c: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007270: 80 a0 60 00 cmp %g1, 0 2007274: 02 bf ff d5 be 20071c8 2007278: 21 00 80 75 sethi %hi(0x201d400), %l0 200727c: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007280: 18 bf ff e2 bgu 2007208 <== NOT EXECUTED 2007284: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2007288: 81 c7 e0 08 ret <== NOT EXECUTED 200728c: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 02007c58 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 2007c58: 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 ) ) { 2007c5c: 92 96 20 00 orcc %i0, 0, %o1 2007c60: 12 80 00 19 bne 2007cc4 2007c64: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007c68: 21 00 80 99 sethi %hi(0x2026400), %l0 2007c6c: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 ! 2026550 <_Thread_Dispatch_disable_level> 2007c70: 82 00 60 01 inc %g1 2007c74: c2 24 21 50 st %g1, [ %l0 + 0x150 ] 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; 2007c78: 03 00 80 99 sethi %hi(0x2026400), %g1 2007c7c: d0 00 62 30 ld [ %g1 + 0x230 ], %o0 ! 2026630 <_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; 2007c80: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 2007c84: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007c88: 80 88 60 02 btst 2, %g1 2007c8c: 12 80 00 2b bne 2007d38 2007c90: 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 ) 2007c94: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 2007c98: b0 10 20 0e mov 0xe, %i0 2007c9c: 82 00 7f ff add %g1, -1, %g1 2007ca0: c2 24 21 50 st %g1, [ %l0 + 0x150 ] 2007ca4: c4 04 21 50 ld [ %l0 + 0x150 ], %g2 2007ca8: 80 a0 a0 00 cmp %g2, 0 2007cac: 12 80 00 0b bne 2007cd8 2007cb0: 01 00 00 00 nop _Thread_Dispatch(); 2007cb4: 40 00 0c 39 call 200ad98 <_Thread_Dispatch> 2007cb8: 01 00 00 00 nop 2007cbc: 81 c7 e0 08 ret 2007cc0: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 2007cc4: 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 ) { 2007cc8: 80 a0 a0 04 cmp %g2, 4 2007ccc: 08 80 00 05 bleu 2007ce0 2007cd0: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007cd4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007cd8: 81 c7 e0 08 ret 2007cdc: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007ce0: 80 a0 60 01 cmp %g1, 1 2007ce4: 12 bf ff f6 bne 2007cbc 2007ce8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007cec: 83 28 a0 02 sll %g2, 2, %g1 2007cf0: 05 00 80 99 sethi %hi(0x2026400), %g2 2007cf4: 84 10 a0 b0 or %g2, 0xb0, %g2 ! 20264b0 <_Objects_Information_table> 2007cf8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007cfc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007d00: 80 a2 20 00 cmp %o0, 0 2007d04: 02 bf ff f5 be 2007cd8 2007d08: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007d0c: 40 00 07 2b call 20099b8 <_Objects_Get> 2007d10: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007d14: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007d18: 80 a0 60 00 cmp %g1, 0 2007d1c: 02 bf ff da be 2007c84 2007d20: 21 00 80 99 sethi %hi(0x2026400), %l0 2007d24: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007d28: 18 bf ff e5 bgu 2007cbc <== NOT EXECUTED 2007d2c: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2007d30: 81 c7 e0 08 ret <== NOT EXECUTED 2007d34: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 2007d38: 40 00 0f 4d call 200ba6c <_Thread_Resume> 2007d3c: 92 10 20 01 mov 1, %o1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007d40: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 2007d44: 10 bf ff d6 b 2007c9c 2007d48: b0 10 20 00 clr %i0 02007fc4 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 2007fc4: 9d e3 bf 90 save %sp, -112, %sp 2007fc8: 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 ) 2007fcc: 80 a6 60 0f cmp %i1, 0xf 2007fd0: 18 80 00 36 bgu 20080a8 2007fd4: 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 ) || 2007fd8: 80 a2 60 00 cmp %o1, 0 2007fdc: 12 80 00 08 bne 2007ffc 2007fe0: 07 00 80 7c sethi %hi(0x201f000), %g3 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2007fe4: c2 00 e2 90 ld [ %g3 + 0x290 ], %g1 ! 201f290 <_Thread_Executing> <== NOT EXECUTED 2007fe8: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 <== NOT EXECUTED 2007fec: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED 2007ff0: f4 20 80 03 st %i2, [ %g2 + %g3 ] <== NOT EXECUTED 2007ff4: 81 c7 e0 08 ret <== NOT EXECUTED 2007ff8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 2007ffc: c2 00 e2 90 ld [ %g3 + 0x290 ], %g1 2008000: c4 00 60 08 ld [ %g1 + 8 ], %g2 2008004: 80 a2 40 02 cmp %o1, %g2 2008008: 22 bf ff f9 be,a 2007fec 200800c: c4 00 61 70 ld [ %g1 + 0x170 ], %g2 <== NOT EXECUTED 2008010: 83 32 60 18 srl %o1, 0x18, %g1 2008014: 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 ) { 2008018: 80 a0 a0 04 cmp %g2, 4 200801c: 08 80 00 04 bleu 200802c 2008020: 83 32 60 1b srl %o1, 0x1b, %g1 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008024: 81 c7 e0 08 ret <== NOT EXECUTED 2008028: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200802c: 80 a0 60 01 cmp %g1, 1 2008030: 12 80 00 1e bne 20080a8 2008034: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2008038: 83 28 a0 02 sll %g2, 2, %g1 200803c: 05 00 80 7c sethi %hi(0x201f000), %g2 2008040: 84 10 a1 10 or %g2, 0x110, %g2 ! 201f110 <_Objects_Information_table> 2008044: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2008048: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 200804c: 80 a2 20 00 cmp %o0, 0 2008050: 02 80 00 16 be 20080a8 2008054: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2008058: 40 00 06 c5 call 2009b6c <_Objects_Get> 200805c: 94 07 bf f4 add %fp, -12, %o2 api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 2008060: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008064: 80 a0 60 00 cmp %g1, 0 2008068: 12 80 00 12 bne 20080b0 200806c: 80 a0 60 02 cmp %g1, 2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 2008070: c4 02 21 70 ld [ %o0 + 0x170 ], %g2 2008074: 83 2e 60 02 sll %i1, 2, %g1 2008078: 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 ) 200807c: 07 00 80 7c sethi %hi(0x201f000), %g3 2008080: c2 00 e1 b0 ld [ %g3 + 0x1b0 ], %g1 ! 201f1b0 <_Thread_Dispatch_disable_level> 2008084: b0 10 20 00 clr %i0 2008088: 82 00 7f ff add %g1, -1, %g1 200808c: c2 20 e1 b0 st %g1, [ %g3 + 0x1b0 ] 2008090: c4 00 e1 b0 ld [ %g3 + 0x1b0 ], %g2 2008094: 80 a0 a0 00 cmp %g2, 0 2008098: 12 80 00 04 bne 20080a8 200809c: 01 00 00 00 nop _Thread_Dispatch(); 20080a0: 40 00 0b ab call 200af4c <_Thread_Dispatch> 20080a4: 01 00 00 00 nop 20080a8: 81 c7 e0 08 ret 20080ac: 81 e8 00 00 restore api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 20080b0: 18 bf ff fe bgu 20080a8 <== NOT EXECUTED 20080b4: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 20080b8: 81 c7 e0 08 ret <== NOT EXECUTED 20080bc: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200d5ac : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 200d5ac: 9d e3 bf 90 save %sp, -112, %sp register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 200d5b0: 80 a6 60 00 cmp %i1, 0 200d5b4: 02 80 00 06 be 200d5cc 200d5b8: 92 10 00 18 mov %i0, %o1 200d5bc: 82 06 7f ff add %i1, -1, %g1 200d5c0: 80 a0 60 fe cmp %g1, 0xfe 200d5c4: 18 80 00 26 bgu 200d65c 200d5c8: b0 10 20 13 mov 0x13, %i0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 200d5cc: 80 a6 a0 00 cmp %i2, 0 200d5d0: 02 80 00 23 be 200d65c 200d5d4: 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 ) ) { 200d5d8: 80 a2 60 00 cmp %o1, 0 200d5dc: 12 80 00 22 bne 200d664 200d5e0: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200d5e4: 21 00 80 ad sethi %hi(0x202b400), %l0 200d5e8: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 ! 202b660 <_Thread_Dispatch_disable_level> 200d5ec: 82 00 60 01 inc %g1 200d5f0: c2 24 22 60 st %g1, [ %l0 + 0x260 ] 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; 200d5f4: 03 00 80 ad sethi %hi(0x202b400), %g1 200d5f8: d0 00 63 40 ld [ %g1 + 0x340 ], %o0 ! 202b740 <_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; 200d5fc: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: /* XXX convert from core priority */ *old_priority = the_thread->current_priority; 200d600: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 200d604: 80 a6 60 00 cmp %i1, 0 200d608: 02 80 00 0d be 200d63c 200d60c: c2 26 80 00 st %g1, [ %i2 ] the_thread->real_priority = new_priority; if ( the_thread->resource_count == 0 || 200d610: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 200d614: 80 a0 60 00 cmp %g1, 0 200d618: 02 80 00 06 be 200d630 200d61c: f2 22 20 18 st %i1, [ %o0 + 0x18 ] 200d620: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 200d624: 80 a6 40 01 cmp %i1, %g1 200d628: 1a 80 00 05 bcc 200d63c 200d62c: 01 00 00 00 nop the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 200d630: 92 10 00 19 mov %i1, %o1 200d634: 40 00 0a 7f call 2010030 <_Thread_Change_priority> 200d638: 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 ) 200d63c: c2 04 22 60 ld [ %l0 + 0x260 ], %g1 200d640: b0 10 20 00 clr %i0 200d644: 82 00 7f ff add %g1, -1, %g1 200d648: c2 24 22 60 st %g1, [ %l0 + 0x260 ] 200d64c: c4 04 22 60 ld [ %l0 + 0x260 ], %g2 200d650: 80 a0 a0 00 cmp %g2, 0 200d654: 02 80 00 0a be 200d67c 200d658: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200d65c: 81 c7 e0 08 ret 200d660: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 200d664: 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 ) { 200d668: 80 a0 a0 04 cmp %g2, 4 200d66c: 08 80 00 08 bleu 200d68c 200d670: 83 32 60 1b srl %o1, 0x1b, %g1 200d674: 81 c7 e0 08 ret <== NOT EXECUTED 200d678: 91 e8 20 04 restore %g0, 4, %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 ) _Thread_Dispatch(); 200d67c: 40 00 0b 9d call 20104f0 <_Thread_Dispatch> 200d680: 01 00 00 00 nop 200d684: 81 c7 e0 08 ret 200d688: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 200d68c: 80 a0 60 01 cmp %g1, 1 200d690: 12 bf ff f3 bne 200d65c 200d694: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 200d698: 83 28 a0 02 sll %g2, 2, %g1 200d69c: 05 00 80 ad sethi %hi(0x202b400), %g2 200d6a0: 84 10 a1 c0 or %g2, 0x1c0, %g2 ! 202b5c0 <_Objects_Information_table> 200d6a4: c6 00 80 01 ld [ %g2 + %g1 ], %g3 200d6a8: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 200d6ac: 80 a2 20 00 cmp %o0, 0 200d6b0: 02 bf ff f5 be 200d684 200d6b4: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 200d6b8: 40 00 06 5a call 200f020 <_Objects_Get> 200d6bc: 94 07 bf f4 add %fp, -12, %o2 if ( !old_priority ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 200d6c0: c2 07 bf f4 ld [ %fp + -12 ], %g1 200d6c4: 80 a0 60 00 cmp %g1, 0 200d6c8: 02 bf ff ce be 200d600 200d6cc: 21 00 80 ad sethi %hi(0x202b400), %l0 200d6d0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200d6d4: 18 bf ff e2 bgu 200d65c <== NOT EXECUTED 200d6d8: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 200d6dc: 81 c7 e0 08 ret <== NOT EXECUTED 200d6e0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200666c : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 200666c: 9d e3 bf 90 save %sp, -112, %sp 2006670: 92 10 00 18 mov %i0, %o1 register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 2006674: 80 a6 60 00 cmp %i1, 0 2006678: 02 80 00 1e be 20066f0 200667c: 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 ) ) { 2006680: 80 a2 60 00 cmp %o1, 0 2006684: 12 80 00 1d bne 20066f8 2006688: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200668c: 21 00 80 66 sethi %hi(0x2019800), %l0 2006690: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 ! 2019840 <_Thread_Dispatch_disable_level> 2006694: 82 00 60 01 inc %g1 2006698: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 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; 200669c: 03 00 80 66 sethi %hi(0x2019800), %g1 20066a0: d0 00 61 20 ld [ %g1 + 0x120 ], %o0 ! 2019920 <_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; 20066a4: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( _Thread_Start( 20066a8: 94 10 00 19 mov %i1, %o2 20066ac: 98 10 00 1a mov %i2, %o4 20066b0: 92 10 20 00 clr %o1 20066b4: 40 00 0f 03 call 200a2c0 <_Thread_Start> 20066b8: 96 10 20 00 clr %o3 20066bc: 80 a2 20 00 cmp %o0, 0 20066c0: 12 80 00 2b bne 200676c 20066c4: 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 ) 20066c8: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 20066cc: b0 10 20 0e mov 0xe, %i0 20066d0: 82 00 7f ff add %g1, -1, %g1 20066d4: c2 24 20 40 st %g1, [ %l0 + 0x40 ] 20066d8: c4 04 20 40 ld [ %l0 + 0x40 ], %g2 20066dc: 80 a0 a0 00 cmp %g2, 0 20066e0: 12 80 00 0b bne 200670c 20066e4: 01 00 00 00 nop _Thread_Dispatch(); 20066e8: 40 00 0a ed call 200929c <_Thread_Dispatch> 20066ec: 01 00 00 00 nop 20066f0: 81 c7 e0 08 ret 20066f4: 81 e8 00 00 restore */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 20066f8: 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 ) { 20066fc: 80 a0 a0 04 cmp %g2, 4 2006700: 08 80 00 05 bleu 2006714 2006704: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2006708: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 200670c: 81 c7 e0 08 ret 2006710: 81 e8 00 00 restore *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2006714: 80 a0 60 01 cmp %g1, 1 2006718: 12 bf ff f6 bne 20066f0 200671c: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2006720: 83 28 a0 02 sll %g2, 2, %g1 2006724: 05 00 80 65 sethi %hi(0x2019400), %g2 2006728: 84 10 a3 a0 or %g2, 0x3a0, %g2 ! 20197a0 <_Objects_Information_table> 200672c: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2006730: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2006734: 80 a2 20 00 cmp %o0, 0 2006738: 02 bf ff f5 be 200670c 200673c: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2006740: 40 00 05 a3 call 2007dcc <_Objects_Get> 2006744: 94 07 bf f4 add %fp, -12, %o2 if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2006748: c2 07 bf f4 ld [ %fp + -12 ], %g1 200674c: 80 a0 60 00 cmp %g1, 0 2006750: 02 bf ff d6 be 20066a8 2006754: 21 00 80 66 sethi %hi(0x2019800), %l0 2006758: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200675c: 18 bf ff e5 bgu 20066f0 <== NOT EXECUTED 2006760: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2006764: 81 c7 e0 08 ret <== NOT EXECUTED 2006768: 91 e8 20 04 restore %g0, 4, %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 ) 200676c: c2 04 20 40 ld [ %l0 + 0x40 ], %g1 2006770: 10 bf ff d8 b 20066d0 2006774: b0 10 20 00 clr %i0 02007e58 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 2007e58: 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 ) ) { 2007e5c: 92 96 20 00 orcc %i0, 0, %o1 2007e60: 12 80 00 19 bne 2007ec4 2007e64: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2007e68: 21 00 80 99 sethi %hi(0x2026400), %l0 2007e6c: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 ! 2026550 <_Thread_Dispatch_disable_level> 2007e70: 82 00 60 01 inc %g1 2007e74: c2 24 21 50 st %g1, [ %l0 + 0x150 ] 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; 2007e78: 03 00 80 99 sethi %hi(0x2026400), %g1 2007e7c: d0 00 62 30 ld [ %g1 + 0x230 ], %o0 ! 2026630 <_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; 2007e80: c0 27 bf f4 clr [ %fp + -12 ] case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 2007e84: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 2007e88: 80 88 60 02 btst 2, %g1 2007e8c: 02 80 00 2b be 2007f38 2007e90: 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 ) 2007e94: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 2007e98: b0 10 20 0f mov 0xf, %i0 2007e9c: 82 00 7f ff add %g1, -1, %g1 2007ea0: c2 24 21 50 st %g1, [ %l0 + 0x150 ] 2007ea4: c4 04 21 50 ld [ %l0 + 0x150 ], %g2 2007ea8: 80 a0 a0 00 cmp %g2, 0 2007eac: 12 80 00 0b bne 2007ed8 2007eb0: 01 00 00 00 nop _Thread_Dispatch(); 2007eb4: 40 00 0b b9 call 200ad98 <_Thread_Dispatch> 2007eb8: 01 00 00 00 nop 2007ebc: 81 c7 e0 08 ret 2007ec0: 81 e8 00 00 restore 2007ec4: 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 ) { 2007ec8: 80 a0 a0 04 cmp %g2, 4 2007ecc: 08 80 00 05 bleu 2007ee0 2007ed0: 83 32 60 1b srl %o1, 0x1b, %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) _Thread_Dispatch(); 2007ed4: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_ALREADY_SUSPENDED; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2007ed8: 81 c7 e0 08 ret <== NOT EXECUTED 2007edc: 81 e8 00 00 restore <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 2007ee0: 80 a0 60 01 cmp %g1, 1 2007ee4: 12 bf ff f6 bne 2007ebc 2007ee8: b0 10 20 04 mov 4, %i0 *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 2007eec: 83 28 a0 02 sll %g2, 2, %g1 2007ef0: 05 00 80 99 sethi %hi(0x2026400), %g2 2007ef4: 84 10 a0 b0 or %g2, 0xb0, %g2 ! 20264b0 <_Objects_Information_table> 2007ef8: c6 00 80 01 ld [ %g2 + %g1 ], %g3 2007efc: d0 00 e0 04 ld [ %g3 + 4 ], %o0 if ( !information ) { 2007f00: 80 a2 20 00 cmp %o0, 0 2007f04: 02 bf ff f5 be 2007ed8 2007f08: 01 00 00 00 nop *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 2007f0c: 40 00 06 ab call 20099b8 <_Objects_Get> 2007f10: 94 07 bf f4 add %fp, -12, %o2 { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 2007f14: c2 07 bf f4 ld [ %fp + -12 ], %g1 2007f18: 80 a0 60 00 cmp %g1, 0 2007f1c: 02 bf ff da be 2007e84 2007f20: 21 00 80 99 sethi %hi(0x2026400), %l0 2007f24: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2007f28: 18 bf ff e5 bgu 2007ebc <== NOT EXECUTED 2007f2c: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 2007f30: 81 c7 e0 08 ret <== NOT EXECUTED 2007f34: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 2007f38: 40 00 10 11 call 200bf7c <_Thread_Suspend> 2007f3c: 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 ) 2007f40: c2 04 21 50 ld [ %l0 + 0x150 ], %g1 2007f44: 10 bf ff d6 b 2007e9c 2007f48: b0 10 20 00 clr %i0 02019f14 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 2019f14: 9d e3 bf 90 save %sp, -112, %sp 2019f18: 92 10 00 18 mov %i0, %o1 Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 2019f1c: 80 a6 60 00 cmp %i1, 0 2019f20: 02 80 00 22 be 2019fa8 2019f24: 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 ) ) { 2019f28: 80 a2 60 00 cmp %o1, 0 2019f2c: 12 80 00 21 bne 2019fb0 2019f30: 83 32 60 18 srl %o1, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2019f34: 21 00 80 f5 sethi %hi(0x203d400), %l0 2019f38: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 ! 203d600 <_Thread_Dispatch_disable_level> 2019f3c: 82 00 60 01 inc %g1 2019f40: c2 24 22 00 st %g1, [ %l0 + 0x200 ] 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; 2019f44: 03 00 80 f5 sethi %hi(0x203d400), %g1 2019f48: f0 00 62 e0 ld [ %g1 + 0x2e0 ], %i0 ! 203d6e0 <_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; 2019f4c: c0 27 bf f4 clr [ %fp + -12 ] /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 2019f50: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 while (tvp) { 2019f54: 80 a0 a0 00 cmp %g2, 0 2019f58: 32 80 00 08 bne,a 2019f78 2019f5c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 2019f60: 10 80 00 1a b 2019fc8 2019f64: 11 00 80 f5 sethi %hi(0x203d400), %o0 2019f68: 84 90 60 00 orcc %g1, 0, %g2 <== NOT EXECUTED 2019f6c: 02 80 00 17 be 2019fc8 <== NOT EXECUTED 2019f70: 11 00 80 f5 sethi %hi(0x203d400), %o0 <== NOT EXECUTED if (tvp->ptr == ptr) { 2019f74: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED 2019f78: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 2019f7c: 32 bf ff fb bne,a 2019f68 <== NOT EXECUTED 2019f80: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED tvp->dtor = dtor; 2019f84: f4 20 a0 10 st %i2, [ %g2 + 0x10 ] <== 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 ) 2019f88: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 _Thread_Dispatch(); 2019f8c: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019f90: 82 00 7f ff add %g1, -1, %g1 2019f94: c2 24 22 00 st %g1, [ %l0 + 0x200 ] 2019f98: c4 04 22 00 ld [ %l0 + 0x200 ], %g2 2019f9c: 80 a0 a0 00 cmp %g2, 0 2019fa0: 02 80 00 1c be 201a010 2019fa4: 01 00 00 00 nop the_thread->task_variables = new; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2019fa8: 81 c7 e0 08 ret <== NOT EXECUTED 2019fac: 81 e8 00 00 restore <== NOT EXECUTED 2019fb0: 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 ) { 2019fb4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 2019fb8: 08 80 00 21 bleu 201a03c <== NOT EXECUTED 2019fbc: 83 32 60 1b srl %o1, 0x1b, %g1 <== 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 ) _Thread_Dispatch(); 2019fc0: 81 c7 e0 08 ret <== NOT EXECUTED 2019fc4: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 2019fc8: 92 10 20 14 mov 0x14, %o1 2019fcc: 7f ff bf 14 call 2009c1c <_Heap_Allocate> 2019fd0: 90 12 22 4c or %o0, 0x24c, %o0 * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 2019fd4: 80 a2 20 00 cmp %o0, 0 2019fd8: 32 80 00 12 bne,a 201a020 2019fdc: c4 06 21 80 ld [ %i0 + 0x180 ], %g2 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2019fe0: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 <== NOT EXECUTED 2019fe4: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED 2019fe8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2019fec: c2 24 22 00 st %g1, [ %l0 + 0x200 ] <== NOT EXECUTED 2019ff0: c4 04 22 00 ld [ %l0 + 0x200 ], %g2 <== NOT EXECUTED 2019ff4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2019ff8: 12 80 00 08 bne 201a018 <== NOT EXECUTED 2019ffc: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 201a000: 7f ff c7 47 call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 201a004: 01 00 00 00 nop <== NOT EXECUTED 201a008: 81 c7 e0 08 ret <== NOT EXECUTED 201a00c: 81 e8 00 00 restore <== NOT EXECUTED 201a010: 7f ff c7 43 call 200bd1c <_Thread_Dispatch> 201a014: b0 10 20 00 clr %i0 201a018: 81 c7 e0 08 ret 201a01c: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 201a020: 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; 201a024: 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; 201a028: c2 22 20 08 st %g1, [ %o0 + 8 ] new->ptr = ptr; 201a02c: f2 22 20 04 st %i1, [ %o0 + 4 ] new->dtor = dtor; 201a030: f4 22 20 10 st %i2, [ %o0 + 0x10 ] new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 201a034: 10 bf ff d5 b 2019f88 201a038: c4 22 00 00 st %g2, [ %o0 ] *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 201a03c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201a040: 12 bf ff e0 bne 2019fc0 <== NOT EXECUTED 201a044: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 201a048: 05 00 80 f5 sethi %hi(0x203d400), %g2 <== NOT EXECUTED 201a04c: 84 10 a1 60 or %g2, 0x160, %g2 ! 203d560 <_Objects_Information_table> <== NOT EXECUTED 201a050: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 201a054: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 201a058: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201a05c: 02 bf ff d9 be 2019fc0 <== NOT EXECUTED 201a060: 01 00 00 00 nop <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 201a064: 7f ff c1 9e call 200a6dc <_Objects_Get> <== NOT EXECUTED 201a068: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 201a06c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 201a070: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED 201a074: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201a078: 02 bf ff b6 be 2019f50 <== NOT EXECUTED 201a07c: 21 00 80 f5 sethi %hi(0x203d400), %l0 <== NOT EXECUTED 201a080: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 201a084: 18 bf ff c9 bgu 2019fa8 <== NOT EXECUTED 201a088: b0 10 20 19 mov 0x19, %i0 <== NOT EXECUTED 201a08c: 30 bf ff cd b,a 2019fc0 <== NOT EXECUTED 0201a090 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 201a090: 9d e3 bf 90 save %sp, -112, %sp Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 201a094: 80 a6 60 00 cmp %i1, 0 201a098: 02 80 00 50 be 201a1d8 201a09c: 92 10 00 18 mov %i0, %o1 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 ) ) { 201a0a0: 80 a6 20 00 cmp %i0, 0 201a0a4: 12 80 00 26 bne 201a13c 201a0a8: 83 36 20 18 srl %i0, 0x18, %g1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201a0ac: 21 00 80 f5 sethi %hi(0x203d400), %l0 201a0b0: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 ! 203d600 <_Thread_Dispatch_disable_level> 201a0b4: 82 00 60 01 inc %g1 201a0b8: c2 24 22 00 st %g1, [ %l0 + 0x200 ] 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; 201a0bc: 03 00 80 f5 sethi %hi(0x203d400), %g1 201a0c0: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 203d6e0 <_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; 201a0c4: c0 27 bf f4 clr [ %fp + -12 ] default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; 201a0c8: c6 02 21 80 ld [ %o0 + 0x180 ], %g3 while (tvp) { 201a0cc: 80 a0 e0 00 cmp %g3, 0 201a0d0: 02 80 00 10 be 201a110 201a0d4: 01 00 00 00 nop if (tvp->ptr == ptr) { 201a0d8: c2 00 e0 04 ld [ %g3 + 4 ], %g1 201a0dc: 80 a0 40 19 cmp %g1, %i1 201a0e0: 32 80 00 09 bne,a 201a104 201a0e4: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 201a0e8: 10 80 00 5b b 201a254 201a0ec: c2 00 c0 00 ld [ %g3 ], %g1 return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { 201a0f0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 201a0f4: 02 80 00 18 be 201a154 <== NOT EXECUTED 201a0f8: b0 10 00 02 mov %g2, %i0 <== 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 ) _Thread_Dispatch(); 201a0fc: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED _Workspace_Free(tvp); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 201a100: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED default: return RTEMS_INTERNAL_ERROR; case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 201a104: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201a108: 32 bf ff fa bne,a 201a0f0 <== NOT EXECUTED 201a10c: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== 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 ) 201a110: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 <== NOT EXECUTED 201a114: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 201a118: c2 24 22 00 st %g1, [ %l0 + 0x200 ] <== NOT EXECUTED 201a11c: c4 04 22 00 ld [ %l0 + 0x200 ], %g2 <== NOT EXECUTED 201a120: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201a124: 12 80 00 2d bne 201a1d8 <== NOT EXECUTED 201a128: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 201a12c: 7f ff c6 fc call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 201a130: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 201a134: 81 c7 e0 08 ret <== NOT EXECUTED 201a138: 81 e8 00 00 restore <== NOT EXECUTED 201a13c: 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 ) { 201a140: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 201a144: 08 80 00 2e bleu 201a1fc <== NOT EXECUTED 201a148: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 201a14c: 81 c7 e0 08 ret <== NOT EXECUTED 201a150: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 201a154: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED 201a158: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; if (_Thread_Is_executing(the_thread)) { 201a15c: 03 00 80 f5 sethi %hi(0x203d400), %g1 201a160: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 203d6e0 <_Thread_Executing> 201a164: 80 a2 00 02 cmp %o0, %g2 201a168: 32 80 00 1e bne,a 201a1e0 201a16c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if (tvp->dtor) 201a170: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 201a174: 80 a0 a0 00 cmp %g2, 0 201a178: 22 80 00 06 be,a 201a190 201a17c: c4 06 20 04 ld [ %i0 + 4 ], %g2 (*tvp->dtor)(*tvp->ptr); 201a180: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 201a184: 9f c0 80 00 call %g2 <== NOT EXECUTED 201a188: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED *tvp->ptr = tvp->gval; 201a18c: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED 201a190: c2 06 20 08 ld [ %i0 + 8 ], %g1 201a194: c2 20 80 00 st %g1, [ %g2 ] RTEMS_INLINE_ROUTINE boolean _Workspace_Free( void *block ) { return _Heap_Free( &_Workspace_Area, block ); 201a198: 92 10 00 18 mov %i0, %o1 201a19c: 11 00 80 f5 sethi %hi(0x203d400), %o0 201a1a0: 7f ff be d1 call 2009ce4 <_Heap_Free> 201a1a4: 90 12 22 4c or %o0, 0x24c, %o0 ! 203d64c <_Workspace_Area> #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201a1a8: c2 04 22 00 ld [ %l0 + 0x200 ], %g1 201a1ac: b0 10 20 00 clr %i0 201a1b0: 82 00 7f ff add %g1, -1, %g1 201a1b4: c2 24 22 00 st %g1, [ %l0 + 0x200 ] 201a1b8: c4 04 22 00 ld [ %l0 + 0x200 ], %g2 201a1bc: 80 a0 a0 00 cmp %g2, 0 201a1c0: 12 80 00 04 bne 201a1d0 201a1c4: 01 00 00 00 nop _Thread_Dispatch(); 201a1c8: 7f ff c6 d5 call 200bd1c <_Thread_Dispatch> 201a1cc: 01 00 00 00 nop 201a1d0: 81 c7 e0 08 ret 201a1d4: 81 e8 00 00 restore 201a1d8: 81 c7 e0 08 ret <== NOT EXECUTED 201a1dc: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED } else { if (tvp->dtor) 201a1e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201a1e4: 22 bf ff ee be,a 201a19c <== NOT EXECUTED 201a1e8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED (*tvp->dtor)(tvp->tval); 201a1ec: 9f c0 40 00 call %g1 <== NOT EXECUTED 201a1f0: d0 06 20 0c ld [ %i0 + 0xc ], %o0 <== NOT EXECUTED 201a1f4: 10 bf ff ea b 201a19c <== NOT EXECUTED 201a1f8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 201a1fc: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201a200: 32 bf ff cd bne,a 201a134 <== NOT EXECUTED 201a204: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 201a208: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 201a20c: 05 00 80 f5 sethi %hi(0x203d400), %g2 <== NOT EXECUTED 201a210: 84 10 a1 60 or %g2, 0x160, %g2 ! 203d560 <_Objects_Information_table> <== NOT EXECUTED 201a214: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 201a218: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 201a21c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201a220: 22 bf ff c5 be,a 201a134 <== NOT EXECUTED 201a224: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 201a228: 7f ff c1 2d call 200a6dc <_Objects_Get> <== NOT EXECUTED 201a22c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 201a230: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 201a234: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201a238: 02 bf ff a4 be 201a0c8 <== NOT EXECUTED 201a23c: 21 00 80 f5 sethi %hi(0x203d400), %l0 <== NOT EXECUTED 201a240: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 201a244: 18 bf ff bc bgu 201a134 <== NOT EXECUTED 201a248: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 201a24c: 81 c7 e0 08 ret <== NOT EXECUTED 201a250: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 201a254: b0 10 00 03 mov %g3, %i0 201a258: 10 bf ff c1 b 201a15c 201a25c: c2 22 21 80 st %g1, [ %o0 + 0x180 ] 0201a260 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 201a260: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 201a264: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 201a268: 02 80 00 3b be 201a354 <== NOT EXECUTED 201a26c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 201a270: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 201a274: 02 80 00 38 be 201a354 <== NOT EXECUTED 201a278: 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 ) ) { 201a27c: 12 80 00 21 bne 201a300 <== NOT EXECUTED 201a280: 83 36 20 18 srl %i0, 0x18, %g1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 201a284: 05 00 80 f5 sethi %hi(0x203d400), %g2 <== NOT EXECUTED 201a288: c2 00 a2 00 ld [ %g2 + 0x200 ], %g1 ! 203d600 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 201a28c: 82 00 60 01 inc %g1 <== NOT EXECUTED 201a290: c2 20 a2 00 st %g1, [ %g2 + 0x200 ] <== 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; 201a294: 03 00 80 f5 sethi %hi(0x203d400), %g1 <== NOT EXECUTED 201a298: d0 00 62 e0 ld [ %g1 + 0x2e0 ], %o0 ! 203d6e0 <_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; 201a29c: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 201a2a0: d0 02 21 80 ld [ %o0 + 0x180 ], %o0 <== NOT EXECUTED while (tvp) { 201a2a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201a2a8: 32 80 00 07 bne,a 201a2c4 <== NOT EXECUTED 201a2ac: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 201a2b0: 30 80 00 1a b,a 201a318 <== NOT EXECUTED 201a2b4: 90 90 60 00 orcc %g1, 0, %o0 <== NOT EXECUTED 201a2b8: 02 80 00 18 be 201a318 <== NOT EXECUTED 201a2bc: 01 00 00 00 nop <== NOT EXECUTED if (tvp->ptr == ptr) { 201a2c0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 201a2c4: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED 201a2c8: 32 bf ff fb bne,a 201a2b4 <== NOT EXECUTED 201a2cc: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 201a2d0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED 201a2d4: c2 26 80 00 st %g1, [ %i2 ] <== 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 ) 201a2d8: c2 00 a2 00 ld [ %g2 + 0x200 ], %g1 <== NOT EXECUTED 201a2dc: b0 10 20 00 clr %i0 <== NOT EXECUTED 201a2e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 201a2e4: c2 20 a2 00 st %g1, [ %g2 + 0x200 ] <== NOT EXECUTED 201a2e8: c4 00 a2 00 ld [ %g2 + 0x200 ], %g2 <== NOT EXECUTED 201a2ec: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201a2f0: 02 80 00 15 be 201a344 <== NOT EXECUTED 201a2f4: 01 00 00 00 nop <== NOT EXECUTED } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 201a2f8: 81 c7 e0 08 ret <== NOT EXECUTED 201a2fc: 81 e8 00 00 restore <== NOT EXECUTED 201a300: 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 ) { 201a304: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 201a308: 08 80 00 15 bleu 201a35c <== NOT EXECUTED 201a30c: 83 36 20 1b srl %i0, 0x1b, %g1 <== NOT EXECUTED 201a310: 81 c7 e0 08 ret <== NOT EXECUTED 201a314: 91 e8 20 04 restore %g0, 4, %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 ) 201a318: c2 00 a2 00 ld [ %g2 + 0x200 ], %g1 <== NOT EXECUTED 201a31c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 201a320: c2 20 a2 00 st %g1, [ %g2 + 0x200 ] <== NOT EXECUTED 201a324: c4 00 a2 00 ld [ %g2 + 0x200 ], %g2 <== NOT EXECUTED 201a328: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 201a32c: 12 80 00 0a bne 201a354 <== NOT EXECUTED 201a330: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 201a334: 7f ff c6 7a call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 201a338: b0 10 20 09 mov 9, %i0 ! 9 <== NOT EXECUTED 201a33c: 81 c7 e0 08 ret <== NOT EXECUTED 201a340: 81 e8 00 00 restore <== NOT EXECUTED 201a344: 7f ff c6 76 call 200bd1c <_Thread_Dispatch> <== NOT EXECUTED 201a348: 01 00 00 00 nop <== NOT EXECUTED 201a34c: 81 c7 e0 08 ret <== NOT EXECUTED 201a350: 81 e8 00 00 restore <== NOT EXECUTED 201a354: 81 c7 e0 08 ret <== NOT EXECUTED 201a358: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 201a35c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 201a360: 32 bf ff e6 bne,a 201a2f8 <== NOT EXECUTED 201a364: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = _Objects_Information_table[ the_api ][ the_class ]; 201a368: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED 201a36c: 05 00 80 f5 sethi %hi(0x203d400), %g2 <== NOT EXECUTED 201a370: 84 10 a1 60 or %g2, 0x160, %g2 ! 203d560 <_Objects_Information_table> <== NOT EXECUTED 201a374: c6 00 80 01 ld [ %g2 + %g1 ], %g3 <== NOT EXECUTED 201a378: d0 00 e0 04 ld [ %g3 + 4 ], %o0 <== NOT EXECUTED if ( !information ) { 201a37c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 201a380: 22 bf ff de be,a 201a2f8 <== NOT EXECUTED 201a384: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 201a388: 7f ff c0 d5 call 200a6dc <_Objects_Get> <== NOT EXECUTED 201a38c: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 201a390: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 201a394: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201a398: 02 bf ff c2 be 201a2a0 <== NOT EXECUTED 201a39c: 05 00 80 f5 sethi %hi(0x203d400), %g2 <== NOT EXECUTED 201a3a0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 201a3a4: 18 bf ff d5 bgu 201a2f8 <== NOT EXECUTED 201a3a8: b0 10 20 19 mov 0x19, %i0 <== 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 ) _Thread_Dispatch(); 201a3ac: 81 c7 e0 08 ret <== NOT EXECUTED 201a3b0: 91 e8 20 04 restore %g0, 4, %o0 <== NOT EXECUTED 0200331c : int cbufsize, int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize; 200331c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 2003320: 05 00 80 62 sethi %hi(0x2018800), %g2 <== NOT EXECUTED int cbufsize, int raw_input, int raw_output ) { rtems_termios_cbufsize = cbufsize; 2003324: d0 20 61 ec st %o0, [ %g1 + 0x1ec ] <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 2003328: d2 20 a1 f0 st %o1, [ %g2 + 0x1f0 ] <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 200332c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 2003330: 90 10 20 00 clr %o0 <== NOT EXECUTED 2003334: 81 c3 e0 08 retl <== NOT EXECUTED 2003338: d4 20 61 f4 st %o2, [ %g1 + 0x1f4 ] <== NOT EXECUTED 02004ad0 : } } rtems_status_code rtems_termios_close (void *arg) { 2004ad0: 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); 2004ad4: 23 00 80 65 sethi %hi(0x2019400), %l1 rtems_status_code rtems_termios_close (void *arg) { rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 2004ad8: c2 06 00 00 ld [ %i0 ], %g1 rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2004adc: d0 04 62 e4 ld [ %l1 + 0x2e4 ], %o0 rtems_status_code rtems_termios_close (void *arg) { rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 2004ae0: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2004ae4: 92 10 20 00 clr %o1 2004ae8: 40 00 04 c6 call 2005e00 2004aec: 94 10 20 00 clr %o2 if (sc != RTEMS_SUCCESSFUL) 2004af0: 80 a2 20 00 cmp %o0, 0 2004af4: 12 80 00 47 bne 2004c10 2004af8: 01 00 00 00 nop rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 2004afc: c2 04 20 08 ld [ %l0 + 8 ], %g1 2004b00: 82 00 7f ff add %g1, -1, %g1 2004b04: 80 a0 60 00 cmp %g1, 0 2004b08: 12 80 00 3a bne 2004bf0 2004b0c: c2 24 20 08 st %g1, [ %l0 + 8 ] if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 2004b10: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 2004b14: 03 00 80 64 sethi %hi(0x2019000), %g1 2004b18: 82 10 63 2c or %g1, 0x32c, %g1 ! 201932c 2004b1c: 85 28 a0 05 sll %g2, 5, %g2 2004b20: 84 00 80 01 add %g2, %g1, %g2 2004b24: c2 00 a0 04 ld [ %g2 + 4 ], %g1 2004b28: 80 a0 60 00 cmp %g1, 0 2004b2c: 02 80 00 49 be 2004c50 2004b30: 01 00 00 00 nop /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 2004b34: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004b38: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED * default: just flush output buffer */ drainOutput (tty); } if (tty->device.outputUsesInterrupts 2004b3c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED 2004b40: 80 a0 60 02 cmp %g1, 2 2004b44: 22 80 00 47 be,a 2004c60 2004b48: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) 2004b4c: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 2004b50: 80 a0 60 00 cmp %g1, 0 2004b54: 22 80 00 07 be,a 2004b70 2004b58: c4 04 00 00 ld [ %l0 ], %g2 (*tty->device.lastClose)(tty->major, tty->minor, arg); 2004b5c: d0 04 20 0c ld [ %l0 + 0xc ], %o0 <== NOT EXECUTED 2004b60: d2 04 20 10 ld [ %l0 + 0x10 ], %o1 <== NOT EXECUTED 2004b64: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004b68: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED if (tty->forw == NULL) { 2004b6c: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED 2004b70: 80 a0 a0 00 cmp %g2, 0 2004b74: 22 80 00 30 be,a 2004c34 2004b78: c6 04 20 04 ld [ %l0 + 4 ], %g3 if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 2004b7c: c2 04 20 04 ld [ %l0 + 4 ], %g1 <== NOT EXECUTED 2004b80: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED } if (tty->back == NULL) { 2004b84: c2 04 20 04 ld [ %l0 + 4 ], %g1 2004b88: 80 a0 60 00 cmp %g1, 0 2004b8c: 22 80 00 25 be,a 2004c20 2004b90: 03 00 80 65 sethi %hi(0x2019400), %g1 if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 2004b94: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 2004b98: 40 00 04 4f call 2005cd4 2004b9c: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 rtems_semaphore_delete (tty->osem); 2004ba0: 40 00 04 4d call 2005cd4 2004ba4: d0 04 20 18 ld [ %l0 + 0x18 ], %o0 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 2004ba8: 40 00 04 4b call 2005cd4 2004bac: d0 04 20 8c ld [ %l0 + 0x8c ], %o0 if ((tty->device.pollRead == NULL) || 2004bb0: c2 04 20 a0 ld [ %l0 + 0xa0 ], %g1 2004bb4: 80 a0 60 00 cmp %g1, 0 2004bb8: 02 80 00 13 be 2004c04 2004bbc: 01 00 00 00 nop 2004bc0: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004bc4: 80 a0 60 02 cmp %g1, 2 2004bc8: 02 80 00 0f be 2004c04 2004bcc: 01 00 00 00 nop (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 2004bd0: 7f ff f5 ca call 20022f8 2004bd4: d0 04 20 58 ld [ %l0 + 0x58 ], %o0 free (tty->rawOutBuf.theBuf); 2004bd8: 7f ff f5 c8 call 20022f8 2004bdc: d0 04 20 7c ld [ %l0 + 0x7c ], %o0 free (tty->cbuf); 2004be0: 7f ff f5 c6 call 20022f8 2004be4: d0 04 20 1c ld [ %l0 + 0x1c ], %o0 free (tty); 2004be8: 7f ff f5 c4 call 20022f8 2004bec: 90 10 00 10 mov %l0, %o0 } rtems_semaphore_release (rtems_termios_ttyMutex); 2004bf0: d0 04 62 e4 ld [ %l1 + 0x2e4 ], %o0 2004bf4: 40 00 05 52 call 200613c 2004bf8: b0 10 20 00 clr %i0 return RTEMS_SUCCESSFUL; } 2004bfc: 81 c7 e0 08 ret 2004c00: 81 e8 00 00 restore rtems_semaphore_delete (tty->isem); rtems_semaphore_delete (tty->osem); rtems_semaphore_delete (tty->rawOutBuf.Semaphore); if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 2004c04: 40 00 04 34 call 2005cd4 <== NOT EXECUTED 2004c08: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED 2004c0c: 30 bf ff f1 b,a 2004bd0 <== NOT EXECUTED struct rtems_termios_tty *tty = args->iop->data1; rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 2004c10: 40 00 07 98 call 2006a70 <== NOT EXECUTED 2004c14: 01 00 00 00 nop <== NOT EXECUTED if (--tty->refcount == 0) { 2004c18: 10 bf ff ba b 2004b00 <== NOT EXECUTED 2004c1c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== NOT EXECUTED else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; if ( rtems_termios_ttyHead != NULL ) { 2004c20: 80 a0 a0 00 cmp %g2, 0 2004c24: 02 bf ff dd be 2004b98 2004c28: c4 20 62 ec st %g2, [ %g1 + 0x2ec ] rtems_termios_ttyHead->back = NULL; 2004c2c: 10 bf ff db b 2004b98 <== NOT EXECUTED 2004c30: c0 20 a0 04 clr [ %g2 + 4 ] <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) (*tty->device.lastClose)(tty->major, tty->minor, arg); if (tty->forw == NULL) { rtems_termios_ttyTail = tty->back; 2004c34: 03 00 80 65 sethi %hi(0x2019400), %g1 if ( rtems_termios_ttyTail != NULL ) { 2004c38: 80 a0 e0 00 cmp %g3, 0 2004c3c: 02 bf ff d2 be 2004b84 2004c40: c6 20 62 e8 st %g3, [ %g1 + 0x2e8 ] rtems_termios_ttyTail->forw = NULL; 2004c44: c0 20 c0 00 clr [ %g3 ] <== NOT EXECUTED 2004c48: 10 bf ff cf b 2004b84 <== NOT EXECUTED 2004c4c: c4 04 00 00 ld [ %l0 ], %g2 <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 2004c50: 7f ff fd 66 call 20041e8 2004c54: 90 10 00 10 mov %l0, %o0 } if (tty->device.outputUsesInterrupts 2004c58: 10 bf ff ba b 2004b40 2004c5c: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 2004c60: 40 00 02 ab call 200570c <== NOT EXECUTED 2004c64: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 2004c68: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004c6c: 12 80 00 0c bne 2004c9c <== NOT EXECUTED 2004c70: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 2004c74: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED 2004c78: 40 00 02 a5 call 200570c <== NOT EXECUTED 2004c7c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 2004c80: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004c84: 22 bf ff b3 be,a 2004b50 <== NOT EXECUTED 2004c88: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004c8c: 40 00 07 79 call 2006a70 <== NOT EXECUTED 2004c90: 01 00 00 00 nop <== NOT EXECUTED } if (tty->device.lastClose) 2004c94: 10 bf ff af b 2004b50 <== NOT EXECUTED 2004c98: c2 04 20 9c ld [ %l0 + 0x9c ], %g1 <== NOT EXECUTED */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 2004c9c: 40 00 07 75 call 2006a70 <== NOT EXECUTED 2004ca0: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_event_send( 2004ca4: 10 bf ff f5 b 2004c78 <== NOT EXECUTED 2004ca8: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED 02003550 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 2003550: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 2003554: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2003558: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2 <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 200355c: 82 00 40 19 add %g1, %i1, %g1 <== NOT EXECUTED 2003560: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2003564: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 2003568: 02 80 00 10 be 20035a8 <== NOT EXECUTED 200356c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { 2003570: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 2003574: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED 2003578: 02 80 00 04 be 2003588 <== NOT EXECUTED 200357c: 03 00 80 64 sethi %hi(0x2019000), %g1 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 2003580: 7f ff ff 75 call 2003354 <== NOT EXECUTED 2003584: 81 e8 00 00 restore <== NOT EXECUTED } else if (tty->t_line == PPPDISC ) { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 2003588: c2 00 63 e0 ld [ %g1 + 0x3e0 ], %g1 <== NOT EXECUTED 200358c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003590: 02 80 00 04 be 20035a0 <== NOT EXECUTED 2003594: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 2003598: 9f c0 40 00 call %g1 <== NOT EXECUTED 200359c: 01 00 00 00 nop <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); } } 20035a0: 81 c7 e0 08 ret <== NOT EXECUTED 20035a4: 81 e8 00 00 restore <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 20035a8: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0 <== NOT EXECUTED 20035ac: 40 00 08 58 call 200570c <== NOT EXECUTED 20035b0: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 20035b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20035b8: 02 bf ff fa be 20035a0 <== NOT EXECUTED 20035bc: b0 10 20 00 clr %i0 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20035c0: 40 00 0d 2c call 2006a70 <== NOT EXECUTED 20035c4: 01 00 00 00 nop <== NOT EXECUTED 20035c8: 30 bf ff f6 b,a 20035a0 <== NOT EXECUTED 020035cc : * 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) { 20035cc: 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) { 20035d0: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 20035d4: 05 00 80 64 sethi %hi(0x2019000), %g2 <== NOT EXECUTED 20035d8: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 20035dc: a0 10 a3 2c or %g2, 0x32c, %l0 <== NOT EXECUTED 20035e0: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED 20035e4: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED 20035e8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20035ec: 02 80 00 24 be 200367c <== NOT EXECUTED 20035f0: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED while (len--) { 20035f4: 22 80 00 11 be,a 2003638 <== NOT EXECUTED 20035f8: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED 20035fc: b4 06 80 19 add %i2, %i1, %i2 <== NOT EXECUTED c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 2003600: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== 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++; 2003604: d0 0e 40 00 ldub [ %i1 ], %o0 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 2003608: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 200360c: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED 2003610: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 <== NOT EXECUTED 2003614: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 2003618: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200361c: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003620: 91 3a 20 18 sra %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++; 2003624: b2 06 60 01 inc %i1 <== 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--) { 2003628: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED 200362c: 32 bf ff f6 bne,a 2003604 <== NOT EXECUTED 2003630: 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 )) { 2003634: c2 06 20 e4 ld [ %i0 + 0xe4 ], %g1 <== NOT EXECUTED 2003638: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200363c: 12 80 00 0e bne 2003674 <== NOT EXECUTED 2003640: a8 10 20 00 clr %l4 <== NOT EXECUTED 2003644: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED 2003648: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200364c: 02 80 00 0a be 2003674 <== NOT EXECUTED 2003650: 01 00 00 00 nop <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 2003654: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED 2003658: 9f c0 40 00 call %g1 <== NOT EXECUTED 200365c: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; 2003660: a8 10 20 00 clr %l4 <== NOT EXECUTED 2003664: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2003668: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 200366c: 81 c7 e0 08 ret <== NOT EXECUTED 2003670: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED 2003674: 81 c7 e0 08 ret <== NOT EXECUTED 2003678: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 200367c: b4 06 bf ff add %i2, -1, %i2 <== 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) { 2003680: a8 10 20 00 clr %l4 <== NOT EXECUTED 2003684: a6 10 20 00 clr %l3 <== 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); 2003688: aa 06 20 30 add %i0, 0x30, %l5 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 200368c: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED 2003690: 02 80 00 1c be 2003700 <== NOT EXECUTED 2003694: ac 06 20 4a add %i0, 0x4a, %l6 <== NOT EXECUTED c = *buf++; /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 2003698: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 200369c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 20036a0: 02 80 00 0b be 20036cc <== NOT EXECUTED 20036a4: e2 0e 40 00 ldub [ %i1 ], %l1 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 20036a8: c4 0e 20 4a ldub [ %i0 + 0x4a ], %g2 <== NOT EXECUTED 20036ac: 83 2c 60 18 sll %l1, 0x18, %g1 <== NOT EXECUTED 20036b0: 87 38 60 18 sra %g1, 0x18, %g3 <== NOT EXECUTED 20036b4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 20036b8: 02 80 00 63 be 2003844 <== NOT EXECUTED 20036bc: c2 0e 20 49 ldub [ %i0 + 0x49 ], %g1 <== NOT EXECUTED /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = TRUE; } else if (c == tty->termios.c_cc[VSTART]) { 20036c0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 20036c4: 02 80 00 68 be 2003864 <== NOT EXECUTED 20036c8: 01 00 00 00 nop <== NOT EXECUTED /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = TRUE; } } if (flow_rcv) { 20036cc: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED 20036d0: 02 80 00 23 be 200375c <== NOT EXECUTED 20036d4: 01 00 00 00 nop <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 20036d8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20036dc: 82 08 60 30 and %g1, 0x30, %g1 <== NOT EXECUTED 20036e0: 80 a0 60 20 cmp %g1, 0x20 <== NOT EXECUTED 20036e4: 02 80 00 0f be 2003720 <== NOT EXECUTED 20036e8: 01 00 00 00 nop <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 20036ec: b2 06 60 01 inc %i1 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 20036f0: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED 20036f4: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED 20036f8: 12 bf ff e8 bne 2003698 <== NOT EXECUTED 20036fc: 01 00 00 00 nop <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 2003700: c2 06 20 78 ld [ %i0 + 0x78 ], %g1 <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 2003704: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 2003708: 82 00 40 14 add %g1, %l4, %g1 <== NOT EXECUTED 200370c: c2 26 20 78 st %g1, [ %i0 + 0x78 ] <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 2003710: 40 00 0a 8b call 200613c <== NOT EXECUTED 2003714: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED return dropped; } 2003718: 81 c7 e0 08 ret <== NOT EXECUTED 200371c: 81 e8 00 00 restore <== NOT EXECUTED } if (flow_rcv) { /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { /* disable interrupts */ rtems_interrupt_disable(level); 2003720: 7f ff f9 b7 call 2001dfc <== NOT EXECUTED 2003724: 01 00 00 00 nop <== NOT EXECUTED 2003728: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 200372c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 2003730: 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; 2003734: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED 2003738: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 200373c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003740: 12 80 00 55 bne 2003894 <== NOT EXECUTED 2003744: 01 00 00 00 nop <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 2003748: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200374c: 7f ff f9 b0 call 2001e0c <== NOT EXECUTED 2003750: b2 06 60 01 inc %i1 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 2003754: 10 bf ff e8 b 20036f4 <== NOT EXECUTED 2003758: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 200375c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0 <== NOT EXECUTED 2003760: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED 2003764: 40 00 4a a0 call 20161e4 <.urem> <== NOT EXECUTED 2003768: 90 02 20 01 inc %o0 <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 200376c: 7f ff f9 a4 call 2001dfc <== NOT EXECUTED 2003770: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED 2003774: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 2003778: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 200377c: d0 06 20 64 ld [ %i0 + 0x64 ], %o0 <== NOT EXECUTED 2003780: d2 06 20 64 ld [ %i0 + 0x64 ], %o1 <== NOT EXECUTED 2003784: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED 2003788: 40 00 4a 97 call 20161e4 <.urem> <== NOT EXECUTED 200378c: 90 02 00 10 add %o0, %l0, %o0 <== NOT EXECUTED 2003790: c2 06 20 c0 ld [ %i0 + 0xc0 ], %g1 <== NOT EXECUTED 2003794: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 2003798: 08 80 00 13 bleu 20037e4 <== NOT EXECUTED 200379c: 01 00 00 00 nop <== NOT EXECUTED 20037a0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20037a4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 20037a8: 12 80 00 0f bne 20037e4 <== NOT EXECUTED 20037ac: 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; 20037b0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20037b4: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED 20037b8: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 20037bc: c4 06 20 b8 ld [ %i0 + 0xb8 ], %g2 <== NOT EXECUTED 20037c0: 84 08 a4 02 and %g2, 0x402, %g2 <== NOT EXECUTED 20037c4: 80 a0 a4 00 cmp %g2, 0x400 <== NOT EXECUTED 20037c8: 02 80 00 45 be 20038dc <== NOT EXECUTED 20037cc: 01 00 00 00 nop <== NOT EXECUTED (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 20037d0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20037d4: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED 20037d8: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED 20037dc: 02 80 00 36 be 20038b4 <== NOT EXECUTED 20037e0: 01 00 00 00 nop <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); } } } /* reenable interrupts */ rtems_interrupt_enable(level); 20037e4: 7f ff f9 8a call 2001e0c <== NOT EXECUTED 20037e8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 20037ec: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 20037f0: 80 a0 40 10 cmp %g1, %l0 <== NOT EXECUTED 20037f4: 22 80 00 21 be,a 2003878 <== NOT EXECUTED 20037f8: a8 05 20 01 inc %l4 <== NOT EXECUTED dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 20037fc: c2 06 20 58 ld [ %i0 + 0x58 ], %g1 <== NOT EXECUTED 2003800: e2 28 40 10 stb %l1, [ %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 )) { 2003804: c4 06 20 e4 ld [ %i0 + 0xe4 ], %g2 <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; tty->rawInBuf.Tail = newTail; 2003808: 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 )) { 200380c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2003810: 32 bf ff b8 bne,a 20036f0 <== NOT EXECUTED 2003814: b2 06 60 01 inc %i1 <== NOT EXECUTED 2003818: c2 06 20 dc ld [ %i0 + 0xdc ], %g1 <== NOT EXECUTED 200381c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2003820: 22 bf ff b4 be,a 20036f0 <== NOT EXECUTED 2003824: b2 06 60 01 inc %i1 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 2003828: d2 06 20 e0 ld [ %i0 + 0xe0 ], %o1 <== NOT EXECUTED 200382c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003830: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 1; 2003834: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 2003838: b2 06 60 01 inc %i1 <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; 200383c: 10 bf ff ad b 20036f0 <== NOT EXECUTED 2003840: c2 26 20 e4 st %g1, [ %i0 + 0xe4 ] <== NOT EXECUTED /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { 2003844: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2003848: 02 80 00 0e be 2003880 <== NOT EXECUTED 200384c: 01 00 00 00 nop <== NOT EXECUTED tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 2003850: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 2003854: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 2003858: 82 10 60 10 or %g1, 0x10, %g1 <== NOT EXECUTED 200385c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED 2003860: 30 bf ff 9e b,a 20036d8 <== NOT EXECUTED flow_rcv = TRUE; } else if (c == tty->termios.c_cc[VSTART]) { /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 2003864: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 2003868: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED flow_rcv = TRUE; } else if (c == tty->termios.c_cc[VSTART]) { /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 200386c: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED 2003870: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED 2003874: 30 bf ff 99 b,a 20036d8 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 2003878: 10 bf ff 9e b 20036f0 <== NOT EXECUTED 200387c: b2 06 60 01 inc %i1 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 2003880: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 2003884: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { if (c == tty->termios.c_cc[VSTART]) { /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 2003888: 82 18 60 10 xor %g1, 0x10, %g1 <== NOT EXECUTED 200388c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED 2003890: 30 bf ff 92 b,a 20036d8 <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 2003894: d2 06 20 84 ld [ %i0 + 0x84 ], %o1 <== NOT EXECUTED 2003898: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED 200389c: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 20038a0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 20038a4: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 20038a8: 9f c0 80 00 call %g2 <== NOT EXECUTED 20038ac: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 20038b0: 30 bf ff a6 b,a 2003748 <== NOT EXECUTED 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 20038b4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 20038b8: 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; 20038bc: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED 20038c0: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 20038c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20038c8: 02 bf ff c7 be 20037e4 <== NOT EXECUTED 20038cc: 01 00 00 00 nop <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 20038d0: 9f c0 80 00 call %g2 <== NOT EXECUTED 20038d4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 20038d8: 30 bf ff c3 b,a 20037e4 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || 20038dc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20038e0: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 20038e4: 12 80 00 06 bne 20038fc <== NOT EXECUTED 20038e8: 01 00 00 00 nop <== NOT EXECUTED 20038ec: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED 20038f0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20038f4: 12 bf ff bc bne 20037e4 <== NOT EXECUTED 20038f8: 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; 20038fc: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003900: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 2003904: 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; 2003908: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 200390c: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; 2003910: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003914: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003918: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 200391c: 30 bf ff b2 b,a 20037e4 <== NOT EXECUTED 020032cc : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 20032cc: 9d e3 bf 98 save %sp, -104, %sp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 20032d0: 03 00 80 65 sethi %hi(0x2019400), %g1 20032d4: c4 00 62 e4 ld [ %g1 + 0x2e4 ], %g2 ! 20196e4 20032d8: 80 a0 a0 00 cmp %g2, 0 20032dc: 02 80 00 04 be 20032ec 20032e0: 98 10 62 e4 or %g1, 0x2e4, %o4 20032e4: 81 c7 e0 08 ret 20032e8: 81 e8 00 00 restore sc = rtems_semaphore_create ( 20032ec: 11 15 14 9b sethi %hi(0x54526c00), %o0 20032f0: 92 10 20 01 mov 1, %o1 20032f4: 90 12 21 69 or %o0, 0x169, %o0 20032f8: 94 10 20 54 mov 0x54, %o2 20032fc: 40 00 09 ea call 2005aa4 2003300: 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) 2003304: 80 a2 20 00 cmp %o0, 0 2003308: 02 bf ff f7 be 20032e4 200330c: 01 00 00 00 nop rtems_fatal_error_occurred (sc); 2003310: 40 00 0d d8 call 2006a70 <== NOT EXECUTED 2003314: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 2003318: 01 00 00 00 nop 020046b4 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 20046b4: 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; 20046b8: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; rtems_status_code sc; args->ioctl_return = 0; 20046bc: 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; 20046c0: e2 00 60 28 ld [ %g1 + 0x28 ], %l1 <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 20046c4: 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); 20046c8: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED } } rtems_status_code rtems_termios_ioctl (void *arg) { 20046cc: 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); 20046d0: 92 10 20 00 clr %o1 <== NOT EXECUTED 20046d4: 40 00 05 cb call 2005e00 <== NOT EXECUTED 20046d8: 94 10 20 00 clr %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 20046dc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 20046e0: 22 80 00 05 be,a 20046f4 <== NOT EXECUTED 20046e4: c4 04 a0 04 ld [ %l2 + 4 ], %g2 <== NOT EXECUTED args->ioctl_return = sc; 20046e8: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED 20046ec: 81 c7 e0 08 ret <== NOT EXECUTED 20046f0: 81 e8 00 00 restore <== NOT EXECUTED return sc; } switch (args->command) { 20046f4: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED 20046f8: 22 80 00 27 be,a 2004794 <== NOT EXECUTED 20046fc: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED 2004700: 18 80 00 0e bgu 2004738 <== NOT EXECUTED 2004704: 03 10 01 19 sethi %hi(0x40046400), %g1 <== NOT EXECUTED 2004708: 80 a0 a0 02 cmp %g2, 2 <== NOT EXECUTED 200470c: 22 80 00 61 be,a 2004890 <== NOT EXECUTED 2004710: d2 04 a0 08 ld [ %l2 + 8 ], %o1 <== NOT EXECUTED 2004714: 08 80 00 4c bleu 2004844 <== NOT EXECUTED 2004718: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED if (tty->device.setAttributes) (*tty->device.setAttributes)(tty->minor, &tty->termios); break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 200471c: 7f ff fe b3 call 20041e8 <== NOT EXECUTED 2004720: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 2004724: 40 00 06 86 call 200613c <== NOT EXECUTED 2004728: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED args->ioctl_return = sc; 200472c: f0 24 a0 0c st %i0, [ %l2 + 0xc ] <== NOT EXECUTED return sc; } 2004730: 81 c7 e0 08 ret <== NOT EXECUTED 2004734: 81 e8 00 00 restore <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 2004738: 82 10 62 7f or %g1, 0x27f, %g1 <== NOT EXECUTED 200473c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004740: 02 80 00 48 be 2004860 <== NOT EXECUTED 2004744: 01 00 00 00 nop <== NOT EXECUTED 2004748: 18 80 00 1b bgu 20047b4 <== NOT EXECUTED 200474c: 03 10 01 1d sethi %hi(0x40047400), %g1 <== NOT EXECUTED 2004750: 80 a0 a0 05 cmp %g2, 5 <== NOT EXECUTED 2004754: 22 80 00 14 be,a 20047a4 <== NOT EXECUTED 2004758: c2 04 00 00 ld [ %l0 ], %g1 <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 200475c: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED 2004760: 03 00 80 64 sethi %hi(0x2019000), %g1 <== NOT EXECUTED 2004764: 82 10 63 2c or %g1, 0x32c, %g1 ! 201932c <== NOT EXECUTED 2004768: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED 200476c: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED 2004770: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 <== NOT EXECUTED 2004774: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004778: 02 bf ff eb be 2004724 <== NOT EXECUTED 200477c: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 2004780: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2004784: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004788: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 200478c: 10 bf ff e6 b 2004724 <== NOT EXECUTED 2004790: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 2004794: c2 24 60 dc st %g1, [ %l1 + 0xdc ] <== NOT EXECUTED 2004798: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 200479c: 10 bf ff e2 b 2004724 <== NOT EXECUTED 20047a0: c4 24 60 e0 st %g2, [ %l1 + 0xe0 ] <== NOT EXECUTED case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 20047a4: c2 24 60 d4 st %g1, [ %l1 + 0xd4 ] <== NOT EXECUTED 20047a8: c4 04 20 04 ld [ %l0 + 4 ], %g2 <== NOT EXECUTED 20047ac: 10 bf ff de b 2004724 <== NOT EXECUTED 20047b0: c4 24 60 d8 st %g2, [ %l1 + 0xd8 ] <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 20047b4: 82 10 60 1a or %g1, 0x1a, %g1 <== NOT EXECUTED 20047b8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20047bc: 02 80 00 1e be 2004834 <== NOT EXECUTED 20047c0: 03 20 01 1d sethi %hi(0x80047400), %g1 <== NOT EXECUTED 20047c4: 82 10 60 1b or %g1, 0x1b, %g1 ! 8004741b <== NOT EXECUTED 20047c8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20047cc: 32 bf ff e5 bne,a 2004760 <== NOT EXECUTED 20047d0: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 20047d4: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED 20047d8: 05 00 80 64 sethi %hi(0x2019000), %g2 <== NOT EXECUTED 20047dc: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 20047e0: a0 10 a3 2c or %g2, 0x32c, %l0 <== NOT EXECUTED 20047e4: 82 00 40 10 add %g1, %l0, %g1 <== NOT EXECUTED 20047e8: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED 20047ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20047f0: 22 80 00 06 be,a 2004808 <== NOT EXECUTED 20047f4: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 20047f8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20047fc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2004800: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 2004804: c2 04 a0 08 ld [ %l2 + 8 ], %g1 <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 2004808: 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); 200480c: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 2004810: 85 28 e0 05 sll %g3, 5, %g2 <== NOT EXECUTED 2004814: c4 04 00 02 ld [ %l0 + %g2 ], %g2 <== NOT EXECUTED 2004818: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200481c: 02 bf ff c2 be 2004724 <== NOT EXECUTED 2004820: c6 24 60 cc st %g3, [ %l1 + 0xcc ] <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 2004824: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004828: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 200482c: 10 bf ff be b 2004724 <== NOT EXECUTED 2004830: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 2004834: c4 04 a0 08 ld [ %l2 + 8 ], %g2 <== NOT EXECUTED 2004838: c2 04 60 cc ld [ %l1 + 0xcc ], %g1 <== NOT EXECUTED 200483c: 10 bf ff ba b 2004724 <== NOT EXECUTED 2004840: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; return sc; } switch (args->command) { 2004844: 32 bf ff c7 bne,a 2004760 <== NOT EXECUTED 2004848: 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; 200484c: d0 04 a0 08 ld [ %l2 + 8 ], %o0 <== NOT EXECUTED 2004850: 92 04 60 30 add %l1, 0x30, %o1 <== NOT EXECUTED 2004854: 40 00 2b f0 call 200f814 <== NOT EXECUTED 2004858: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED 200485c: 30 bf ff b2 b,a 2004724 <== NOT EXECUTED *(int*)(args->buffer)=tty->t_line; break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 2004860: c4 04 60 60 ld [ %l1 + 0x60 ], %g2 <== NOT EXECUTED 2004864: c2 04 60 5c ld [ %l1 + 0x5c ], %g1 <== NOT EXECUTED if ( rawnc < 0 ) 2004868: 88 a0 80 01 subcc %g2, %g1, %g4 <== NOT EXECUTED 200486c: 0c 80 00 82 bneg 2004a74 <== NOT EXECUTED 2004870: 01 00 00 00 nop <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 2004874: c2 04 60 20 ld [ %l1 + 0x20 ], %g1 <== NOT EXECUTED 2004878: c4 04 60 24 ld [ %l1 + 0x24 ], %g2 <== NOT EXECUTED 200487c: c6 04 a0 08 ld [ %l2 + 8 ], %g3 <== NOT EXECUTED 2004880: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 2004884: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED 2004888: 10 bf ff a7 b 2004724 <== NOT EXECUTED 200488c: c2 20 c0 00 st %g1, [ %g3 ] <== NOT EXECUTED case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 2004890: a6 04 60 30 add %l1, 0x30, %l3 <== NOT EXECUTED 2004894: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED 2004898: 40 00 2b df call 200f814 <== NOT EXECUTED 200489c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 20048a0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20048a4: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED 20048a8: 02 80 00 19 be 200490c <== NOT EXECUTED 20048ac: 01 00 00 00 nop <== NOT EXECUTED 20048b0: c2 04 60 30 ld [ %l1 + 0x30 ], %g1 <== NOT EXECUTED 20048b4: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED 20048b8: 12 80 00 15 bne 200490c <== NOT EXECUTED 20048bc: 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); 20048c0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20048c4: 82 08 7d ef and %g1, -529, %g1 <== NOT EXECUTED 20048c8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 20048cc: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED 20048d0: 80 88 a0 20 btst 0x20, %g2 <== NOT EXECUTED 20048d4: 02 80 00 0e be 200490c <== NOT EXECUTED 20048d8: 01 00 00 00 nop <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 20048dc: 7f ff f5 48 call 2001dfc <== NOT EXECUTED 20048e0: 01 00 00 00 nop <== NOT EXECUTED 20048e4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 20048e8: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 20048ec: 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; 20048f0: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED 20048f4: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 20048f8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20048fc: 12 80 00 6d bne 2004ab0 <== NOT EXECUTED 2004900: 01 00 00 00 nop <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 2004904: 7f ff f5 42 call 2001e0c <== NOT EXECUTED 2004908: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 200490c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004910: 80 88 64 00 btst 0x400, %g1 <== NOT EXECUTED 2004914: 02 80 00 0c be 2004944 <== NOT EXECUTED 2004918: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED 200491c: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED 2004920: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 2004924: 12 80 00 08 bne 2004944 <== NOT EXECUTED 2004928: 01 00 00 00 nop <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 200492c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004930: 82 08 7b ff and %g1, -1025, %g1 <== NOT EXECUTED 2004934: 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); 2004938: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED 200493c: 84 08 bf fd and %g2, -3, %g2 <== NOT EXECUTED 2004940: c4 24 60 b8 st %g2, [ %l1 + 0xb8 ] <== NOT EXECUTED } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && 2004944: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004948: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED 200494c: 12 80 00 22 bne 20049d4 <== NOT EXECUTED 2004950: c6 04 60 38 ld [ %l1 + 0x38 ], %g3 <== NOT EXECUTED /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { 2004954: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2004958: 06 80 00 4a bl 2004a80 <== NOT EXECUTED 200495c: 01 00 00 00 nop <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 2004960: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED 2004964: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED 2004968: 80 88 80 01 btst %g2, %g1 <== NOT EXECUTED 200496c: 02 80 00 06 be 2004984 <== NOT EXECUTED 2004970: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 2004974: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004978: 82 10 64 00 or %g1, 0x400, %g1 <== NOT EXECUTED 200497c: 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) { 2004980: 80 88 a4 00 btst 0x400, %g2 <== NOT EXECUTED 2004984: 22 80 00 06 be,a 200499c <== NOT EXECUTED 2004988: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 200498c: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004990: 82 10 62 00 or %g1, 0x200, %g1 <== NOT EXECUTED 2004994: 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) { 2004998: c2 04 60 3c ld [ %l1 + 0x3c ], %g1 <== NOT EXECUTED 200499c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 20049a0: 02 80 00 23 be 2004a2c <== NOT EXECUTED 20049a4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 20049a8: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 20049ac: c0 24 60 70 clr [ %l1 + 0x70 ] <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 20049b0: c0 24 60 74 clr [ %l1 + 0x74 ] <== NOT EXECUTED else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 20049b4: c2 04 60 a8 ld [ %l1 + 0xa8 ], %g1 <== NOT EXECUTED 20049b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20049bc: 02 bf ff 5a be 2004724 <== NOT EXECUTED 20049c0: 01 00 00 00 nop <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 20049c4: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED 20049c8: 9f c0 40 00 call %g1 <== NOT EXECUTED 20049cc: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 20049d0: 30 bf ff 55 b,a 2004724 <== NOT EXECUTED /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && 20049d4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 20049d8: 06 80 00 2a bl 2004a80 <== NOT EXECUTED 20049dc: 01 00 00 00 nop <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 20049e0: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 20049e4: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED 20049e8: c2 24 60 b8 st %g1, [ %l1 + 0xb8 ] <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && 20049ec: c4 04 60 b8 ld [ %l1 + 0xb8 ], %g2 <== NOT EXECUTED 20049f0: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED 20049f4: 02 80 00 09 be 2004a18 <== NOT EXECUTED 20049f8: 01 00 00 00 nop <== NOT EXECUTED 20049fc: c2 04 60 b0 ld [ %l1 + 0xb0 ], %g1 <== NOT EXECUTED 2004a00: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004a04: 02 80 00 05 be 2004a18 <== NOT EXECUTED 2004a08: 01 00 00 00 nop <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 2004a0c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004a10: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED 2004a14: c6 04 60 38 ld [ %l1 + 0x38 ], %g3 <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 2004a18: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004a1c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED 2004a20: 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) { 2004a24: 10 bf ff cd b 2004958 <== NOT EXECUTED 2004a28: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { rtems_interval ticksPerSecond; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond); 2004a2c: 40 00 02 24 call 20052bc <== NOT EXECUTED 2004a30: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 2004a34: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED 2004a38: e0 0c 60 46 ldub [ %l1 + 0x46 ], %l0 <== NOT EXECUTED 2004a3c: 40 00 45 04 call 2015e4c <.umul> <== NOT EXECUTED 2004a40: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2004a44: 40 00 45 3c call 2015f34 <.udiv> <== NOT EXECUTED 2004a48: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 2004a4c: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2004a50: 02 80 00 11 be 2004a94 <== NOT EXECUTED 2004a54: d0 24 60 54 st %o0, [ %l1 + 0x54 ] <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; if (tty->termios.c_cc[VMIN]) 2004a58: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED else { rtems_interval ticksPerSecond; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond); tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; if (tty->termios.c_cc[VTIME]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 2004a5c: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; if (tty->termios.c_cc[VMIN]) 2004a60: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004a64: 12 bf ff d3 bne 20049b0 <== NOT EXECUTED 2004a68: d0 24 60 70 st %o0, [ %l1 + 0x70 ] <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 2004a6c: 10 bf ff d2 b 20049b4 <== NOT EXECUTED 2004a70: d0 24 60 74 st %o0, [ %l1 + 0x74 ] <== NOT EXECUTED #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; if ( rawnc < 0 ) rawnc += tty->rawInBuf.Size; 2004a74: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 <== NOT EXECUTED 2004a78: 10 bf ff 7f b 2004874 <== NOT EXECUTED 2004a7c: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED /* * check for flow control options to be switched on */ /* check for incoming RTS/CTS flow control switched on */ if (tty->termios.c_cflag & CRTSCTS) { tty->flow_ctrl |= FL_MDRTS; 2004a80: c2 04 60 b8 ld [ %l1 + 0xb8 ], %g1 <== NOT EXECUTED 2004a84: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED 2004a88: 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) { 2004a8c: 10 bf ff b6 b 2004964 <== NOT EXECUTED 2004a90: c4 04 60 30 ld [ %l1 + 0x30 ], %g2 <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { 2004a94: c2 0c 60 47 ldub [ %l1 + 0x47 ], %g1 <== NOT EXECUTED 2004a98: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004a9c: 32 bf ff c4 bne,a 20049ac <== NOT EXECUTED 2004aa0: c0 24 60 6c clr [ %l1 + 0x6c ] <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 2004aa4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2004aa8: 10 bf ff c3 b 20049b4 <== NOT EXECUTED 2004aac: c2 24 60 6c st %g1, [ %l1 + 0x6c ] <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 2004ab0: d2 04 60 84 ld [ %l1 + 0x84 ], %o1 <== NOT EXECUTED 2004ab4: c2 04 60 7c ld [ %l1 + 0x7c ], %g1 <== NOT EXECUTED 2004ab8: c4 04 60 a4 ld [ %l1 + 0xa4 ], %g2 <== NOT EXECUTED 2004abc: d0 04 60 10 ld [ %l1 + 0x10 ], %o0 <== NOT EXECUTED 2004ac0: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 2004ac4: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004ac8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 2004acc: 30 bf ff 8e b,a 2004904 <== NOT EXECUTED 02004cac : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 2004cac: 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, 2004cb0: 29 00 80 65 sethi %hi(0x2019400), %l4 2004cb4: d0 05 22 e4 ld [ %l4 + 0x2e4 ], %o0 ! 20196e4 2004cb8: 92 10 20 00 clr %o1 2004cbc: 40 00 04 51 call 2005e00 2004cc0: 94 10 20 00 clr %o2 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 2004cc4: a4 92 20 00 orcc %o0, 0, %l2 2004cc8: 32 80 00 1e bne,a 2004d40 2004ccc: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 2004cd0: 27 00 80 65 sethi %hi(0x2019400), %l3 2004cd4: e0 04 e2 ec ld [ %l3 + 0x2ec ], %l0 ! 20196ec 2004cd8: 80 a4 20 00 cmp %l0, 0 2004cdc: 32 80 00 08 bne,a 2004cfc 2004ce0: c2 04 20 0c ld [ %l0 + 0xc ], %g1 static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 2004ce4: 10 80 00 19 b 2004d48 2004ce8: 90 10 20 01 mov 1, %o0 */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 2004cec: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED 2004cf0: 02 80 00 16 be 2004d48 <== NOT EXECUTED 2004cf4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED if ((tty->major == major) && (tty->minor == minor)) 2004cf8: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED 2004cfc: 80 a0 40 18 cmp %g1, %i0 2004d00: 32 bf ff fb bne,a 2004cec 2004d04: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED 2004d08: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2004d0c: 80 a0 40 19 cmp %g1, %i1 2004d10: 32 bf ff f7 bne,a 2004cec 2004d14: e0 04 00 00 ld [ %l0 ], %l0 <== NOT EXECUTED if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; if (!tty->refcount++) { 2004d18: c2 04 20 08 ld [ %l0 + 8 ], %g1 */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 2004d1c: c4 06 80 00 ld [ %i2 ], %g2 if (!tty->refcount++) { 2004d20: 82 00 60 01 inc %g1 */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 2004d24: e0 20 a0 28 st %l0, [ %g2 + 0x28 ] if (!tty->refcount++) { 2004d28: 80 a0 60 01 cmp %g1, 1 2004d2c: 02 80 00 1e be 2004da4 2004d30: c2 24 20 08 st %g1, [ %l0 + 8 ] (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 2004d34: 40 00 05 02 call 200613c 2004d38: d0 05 22 e4 ld [ %l4 + 0x2e4 ], %o0 return RTEMS_SUCCESSFUL; } 2004d3c: b0 10 00 12 mov %l2, %i0 2004d40: 81 c7 e0 08 ret 2004d44: 81 e8 00 00 restore static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 2004d48: 7f ff f6 33 call 2002614 2004d4c: 92 10 20 e8 mov 0xe8, %o1 if (tty == NULL) { 2004d50: a2 92 20 00 orcc %o0, 0, %l1 2004d54: 12 80 00 06 bne 2004d6c 2004d58: d0 05 22 e4 ld [ %l4 + 0x2e4 ], %o0 */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); if (tty->rawInBuf.theBuf == NULL) { free(tty); rtems_semaphore_release (rtems_termios_ttyMutex); 2004d5c: 40 00 04 f8 call 200613c <== NOT EXECUTED 2004d60: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); return RTEMS_SUCCESSFUL; } 2004d64: 81 c7 e0 08 ret <== NOT EXECUTED 2004d68: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 2004d6c: 03 00 80 62 sethi %hi(0x2018800), %g1 2004d70: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20189f0 static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 2004d74: a0 10 00 11 mov %l1, %l0 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 2004d78: c4 24 60 64 st %g2, [ %l1 + 0x64 ] tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 2004d7c: d0 04 60 64 ld [ %l1 + 0x64 ], %o0 2004d80: 7f ff f5 87 call 200239c 2004d84: 01 00 00 00 nop if (tty->rawInBuf.theBuf == NULL) { 2004d88: 80 a2 20 00 cmp %o0, 0 2004d8c: 12 80 00 25 bne 2004e20 2004d90: d0 24 60 58 st %o0, [ %l1 + 0x58 ] free(tty); 2004d94: 7f ff f5 59 call 20022f8 <== NOT EXECUTED 2004d98: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 2004d9c: 10 bf ff f0 b 2004d5c <== NOT EXECUTED 2004da0: d0 05 22 e4 ld [ %l4 + 0x2e4 ], %o0 <== NOT EXECUTED c = 'a'; } args->iop->data1 = tty; if (!tty->refcount++) { if (tty->device.firstOpen) 2004da4: c2 04 20 98 ld [ %l0 + 0x98 ], %g1 2004da8: 80 a0 60 00 cmp %g1, 0 2004dac: 02 80 00 05 be 2004dc0 2004db0: 90 10 00 18 mov %i0, %o0 (*tty->device.firstOpen)(major, minor, arg); 2004db4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2004db8: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004dbc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2004dc0: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004dc4: 80 a0 60 02 cmp %g1, 2 2004dc8: 12 bf ff db bne 2004d34 2004dcc: 13 00 80 14 sethi %hi(0x2005000), %o1 sc = rtems_task_start(tty->rxTaskId, 2004dd0: d0 04 20 c4 ld [ %l0 + 0xc4 ], %o0 <== NOT EXECUTED 2004dd4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 2004dd8: 40 00 06 25 call 200666c <== NOT EXECUTED 2004ddc: 92 12 61 80 or %o1, 0x180, %o1 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 2004de0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004de4: 22 80 00 05 be,a 2004df8 <== NOT EXECUTED 2004de8: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004dec: 40 00 07 21 call 2006a70 <== NOT EXECUTED 2004df0: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_task_start(tty->txTaskId, 2004df4: d0 04 20 c8 ld [ %l0 + 0xc8 ], %o0 <== NOT EXECUTED 2004df8: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 2004dfc: 13 00 80 14 sethi %hi(0x2005000), %o1 <== NOT EXECUTED 2004e00: 40 00 06 1b call 200666c <== NOT EXECUTED 2004e04: 92 12 62 10 or %o1, 0x210, %o1 ! 2005210 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 2004e08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2004e0c: 02 bf ff ca be 2004d34 <== NOT EXECUTED 2004e10: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2004e14: 40 00 07 17 call 2006a70 <== NOT EXECUTED 2004e18: 01 00 00 00 nop <== NOT EXECUTED 2004e1c: 30 bf ff c6 b,a 2004d34 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 2004e20: 03 00 80 62 sethi %hi(0x2018800), %g1 2004e24: c4 00 61 f4 ld [ %g1 + 0x1f4 ], %g2 ! 20189f4 2004e28: c4 24 60 88 st %g2, [ %l1 + 0x88 ] tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 2004e2c: d0 04 60 88 ld [ %l1 + 0x88 ], %o0 2004e30: 7f ff f5 5b call 200239c 2004e34: 01 00 00 00 nop if (tty->rawOutBuf.theBuf == NULL) { 2004e38: 80 a2 20 00 cmp %o0, 0 2004e3c: 12 80 00 0b bne 2004e68 2004e40: d0 24 60 7c st %o0, [ %l1 + 0x7c ] free((void *)(tty->rawInBuf.theBuf)); 2004e44: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED free(tty); rtems_semaphore_release (rtems_termios_ttyMutex); 2004e48: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); free((void *)(tty->rawInBuf.theBuf)); 2004e4c: 7f ff f5 2b call 20022f8 <== NOT EXECUTED 2004e50: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED free(tty); 2004e54: 7f ff f5 29 call 20022f8 <== NOT EXECUTED 2004e58: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 2004e5c: 40 00 04 b8 call 200613c <== NOT EXECUTED 2004e60: d0 05 22 e4 ld [ %l4 + 0x2e4 ], %o0 <== NOT EXECUTED 2004e64: 30 bf ff b7 b,a 2004d40 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 2004e68: 03 00 80 62 sethi %hi(0x2018800), %g1 2004e6c: 7f ff f5 4c call 200239c 2004e70: d0 00 61 ec ld [ %g1 + 0x1ec ], %o0 ! 20189ec if (tty->cbuf == NULL) { 2004e74: 80 a2 20 00 cmp %o0, 0 2004e78: 12 80 00 07 bne 2004e94 2004e7c: d0 24 60 1c st %o0, [ %l1 + 0x1c ] free((void *)(tty->rawOutBuf.theBuf)); 2004e80: d0 04 60 7c ld [ %l1 + 0x7c ], %o0 <== NOT EXECUTED 2004e84: 7f ff f5 1d call 20022f8 <== NOT EXECUTED 2004e88: a4 10 20 1a mov 0x1a, %l2 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 2004e8c: 10 bf ff f0 b 2004e4c <== NOT EXECUTED 2004e90: d0 04 60 58 ld [ %l1 + 0x58 ], %o0 <== NOT EXECUTED tty->tty_rcvwakeup = 0; /* * link tty */ tty->forw = rtems_termios_ttyHead; 2004e94: c2 04 e2 ec ld [ %l3 + 0x2ec ], %g1 return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 2004e98: c0 24 60 d4 clr [ %l1 + 0xd4 ] tty->tty_snd.sw_arg = NULL; 2004e9c: c0 24 60 d8 clr [ %l1 + 0xd8 ] tty->tty_rcv.sw_pfn = NULL; 2004ea0: c0 24 60 dc clr [ %l1 + 0xdc ] tty->tty_rcv.sw_arg = NULL; 2004ea4: c0 24 60 e0 clr [ %l1 + 0xe0 ] tty->tty_rcvwakeup = 0; 2004ea8: c0 24 60 e4 clr [ %l1 + 0xe4 ] /* * link tty */ tty->forw = rtems_termios_ttyHead; 2004eac: c2 24 40 00 st %g1, [ %l1 ] tty->back = NULL; if (rtems_termios_ttyHead != NULL) 2004eb0: 80 a0 60 00 cmp %g1, 0 2004eb4: 02 80 00 03 be 2004ec0 2004eb8: c0 24 60 04 clr [ %l1 + 4 ] rtems_termios_ttyHead->back = tty; 2004ebc: e2 20 60 04 st %l1, [ %g1 + 4 ] <== NOT EXECUTED rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) 2004ec0: 07 00 80 65 sethi %hi(0x2019400), %g3 2004ec4: c4 00 e2 e8 ld [ %g3 + 0x2e8 ], %g2 ! 20196e8 */ tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; 2004ec8: 03 00 80 65 sethi %hi(0x2019400), %g1 if (rtems_termios_ttyTail == NULL) 2004ecc: 80 a0 a0 00 cmp %g2, 0 2004ed0: 02 80 00 72 be 2005098 2004ed4: e0 20 62 ec st %l0, [ %g1 + 0x2ec ] tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 2004ed8: 27 00 80 62 sethi %hi(0x2018800), %l3 2004edc: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 ! 20189f8 2004ee0: 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; 2004ee4: f2 24 20 10 st %i1, [ %l0 + 0x10 ] tty->major = major; 2004ee8: f0 24 20 0c st %i0, [ %l0 + 0xc ] /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 2004eec: 90 12 21 00 or %o0, 0x100, %o0 2004ef0: 92 10 20 01 mov 1, %o1 2004ef4: 90 10 40 08 or %g1, %o0, %o0 2004ef8: 94 10 20 54 mov 0x54, %o2 2004efc: 96 10 20 00 clr %o3 2004f00: 40 00 02 e9 call 2005aa4 2004f04: 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) 2004f08: 80 a2 20 00 cmp %o0, 0 2004f0c: 12 80 00 99 bne 2005170 2004f10: 01 00 00 00 nop rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 2004f14: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 2004f18: 11 15 14 9b sethi %hi(0x54526c00), %o0 2004f1c: 92 10 20 01 mov 1, %o1 2004f20: 90 12 23 00 or %o0, 0x300, %o0 2004f24: 94 10 20 54 mov 0x54, %o2 2004f28: 90 10 40 08 or %g1, %o0, %o0 2004f2c: 96 10 20 00 clr %o3 2004f30: 40 00 02 dd call 2005aa4 2004f34: 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) 2004f38: 80 a2 20 00 cmp %o0, 0 2004f3c: 12 80 00 89 bne 2005160 2004f40: 01 00 00 00 nop rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 2004f44: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 2004f48: 11 15 14 9e sethi %hi(0x54527800), %o0 2004f4c: 92 10 20 00 clr %o1 2004f50: 90 10 40 08 or %g1, %o0, %o0 2004f54: 94 10 20 20 mov 0x20, %o2 2004f58: 96 10 20 00 clr %o3 2004f5c: 40 00 02 d2 call 2005aa4 2004f60: 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) 2004f64: 80 a2 20 00 cmp %o0, 0 2004f68: 12 80 00 7a bne 2005150 2004f6c: 01 00 00 00 nop rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 2004f70: c0 24 20 94 clr [ %l0 + 0x94 ] /* * Set callbacks */ tty->device = *callbacks; 2004f74: 92 10 00 1b mov %i3, %o1 2004f78: 90 04 20 98 add %l0, 0x98, %o0 2004f7c: 40 00 2a 26 call 200f814 2004f80: 94 10 20 20 mov 0x20, %o2 /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 2004f84: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 2004f88: 80 a0 60 02 cmp %g1, 2 2004f8c: 02 80 00 54 be 20050dc 2004f90: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 2004f94: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 2004f98: 80 a0 60 00 cmp %g1, 0 2004f9c: 02 80 00 41 be 20050a0 2004fa0: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 2004fa4: c2 04 60 b4 ld [ %l1 + 0xb4 ], %g1 2004fa8: 80 a0 60 02 cmp %g1, 2 2004fac: 02 80 00 3d be 20050a0 2004fb0: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2004fb4: c8 0c e1 f8 ldub [ %l3 + 0x1f8 ], %g4 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; 2004fb8: c0 24 60 b8 clr [ %l1 + 0xb8 ] /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 2004fbc: c2 04 60 64 ld [ %l1 + 0x64 ], %g1 tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2004fc0: 88 01 20 01 inc %g4 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; 2004fc4: da 04 60 64 ld [ %l1 + 0x64 ], %o5 /* 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; 2004fc8: 83 30 60 01 srl %g1, 1, %g1 tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2004fcc: c8 2c e1 f8 stb %g4, [ %l3 + 0x1f8 ] /* 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; 2004fd0: c2 24 60 bc st %g1, [ %l1 + 0xbc ] } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 2004fd4: 03 00 00 09 sethi %hi(0x2400), %g1 2004fd8: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 tty->termios.c_oflag = OPOST | ONLCR | XTABS; 2004fdc: 05 00 00 06 sethi %hi(0x1800), %g2 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 2004fe0: c2 24 60 30 st %g1, [ %l1 + 0x30 ] tty->termios.c_oflag = OPOST | ONLCR | XTABS; 2004fe4: 84 10 a0 05 or %g2, 5, %g2 tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 2004fe8: 03 00 00 20 sethi %hi(0x8000), %g1 2004fec: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; 2004ff0: c4 24 60 34 st %g2, [ %l1 + 0x34 ] tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 2004ff4: c2 24 60 3c st %g1, [ %l1 + 0x3c ] tty->termios.c_cc[VINTR] = '\003'; 2004ff8: 84 10 20 03 mov 3, %g2 tty->termios.c_cc[VQUIT] = '\034'; 2004ffc: 82 10 20 1c mov 0x1c, %g1 tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 2005000: c4 2c 60 41 stb %g2, [ %l1 + 0x41 ] tty->termios.c_cc[VQUIT] = '\034'; 2005004: c2 2c 60 42 stb %g1, [ %l1 + 0x42 ] tty->termios.c_cc[VERASE] = '\177'; 2005008: 84 10 20 7f mov 0x7f, %g2 tty->termios.c_cc[VKILL] = '\025'; 200500c: 82 10 20 15 mov 0x15, %g1 tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; tty->termios.c_cc[VQUIT] = '\034'; tty->termios.c_cc[VERASE] = '\177'; 2005010: c4 2c 60 43 stb %g2, [ %l1 + 0x43 ] tty->termios.c_cc[VKILL] = '\025'; 2005014: c2 2c 60 44 stb %g1, [ %l1 + 0x44 ] tty->termios.c_cc[VEOF] = '\004'; 2005018: 84 10 20 04 mov 4, %g2 tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021'; 200501c: 82 10 20 11 mov 0x11, %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'; 2005020: c4 2c 60 45 stb %g2, [ %l1 + 0x45 ] tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021'; 2005024: c2 2c 60 49 stb %g1, [ %l1 + 0x49 ] tty->termios.c_cc[VSTOP] = '\023'; 2005028: 84 10 20 13 mov 0x13, %g2 tty->termios.c_cc[VSUSP] = '\032'; 200502c: 82 10 20 1a mov 0x1a, %g1 /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 2005030: 86 10 28 bd mov 0x8bd, %g3 tty->termios.c_cc[VKILL] = '\025'; tty->termios.c_cc[VEOF] = '\004'; tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021'; tty->termios.c_cc[VSTOP] = '\023'; 2005034: c4 2c 60 4a stb %g2, [ %l1 + 0x4a ] tty->termios.c_cc[VSUSP] = '\032'; 2005038: c2 2c 60 4b stb %g1, [ %l1 + 0x4b ] tty->termios.c_cc[VREPRINT] = '\022'; 200503c: 84 10 20 12 mov 0x12, %g2 tty->termios.c_cc[VDISCARD] = '\017'; 2005040: 82 10 20 0f mov 0xf, %g1 /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 2005044: c6 24 60 38 st %g3, [ %l1 + 0x38 ] tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021'; tty->termios.c_cc[VSTOP] = '\023'; tty->termios.c_cc[VSUSP] = '\032'; tty->termios.c_cc[VREPRINT] = '\022'; 2005048: c4 2c 60 4d stb %g2, [ %l1 + 0x4d ] tty->termios.c_cc[VDISCARD] = '\017'; 200504c: c2 2c 60 4e stb %g1, [ %l1 + 0x4e ] tty->termios.c_cc[VWERASE] = '\027'; 2005050: 84 10 20 17 mov 0x17, %g2 tty->termios.c_cc[VLNEXT] = '\026'; 2005054: 86 10 20 16 mov 0x16, %g3 tty->flow_ctrl = 0; /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4; 2005058: 83 2b 60 01 sll %o5, 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'; 200505c: c0 2c 60 4c clrb [ %l1 + 0x4c ] 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; 2005060: 82 00 40 0d add %g1, %o5, %g1 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'; 2005064: 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; 2005068: 83 30 60 02 srl %g1, 2, %g1 tty->termios.c_cc[VSTART] = '\021'; tty->termios.c_cc[VSTOP] = '\023'; tty->termios.c_cc[VSUSP] = '\032'; tty->termios.c_cc[VREPRINT] = '\022'; tty->termios.c_cc[VDISCARD] = '\017'; tty->termios.c_cc[VWERASE] = '\027'; 200506c: c4 2c 60 4f stb %g2, [ %l1 + 0x4f ] tty->termios.c_cc[VLNEXT] = '\026'; 2005070: c6 2c 60 50 stb %g3, [ %l1 + 0x50 ] tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 2005074: 89 29 20 18 sll %g4, 0x18, %g4 2005078: 89 39 20 18 sra %g4, 0x18, %g4 200507c: 80 a1 20 7b cmp %g4, 0x7b 2005080: 12 bf ff 26 bne 2004d18 2005084: c2 24 60 c0 st %g1, [ %l1 + 0xc0 ] c = 'a'; 2005088: 84 10 20 61 mov 0x61, %g2 <== NOT EXECUTED 200508c: 03 00 80 62 sethi %hi(0x2018800), %g1 <== NOT EXECUTED 2005090: 10 bf ff 22 b 2004d18 <== NOT EXECUTED 2005094: c4 28 61 f8 stb %g2, [ %g1 + 0x1f8 ] ! 20189f8 <== NOT EXECUTED tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) rtems_termios_ttyTail = tty; 2005098: 10 bf ff 90 b 2004ed8 200509c: e0 20 e2 e8 st %l0, [ %g3 + 0x2e8 ] rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 20050a0: 11 15 14 9c sethi %hi(0x54527000), %o0 <== NOT EXECUTED 20050a4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20050a8: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED 20050ac: 94 10 20 24 mov 0x24, %o2 <== NOT EXECUTED 20050b0: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 20050b4: 96 10 20 00 clr %o3 <== NOT EXECUTED 20050b8: 40 00 02 7b call 2005aa4 <== NOT EXECUTED 20050bc: 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) 20050c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20050c4: 22 bf ff bd be,a 2004fb8 <== NOT EXECUTED 20050c8: c8 0c e1 f8 ldub [ %l3 + 0x1f8 ], %g4 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20050cc: 40 00 06 69 call 2006a70 <== NOT EXECUTED 20050d0: 01 00 00 00 nop <== NOT EXECUTED tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') 20050d4: 10 bf ff b9 b 2004fb8 <== NOT EXECUTED 20050d8: c8 0c e1 f8 ldub [ %l3 + 0x1f8 ], %g4 <== NOT EXECUTED /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 20050dc: 11 15 1e 15 sethi %hi(0x54785400), %o0 <== NOT EXECUTED 20050e0: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 20050e4: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 20050e8: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED 20050ec: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED 20050f0: 98 10 20 00 clr %o4 <== NOT EXECUTED 20050f4: 40 00 04 5f call 2006270 <== NOT EXECUTED 20050f8: 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) 20050fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2005100: 02 80 00 05 be 2005114 <== NOT EXECUTED 2005104: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2005108: 40 00 06 5a call 2006a70 <== NOT EXECUTED 200510c: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_task_create ( 2005110: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 <== NOT EXECUTED 2005114: 11 14 9e 15 sethi %hi(0x52785400), %o0 <== NOT EXECUTED 2005118: 92 10 20 09 mov 9, %o1 <== NOT EXECUTED 200511c: 90 10 40 08 or %g1, %o0, %o0 <== NOT EXECUTED 2005120: 94 10 24 00 mov 0x400, %o2 <== NOT EXECUTED 2005124: 96 10 25 00 mov 0x500, %o3 <== NOT EXECUTED 2005128: 98 10 20 00 clr %o4 <== NOT EXECUTED 200512c: 40 00 04 51 call 2006270 <== NOT EXECUTED 2005130: 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) 2005134: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2005138: 22 bf ff 98 be,a 2004f98 <== NOT EXECUTED 200513c: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 2005140: 40 00 06 4c call 2006a70 <== NOT EXECUTED 2005144: 01 00 00 00 nop <== NOT EXECUTED } if ((tty->device.pollRead == NULL) || 2005148: 10 bf ff 94 b 2004f98 <== NOT EXECUTED 200514c: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1 <== NOT EXECUTED 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 2005150: 40 00 06 48 call 2006a70 <== NOT EXECUTED 2005154: 01 00 00 00 nop <== NOT EXECUTED tty->rawOutBufState = rob_idle; 2005158: 10 bf ff 87 b 2004f74 <== NOT EXECUTED 200515c: c0 24 20 94 clr [ %l0 + 0x94 ] <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->osem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 2005160: 40 00 06 44 call 2006a70 <== NOT EXECUTED 2005164: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_create ( 2005168: 10 bf ff 78 b 2004f48 <== NOT EXECUTED 200516c: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->isem); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 2005170: 40 00 06 40 call 2006a70 <== NOT EXECUTED 2005174: 01 00 00 00 nop <== NOT EXECUTED sc = rtems_semaphore_create ( 2005178: 10 bf ff 68 b 2004f18 <== NOT EXECUTED 200517c: c2 4c e1 f8 ldsb [ %l3 + 0x1f8 ], %g1 <== NOT EXECUTED 02003920 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 2003920: 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) { 2003924: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1 2003928: 80 a0 60 00 cmp %g1, 0 200392c: 22 80 00 4c be,a 2003a5c 2003930: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; 2003934: e4 06 a0 80 ld [ %i2 + 0x80 ], %l2 <== NOT EXECUTED while (len) { 2003938: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 200393c: 02 80 00 4c be 2003a6c <== NOT EXECUTED 2003940: 01 00 00 00 nop <== NOT EXECUTED * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 2003944: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1 <== NOT EXECUTED 2003948: 40 00 4a 27 call 20161e4 <.urem> <== NOT EXECUTED 200394c: 90 04 a0 01 add %l2, 1, %o0 <== NOT EXECUTED rtems_interrupt_disable (level); 2003950: 7f ff f9 2b call 2001dfc <== NOT EXECUTED 2003954: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED 2003958: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED while (newHead == tty->rawOutBuf.Tail) { 200395c: e2 06 a0 84 ld [ %i2 + 0x84 ], %l1 <== NOT EXECUTED 2003960: 80 a4 40 12 cmp %l1, %l2 <== NOT EXECUTED 2003964: 02 80 00 0a be 200398c <== NOT EXECUTED 2003968: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED 200396c: 30 80 00 1b b,a 20039d8 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 2003970: 7f ff f9 23 call 2001dfc <== NOT EXECUTED 2003974: 01 00 00 00 nop <== NOT EXECUTED 2003978: 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) { 200397c: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1 <== NOT EXECUTED 2003980: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 2003984: 12 80 00 15 bne 20039d8 <== NOT EXECUTED 2003988: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED tty->rawOutBufState = rob_wait; 200398c: c2 26 a0 94 st %g1, [ %i2 + 0x94 ] <== NOT EXECUTED rtems_interrupt_enable (level); 2003990: 7f ff f9 1f call 2001e0c <== NOT EXECUTED 2003994: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 2003998: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0 <== NOT EXECUTED 200399c: 92 10 20 00 clr %o1 <== NOT EXECUTED 20039a0: 40 00 09 18 call 2005e00 <== NOT EXECUTED 20039a4: 94 10 20 00 clr %o2 <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 20039a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20039ac: 02 bf ff f1 be 2003970 <== NOT EXECUTED 20039b0: 01 00 00 00 nop <== NOT EXECUTED rtems_fatal_error_occurred (sc); 20039b4: 40 00 0c 2f call 2006a70 <== NOT EXECUTED 20039b8: 01 00 00 00 nop <== NOT EXECUTED rtems_interrupt_disable (level); 20039bc: 7f ff f9 10 call 2001dfc <== NOT EXECUTED 20039c0: 01 00 00 00 nop <== NOT EXECUTED 20039c4: 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) { 20039c8: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1 <== NOT EXECUTED 20039cc: 80 a0 40 11 cmp %g1, %l1 <== NOT EXECUTED 20039d0: 02 bf ff ef be 200398c <== NOT EXECUTED 20039d4: 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++; 20039d8: c8 06 a0 80 ld [ %i2 + 0x80 ], %g4 <== NOT EXECUTED 20039dc: c4 0e 00 00 ldub [ %i0 ], %g2 <== NOT EXECUTED 20039e0: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED 20039e4: c4 28 40 04 stb %g2, [ %g1 + %g4 ] <== NOT EXECUTED tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { 20039e8: c6 06 a0 94 ld [ %i2 + 0x94 ], %g3 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; 20039ec: e4 26 a0 80 st %l2, [ %i2 + 0x80 ] <== NOT EXECUTED if (tty->rawOutBufState == rob_idle) { 20039f0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 20039f4: 12 80 00 0b bne 2003a20 <== NOT EXECUTED 20039f8: 01 00 00 00 nop <== NOT EXECUTED /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 20039fc: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED 2003a00: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED 2003a04: 02 80 00 0d be 2003a38 <== NOT EXECUTED 2003a08: 01 00 00 00 nop <== NOT EXECUTED (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 2003a0c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED 2003a10: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED 2003a14: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 2003a18: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 2003a1c: c2 26 a0 94 st %g1, [ %i2 + 0x94 ] <== NOT EXECUTED } rtems_interrupt_enable (level); 2003a20: 7f ff f8 fb call 2001e0c <== NOT EXECUTED 2003a24: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 2003a28: b2 86 7f ff addcc %i1, -1, %i1 <== NOT EXECUTED 2003a2c: 02 80 00 10 be 2003a6c <== NOT EXECUTED 2003a30: b0 06 20 01 inc %i0 <== NOT EXECUTED 2003a34: 30 bf ff c4 b,a 2003944 <== NOT EXECUTED tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)(tty->minor, 2003a38: d2 06 a0 84 ld [ %i2 + 0x84 ], %o1 <== NOT EXECUTED 2003a3c: c2 06 a0 7c ld [ %i2 + 0x7c ], %g1 <== NOT EXECUTED 2003a40: c4 06 a0 a4 ld [ %i2 + 0xa4 ], %g2 <== NOT EXECUTED 2003a44: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0 <== NOT EXECUTED 2003a48: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED 2003a4c: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003a50: 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; 2003a54: 10 bf ff f2 b 2003a1c <== NOT EXECUTED 2003a58: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); 2003a5c: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1 2003a60: 92 10 00 18 mov %i0, %o1 2003a64: 9f c0 40 00 call %g1 2003a68: 94 10 00 19 mov %i1, %o2 2003a6c: 81 c7 e0 08 ret 2003a70: 81 e8 00 00 restore 02004298 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 2004298: 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; 200429c: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED uint32_t count = args->count; 20042a0: e2 06 20 0c ld [ %i0 + 0xc ], %l1 <== 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; 20042a4: e0 00 60 28 ld [ %g1 + 0x28 ], %l0 <== NOT EXECUTED uint32_t count = args->count; char *buffer = args->buffer; 20042a8: e4 06 20 08 ld [ %i0 + 8 ], %l2 <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 20042ac: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 20042b0: 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); 20042b4: 92 10 20 00 clr %o1 <== NOT EXECUTED 20042b8: 40 00 06 d2 call 2005e00 <== NOT EXECUTED 20042bc: 94 10 20 00 clr %o2 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 20042c0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 20042c4: 12 80 00 10 bne 2004304 <== NOT EXECUTED 20042c8: 03 00 80 64 sethi %hi(0x2019000), %g1 <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 20042cc: c4 04 20 cc ld [ %l0 + 0xcc ], %g2 <== NOT EXECUTED 20042d0: 82 10 63 2c or %g1, 0x32c, %g1 <== NOT EXECUTED 20042d4: 85 28 a0 05 sll %g2, 5, %g2 <== NOT EXECUTED 20042d8: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED 20042dc: c2 00 a0 08 ld [ %g2 + 8 ], %g1 <== NOT EXECUTED 20042e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20042e4: 02 80 00 0a be 200430c <== NOT EXECUTED 20042e8: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 20042ec: 9f c0 40 00 call %g1 <== NOT EXECUTED 20042f0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 20042f4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); 20042f8: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED 20042fc: 40 00 07 90 call 200613c <== NOT EXECUTED 2004300: c0 24 20 e4 clr [ %l0 + 0xe4 ] <== NOT EXECUTED 2004304: 81 c7 e0 08 ret <== NOT EXECUTED 2004308: 81 e8 00 00 restore <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { 200430c: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED 2004310: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2004314: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004318: 22 80 00 20 be,a 2004398 <== NOT EXECUTED 200431c: c2 04 20 28 ld [ %l0 + 0x28 ], %g1 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 2004320: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 2004324: 22 80 00 16 be,a 200437c <== NOT EXECUTED 2004328: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED 200432c: c6 04 20 24 ld [ %l0 + 0x24 ], %g3 <== NOT EXECUTED 2004330: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2004334: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 2004338: 26 80 00 09 bl,a 200435c <== NOT EXECUTED 200433c: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 2004340: 10 80 00 0f b 200437c <== NOT EXECUTED 2004344: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 2004348: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 200434c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2004350: 24 80 00 0b ble,a 200437c <== NOT EXECUTED 2004354: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; 2004358: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 200435c: a2 84 7f ff addcc %l1, -1, %l1 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; 2004360: c4 08 40 03 ldub [ %g1 + %g3 ], %g2 <== NOT EXECUTED 2004364: 86 00 e0 01 inc %g3 <== NOT EXECUTED 2004368: c4 2c 80 00 stb %g2, [ %l2 ] <== NOT EXECUTED 200436c: c6 24 20 24 st %g3, [ %l0 + 0x24 ] <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 2004370: 12 bf ff f6 bne 2004348 <== NOT EXECUTED 2004374: a4 04 a0 01 inc %l2 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 2004378: c2 05 20 0c ld [ %l4 + 0xc ], %g1 <== NOT EXECUTED tty->tty_rcvwakeup = 0; 200437c: 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; 2004380: 82 20 40 11 sub %g1, %l1, %g1 <== NOT EXECUTED 2004384: c2 25 20 14 st %g1, [ %l4 + 0x14 ] <== NOT EXECUTED tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); 2004388: 40 00 07 6d call 200613c <== NOT EXECUTED 200438c: d0 04 20 14 ld [ %l0 + 0x14 ], %o0 <== NOT EXECUTED return sc; } 2004390: 81 c7 e0 08 ret <== NOT EXECUTED 2004394: 81 e8 00 00 restore <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { tty->cindex = tty->ccount = 0; tty->read_start_column = tty->column; if (tty->device.pollRead != NULL 2004398: 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; 200439c: 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; 20043a0: c0 24 20 20 clr [ %l0 + 0x20 ] <== NOT EXECUTED tty->read_start_column = tty->column; if (tty->device.pollRead != NULL 20043a4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 20043a8: 02 80 00 06 be 20043c0 <== NOT EXECUTED 20043ac: c0 24 20 24 clr [ %l0 + 0x24 ] <== NOT EXECUTED 20043b0: c2 04 20 b4 ld [ %l0 + 0xb4 ], %g1 <== NOT EXECUTED 20043b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20043b8: 22 80 00 51 be,a 20044fc <== NOT EXECUTED 20043bc: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 20043c0: e6 04 20 74 ld [ %l0 + 0x74 ], %l3 <== NOT EXECUTED 20043c4: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 20043c8: 2d 00 80 62 sethi %hi(0x2018800), %l6 <== 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, 20043cc: ae 04 20 49 add %l0, 0x49, %l7 <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 20043d0: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED 20043d4: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 20043d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20043dc: 02 80 00 3e be 20044d4 <== NOT EXECUTED 20043e0: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED 20043e4: c2 05 a1 ec ld [ %l6 + 0x1ec ], %g1 <== NOT EXECUTED 20043e8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 20043ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20043f0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20043f4: 16 80 00 38 bge 20044d4 <== NOT EXECUTED 20043f8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 20043fc: d0 04 20 5c ld [ %l0 + 0x5c ], %o0 <== NOT EXECUTED 2004400: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED 2004404: 40 00 47 78 call 20161e4 <.urem> <== NOT EXECUTED 2004408: 90 02 20 01 inc %o0 <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 200440c: 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; 2004410: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 2004414: e6 08 40 08 ldub [ %g1 + %o0 ], %l3 <== NOT EXECUTED tty->rawInBuf.Head = newHead; 2004418: d0 24 20 5c st %o0, [ %l0 + 0x5c ] <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 200441c: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 2004420: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED 2004424: d2 04 20 64 ld [ %l0 + 0x64 ], %o1 <== NOT EXECUTED 2004428: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED 200442c: 40 00 47 6e call 20161e4 <.urem> <== NOT EXECUTED 2004430: 90 22 00 02 sub %o0, %g2, %o0 <== NOT EXECUTED 2004434: c2 04 20 bc ld [ %l0 + 0xbc ], %g1 <== NOT EXECUTED 2004438: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 200443c: 3a 80 00 18 bcc,a 200449c <== NOT EXECUTED 2004440: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 2004444: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 2004448: 82 08 7f fe and %g1, -2, %g1 <== NOT EXECUTED 200444c: 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)) 2004450: c4 04 20 b8 ld [ %l0 + 0xb8 ], %g2 <== NOT EXECUTED 2004454: 84 08 a2 02 and %g2, 0x202, %g2 <== NOT EXECUTED 2004458: 80 a0 a2 02 cmp %g2, 0x202 <== NOT EXECUTED 200445c: 22 80 00 88 be,a 200467c <== NOT EXECUTED 2004460: c2 04 20 94 ld [ %l0 + 0x94 ], %g1 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 2004464: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 2004468: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED 200446c: 22 80 00 0c be,a 200449c <== NOT EXECUTED 2004470: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 2004474: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 2004478: 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; 200447c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED 2004480: c2 24 20 b8 st %g1, [ %l0 + 0xb8 ] <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 2004484: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 2004488: 22 80 00 05 be,a 200449c <== NOT EXECUTED 200448c: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 2004490: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004494: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 2004498: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED 200449c: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 20044a0: 02 80 00 63 be 200462c <== NOT EXECUTED 20044a4: 90 0c e0 ff and %l3, 0xff, %o0 <== NOT EXECUTED if (siproc (c, tty)) 20044a8: 7f ff ff 07 call 20040c4 <== NOT EXECUTED 20044ac: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 20044b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20044b4: 32 80 00 02 bne,a 20044bc <== NOT EXECUTED 20044b8: aa 10 20 00 clr %l5 <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 20044bc: c4 04 20 5c ld [ %l0 + 0x5c ], %g2 <== NOT EXECUTED 20044c0: c2 04 20 60 ld [ %l0 + 0x60 ], %g1 <== NOT EXECUTED 20044c4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 20044c8: 12 bf ff c7 bne 20043e4 <== NOT EXECUTED 20044cc: e6 04 20 70 ld [ %l0 + 0x70 ], %l3 <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 20044d0: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED 20044d4: 02 bf ff 94 be 2004324 <== NOT EXECUTED 20044d8: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 20044dc: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED 20044e0: d2 04 20 6c ld [ %l0 + 0x6c ], %o1 <== NOT EXECUTED 20044e4: 40 00 06 47 call 2005e00 <== NOT EXECUTED 20044e8: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 20044ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20044f0: 02 bf ff b8 be 20043d0 <== NOT EXECUTED 20044f4: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 20044f8: 30 bf ff 8b b,a 2004324 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 20044fc: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED 2004500: 12 80 00 3a bne 20045e8 <== NOT EXECUTED 2004504: 01 00 00 00 nop <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 2004508: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED 200450c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004510: 12 80 00 07 bne 200452c <== NOT EXECUTED 2004514: aa 07 bf f4 add %fp, -12, %l5 <== NOT EXECUTED 2004518: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED 200451c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004520: 12 80 00 3f bne 200461c <== NOT EXECUTED 2004524: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED else { siproc (n, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 2004528: 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); 200452c: a6 07 bf f0 add %fp, -16, %l3 <== 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); 2004530: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004534: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED if (n < 0) { 2004538: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200453c: 26 80 00 17 bl,a 2004598 <== NOT EXECUTED 2004540: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED } } rtems_task_wake_after (1); } else { siproc (n, tty); 2004544: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED 2004548: 7f ff fe df call 20040c4 <== NOT EXECUTED 200454c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 2004550: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED 2004554: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 2004558: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 200455c: 16 bf ff 71 bge 2004320 <== NOT EXECUTED 2004560: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 2004564: 22 80 00 07 be,a 2004580 <== NOT EXECUTED 2004568: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED 200456c: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED 2004570: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004574: 12 80 00 26 bne 200460c <== NOT EXECUTED 2004578: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED 200457c: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); for (;;) { n = (*tty->device.pollRead)(tty->minor); 2004580: 9f c0 80 00 call %g2 <== NOT EXECUTED 2004584: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED if (n < 0) { 2004588: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 200458c: 36 bf ff ef bge,a 2004548 <== NOT EXECUTED 2004590: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 2004594: c2 0c 20 47 ldub [ %l0 + 0x47 ], %g1 <== NOT EXECUTED 2004598: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200459c: 02 80 00 2c be 200464c <== NOT EXECUTED 20045a0: c2 0c 20 46 ldub [ %l0 + 0x46 ], %g1 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 20045a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20045a8: 02 80 00 06 be 20045c0 <== NOT EXECUTED 20045ac: 01 00 00 00 nop <== NOT EXECUTED 20045b0: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 20045b4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20045b8: 12 80 00 28 bne 2004658 <== NOT EXECUTED 20045bc: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 20045c0: 40 00 08 6e call 2006778 <== NOT EXECUTED 20045c4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 20045c8: 10 bf ff da b 2004530 <== NOT EXECUTED 20045cc: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED n = (*tty->device.pollRead)(tty->minor); if (n < 0) { rtems_task_wake_after (1); } else { if (siproc (n, tty)) 20045d0: 7f ff fe bd call 20040c4 <== NOT EXECUTED 20045d4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 20045d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20045dc: 12 bf ff 52 bne 2004324 <== NOT EXECUTED 20045e0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 20045e4: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED { int n; if (tty->termios.c_lflag & ICANON) { for (;;) { n = (*tty->device.pollRead)(tty->minor); 20045e8: 9f c0 80 00 call %g2 <== NOT EXECUTED 20045ec: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED if (n < 0) { 20045f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20045f4: 16 bf ff f7 bge 20045d0 <== NOT EXECUTED 20045f8: 90 0a 20 ff and %o0, 0xff, %o0 <== NOT EXECUTED rtems_task_wake_after (1); 20045fc: 40 00 08 5f call 2006778 <== NOT EXECUTED 2004600: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED 2004604: 10 bf ff f9 b 20045e8 <== NOT EXECUTED 2004608: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== 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); 200460c: 40 00 03 2c call 20052bc <== NOT EXECUTED 2004610: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 2004614: 10 bf ff db b 2004580 <== NOT EXECUTED 2004618: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 200461c: 40 00 03 28 call 20052bc <== NOT EXECUTED 2004620: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 2004624: 10 bf ff c1 b 2004528 <== NOT EXECUTED 2004628: c4 04 20 a0 ld [ %l0 + 0xa0 ], %g2 <== NOT EXECUTED if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 200462c: 7f ff fe a6 call 20040c4 <== NOT EXECUTED 2004630: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 2004634: c4 0c 20 47 ldub [ %l0 + 0x47 ], %g2 <== NOT EXECUTED 2004638: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 <== NOT EXECUTED 200463c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 2004640: 36 bf ff 9f bge,a 20044bc <== NOT EXECUTED 2004644: aa 10 20 00 clr %l5 <== NOT EXECUTED 2004648: 30 bf ff 9d b,a 20044bc <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 200464c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004650: 02 bf ff 34 be 2004320 <== NOT EXECUTED 2004654: 90 10 20 02 mov 2, %o0 <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 2004658: 40 00 03 19 call 20052bc <== NOT EXECUTED 200465c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 2004660: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 2004664: c4 1f bf f0 ldd [ %fp + -16 ], %g2 <== NOT EXECUTED 2004668: 84 20 80 03 sub %g2, %g3, %g2 <== NOT EXECUTED 200466c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2004670: 08 bf ff d4 bleu 20045c0 <== NOT EXECUTED 2004674: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 2004678: 30 bf ff 2b b,a 2004324 <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 200467c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2004680: 22 80 00 07 be,a 200469c <== NOT EXECUTED 2004684: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED 2004688: c2 04 20 b8 ld [ %l0 + 0xb8 ], %g1 <== NOT EXECUTED 200468c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED 2004690: 02 bf ff 75 be 2004464 <== NOT EXECUTED 2004694: 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, 2004698: c2 04 20 a4 ld [ %l0 + 0xa4 ], %g1 <== NOT EXECUTED 200469c: d0 04 20 10 ld [ %l0 + 0x10 ], %o0 <== NOT EXECUTED 20046a0: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED 20046a4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20046a8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 20046ac: 10 bf ff 7c b 200449c <== NOT EXECUTED 20046b0: c2 04 20 3c ld [ %l0 + 0x3c ], %g1 <== NOT EXECUTED 02003354 : * 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) { 2003354: 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)) 2003358: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 200335c: 82 08 64 03 and %g1, 0x403, %g1 <== NOT EXECUTED 2003360: 80 a0 64 01 cmp %g1, 0x401 <== NOT EXECUTED 2003364: 22 80 00 41 be,a 2003468 <== NOT EXECUTED 2003368: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 200336c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003370: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED 2003374: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2003378: 22 80 00 4c be,a 20034a8 <== NOT EXECUTED 200337c: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 2003380: c4 06 20 80 ld [ %i0 + 0x80 ], %g2 <== NOT EXECUTED 2003384: c2 06 20 84 ld [ %i0 + 0x84 ], %g1 <== NOT EXECUTED 2003388: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 200338c: 22 80 00 2f be,a 2003448 <== NOT EXECUTED 2003390: c2 06 20 94 ld [ %i0 + 0x94 ], %g1 <== NOT EXECUTED rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 2003394: 7f ff fa 9a call 2001dfc <== NOT EXECUTED 2003398: 01 00 00 00 nop <== NOT EXECUTED len = tty->t_dqlen; 200339c: e0 06 20 90 ld [ %i0 + 0x90 ], %l0 <== NOT EXECUTED tty->t_dqlen = 0; 20033a0: c0 26 20 90 clr [ %i0 + 0x90 ] <== NOT EXECUTED rtems_interrupt_enable(level); 20033a4: 7f ff fa 9a call 2001e0c <== NOT EXECUTED 20033a8: 01 00 00 00 nop <== NOT EXECUTED newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 20033ac: d0 06 20 84 ld [ %i0 + 0x84 ], %o0 <== NOT EXECUTED 20033b0: d2 06 20 88 ld [ %i0 + 0x88 ], %o1 <== NOT EXECUTED 20033b4: 40 00 4b 8c call 20161e4 <.urem> <== NOT EXECUTED 20033b8: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { 20033bc: 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; 20033c0: d0 26 20 84 st %o0, [ %i0 + 0x84 ] <== NOT EXECUTED if (tty->rawOutBufState == rob_wait) { 20033c4: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 20033c8: 02 80 00 54 be 2003518 <== NOT EXECUTED 20033cc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 20033d0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 20033d4: 80 a0 40 10 cmp %g1, %l0 <== NOT EXECUTED 20033d8: 22 80 00 44 be,a 20034e8 <== NOT EXECUTED 20033dc: c2 06 20 d4 ld [ %i0 + 0xd4 ], %g1 <== NOT EXECUTED if ( tty->tty_snd.sw_pfn != NULL) { (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 20033e0: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 20033e4: 82 08 62 10 and %g1, 0x210, %g1 <== NOT EXECUTED 20033e8: 80 a0 62 10 cmp %g1, 0x210 <== NOT EXECUTED 20033ec: 02 80 00 4e be 2003524 <== NOT EXECUTED 20033f0: 01 00 00 00 nop <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 20033f4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 20033f8: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED 20033fc: 18 80 00 18 bgu 200345c <== NOT EXECUTED 2003400: 01 00 00 00 nop <== NOT EXECUTED nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 2003404: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED 2003408: 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)) { 200340c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED 2003410: 80 88 66 00 btst 0x600, %g1 <== NOT EXECUTED 2003414: 32 80 00 02 bne,a 200341c <== NOT EXECUTED 2003418: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)(tty->minor, 200341c: d2 06 20 7c ld [ %i0 + 0x7c ], %o1 <== NOT EXECUTED 2003420: c4 06 20 a4 ld [ %i0 + 0xa4 ], %g2 <== NOT EXECUTED 2003424: 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*/ 2003428: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED (*tty->device.write)(tty->minor, 200342c: 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*/ 2003430: c2 26 20 94 st %g1, [ %i0 + 0x94 ] <== NOT EXECUTED (*tty->device.write)(tty->minor, 2003434: 9f c0 80 00 call %g2 <== NOT EXECUTED 2003438: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 200343c: e0 26 20 84 st %l0, [ %i0 + 0x84 ] <== NOT EXECUTED } return nToSend; } 2003440: 81 c7 e0 08 ret <== NOT EXECUTED 2003444: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 2003448: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200344c: 02 80 00 30 be 200350c <== NOT EXECUTED 2003450: a2 10 20 00 clr %l1 <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 2003454: 81 c7 e0 08 ret <== NOT EXECUTED 2003458: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) nToSend = tty->rawOutBuf.Size - newTail; 200345c: c2 06 20 88 ld [ %i0 + 0x88 ], %g1 <== NOT EXECUTED 2003460: 10 bf ff eb b 200340c <== NOT EXECUTED 2003464: a2 20 40 10 sub %g1, %l0, %l1 <== NOT EXECUTED /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, 2003468: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 200346c: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED 2003470: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003474: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 2003478: 7f ff fa 61 call 2001dfc <== NOT EXECUTED 200347c: 01 00 00 00 nop <== NOT EXECUTED tty->t_dqlen--; 2003480: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 2003484: 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--; 2003488: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 200348c: 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--; 2003490: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 2003494: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED rtems_interrupt_enable(level); 2003498: 7f ff fa 5d call 2001e0c <== NOT EXECUTED 200349c: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 20034a0: 81 c7 e0 08 ret <== NOT EXECUTED 20034a4: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED * FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor, 20034a8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED 20034ac: 92 06 20 49 add %i0, 0x49, %o1 <== NOT EXECUTED 20034b0: 9f c0 40 00 call %g1 <== NOT EXECUTED 20034b4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 20034b8: 7f ff fa 51 call 2001dfc <== NOT EXECUTED 20034bc: 01 00 00 00 nop <== NOT EXECUTED tty->t_dqlen--; 20034c0: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 20034c4: 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--; 20034c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 20034cc: 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--; 20034d0: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 20034d4: c4 26 20 b8 st %g2, [ %i0 + 0xb8 ] <== NOT EXECUTED rtems_interrupt_enable(level); 20034d8: 7f ff fa 4d call 2001e0c <== NOT EXECUTED 20034dc: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 20034e0: 81 c7 e0 08 ret <== NOT EXECUTED 20034e4: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 20034e8: 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) { 20034ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20034f0: 02 bf ff d3 be 200343c <== NOT EXECUTED 20034f4: a2 10 20 00 clr %l1 <== NOT EXECUTED (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 20034f8: d2 06 20 d8 ld [ %i0 + 0xd8 ], %o1 <== NOT EXECUTED 20034fc: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003500: 90 06 20 30 add %i0, 0x30, %o0 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 2003504: e0 26 20 84 st %l0, [ %i0 + 0x84 ] <== NOT EXECUTED 2003508: 30 bf ff ce b,a 2003440 <== NOT EXECUTED */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 200350c: 40 00 0b 0c call 200613c <== NOT EXECUTED 2003510: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED 2003514: 30 bf ff d0 b,a 2003454 <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 2003518: 40 00 0b 09 call 200613c <== NOT EXECUTED 200351c: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED 2003520: 30 bf ff ac b,a 20033d0 <== NOT EXECUTED /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 2003524: 7f ff fa 36 call 2001dfc <== NOT EXECUTED 2003528: 01 00 00 00 nop <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 200352c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 2003530: 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; 2003534: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 2003538: 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; 200353c: c2 26 20 b8 st %g1, [ %i0 + 0xb8 ] <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ rtems_interrupt_enable(level); 2003540: 7f ff fa 33 call 2001e0c <== NOT EXECUTED 2003544: a2 10 20 00 clr %l1 <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 2003548: e0 26 20 84 st %l0, [ %i0 + 0x84 ] <== NOT EXECUTED 200354c: 30 bf ff bd b,a 2003440 <== NOT EXECUTED 02005180 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 2005180: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 2005184: a0 07 bf f0 add %fp, -16, %l0 <== NOT EXECUTED 2005188: a2 07 bf f7 add %fp, -9, %l1 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 200518c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 2005190: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2005194: 94 10 20 00 clr %o2 <== NOT EXECUTED 2005198: 40 00 00 cf call 20054d4 <== NOT EXECUTED 200519c: 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) { 20051a0: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 20051a4: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 20051a8: 32 80 00 16 bne,a 2005200 <== NOT EXECUTED 20051ac: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 20051b0: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED 20051b4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20051b8: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED if (c != EOF) { 20051bc: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED 20051c0: 02 bf ff f3 be 200518c <== NOT EXECUTED 20051c4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 20051c8: d0 2f bf f7 stb %o0, [ %fp + -9 ] <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 20051cc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 20051d0: 7f ff f8 ff call 20035cc <== NOT EXECUTED 20051d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 20051d8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 20051dc: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 20051e0: 94 10 20 00 clr %o2 <== NOT EXECUTED 20051e4: 40 00 00 bc call 20054d4 <== NOT EXECUTED 20051e8: 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) { 20051ec: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 20051f0: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 20051f4: 22 bf ff f0 be,a 20051b4 <== NOT EXECUTED 20051f8: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED tty->rxTaskId = 0; 20051fc: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 2005200: 40 00 04 76 call 20063d8 <== NOT EXECUTED 2005204: 90 10 20 00 clr %o0 <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 2005208: 10 bf ff e2 b 2005190 <== NOT EXECUTED 200520c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 0200333c : 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); 200333c: d0 02 20 c4 ld [ %o0 + 0xc4 ], %o0 <== NOT EXECUTED 2003340: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2003344: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2003348: 40 00 08 f1 call 200570c <== NOT EXECUTED 200334c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2003350: 01 00 00 00 nop 02005210 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 2005210: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 2005214: 03 00 80 64 sethi %hi(0x2019000), %g1 <== NOT EXECUTED 2005218: a0 07 bf f4 add %fp, -12, %l0 <== NOT EXECUTED 200521c: a2 10 63 2c or %g1, 0x32c, %l1 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2005220: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2005224: 94 10 20 00 clr %o2 <== NOT EXECUTED 2005228: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 200522c: 40 00 00 aa call 20054d4 <== NOT EXECUTED 2005230: 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) { 2005234: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2005238: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200523c: 12 80 00 16 bne 2005294 <== NOT EXECUTED 2005240: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 2005244: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED 2005248: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED 200524c: 82 00 40 11 add %g1, %l1, %g1 <== NOT EXECUTED 2005250: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED 2005254: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005258: 02 80 00 04 be 2005268 <== NOT EXECUTED 200525c: 01 00 00 00 nop <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 2005260: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005264: 01 00 00 00 nop <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 2005268: 7f ff f8 3b call 2003354 <== NOT EXECUTED 200526c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 2005270: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 2005274: 94 10 20 00 clr %o2 <== NOT EXECUTED 2005278: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 200527c: 40 00 00 96 call 20054d4 <== NOT EXECUTED 2005280: 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) { 2005284: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 2005288: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED 200528c: 02 bf ff ee be 2005244 <== NOT EXECUTED 2005290: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED tty->txTaskId = 0; 2005294: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 2005298: 40 00 04 50 call 20063d8 <== NOT EXECUTED 200529c: 90 10 20 00 clr %o0 <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 20052a0: 10 bf ff e1 b 2005224 <== NOT EXECUTED 20052a4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED 02004110 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 2004110: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 2004114: c2 06 00 00 ld [ %i0 ], %g1 rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 2004118: a6 10 00 18 mov %i0, %l3 rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 200411c: e2 00 60 28 ld [ %g1 + 0x28 ], %l1 rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 2004120: 92 10 20 00 clr %o1 2004124: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 2004128: 40 00 07 36 call 2005e00 200412c: 94 10 20 00 clr %o2 if (sc != RTEMS_SUCCESSFUL) 2004130: b0 92 20 00 orcc %o0, 0, %i0 2004134: 12 80 00 0f bne 2004170 2004138: 03 00 80 64 sethi %hi(0x2019000), %g1 return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 200413c: c4 04 60 cc ld [ %l1 + 0xcc ], %g2 2004140: 82 10 63 2c or %g1, 0x32c, %g1 2004144: 85 28 a0 05 sll %g2, 5, %g2 2004148: 84 00 80 01 add %g2, %g1, %g2 200414c: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 2004150: 80 a0 60 00 cmp %g1, 0 2004154: 02 80 00 09 be 2004178 2004158: 92 10 00 13 mov %l3, %o1 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 200415c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2004160: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2004164: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED rtems_semaphore_release (tty->osem); 2004168: 40 00 07 f5 call 200613c <== NOT EXECUTED 200416c: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 <== NOT EXECUTED 2004170: 81 c7 e0 08 ret <== NOT EXECUTED 2004174: 81 e8 00 00 restore <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { 2004178: c2 04 60 34 ld [ %l1 + 0x34 ], %g1 200417c: 80 88 60 01 btst 1, %g1 2004180: 32 80 00 0c bne,a 20041b0 2004184: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 2004188: d0 04 e0 08 ld [ %l3 + 8 ], %o0 <== NOT EXECUTED 200418c: d2 04 e0 0c ld [ %l3 + 0xc ], %o1 <== NOT EXECUTED 2004190: 7f ff fd e4 call 2003920 <== NOT EXECUTED 2004194: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED args->bytes_moved = args->count; 2004198: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 <== NOT EXECUTED 200419c: c2 24 e0 14 st %g1, [ %l3 + 0x14 ] } rtems_semaphore_release (tty->osem); 20041a0: 40 00 07 e7 call 200613c 20041a4: d0 04 60 18 ld [ %l1 + 0x18 ], %o0 return sc; } 20041a8: 81 c7 e0 08 ret 20041ac: 81 e8 00 00 restore return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 20041b0: 80 a0 60 00 cmp %g1, 0 20041b4: 02 bf ff fa be 200419c 20041b8: c4 04 e0 08 ld [ %l3 + 8 ], %g2 20041bc: a0 10 00 02 mov %g2, %l0 20041c0: a4 00 80 01 add %g2, %g1, %l2 oproc (*buffer++, tty); 20041c4: d0 0c 00 00 ldub [ %l0 ], %o0 20041c8: 7f ff fe 2b call 2003a74 20041cc: 92 10 00 11 mov %l1, %o1 20041d0: 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--) 20041d4: 80 a4 00 12 cmp %l0, %l2 20041d8: 32 bf ff fc bne,a 20041c8 20041dc: 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; 20041e0: 10 bf ff ef b 200419c 20041e4: c2 04 e0 0c ld [ %l3 + 0xc ], %g1 02012abc : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 2012abc: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012ac0: 11 00 80 d0 sethi %hi(0x2034000), %o0 2012ac4: 92 10 00 18 mov %i0, %o1 2012ac8: 90 12 23 9c or %o0, 0x39c, %o0 2012acc: 40 00 0a d2 call 2015614 <_Objects_Get> 2012ad0: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012ad4: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012ad8: 80 a0 60 00 cmp %g1, 0 2012adc: 12 80 00 11 bne 2012b20 2012ae0: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 2012ae4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2012ae8: 80 a0 60 04 cmp %g1, 4 2012aec: 12 80 00 16 bne 2012b44 2012af0: 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 ) 2012af4: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2012af8: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2012afc: b0 10 20 00 clr %i0 <== NOT EXECUTED 2012b00: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 2012b04: c4 20 61 60 st %g2, [ %g1 + 0x160 ] <== NOT EXECUTED 2012b08: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 <== NOT EXECUTED 2012b0c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2012b10: 02 80 00 09 be 2012b34 <== NOT EXECUTED 2012b14: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012b18: 81 c7 e0 08 ret <== NOT EXECUTED 2012b1c: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012b20: 80 a0 00 01 cmp %g0, %g1 2012b24: 84 60 20 00 subx %g0, 0, %g2 2012b28: b0 08 a0 15 and %g2, 0x15, %i0 2012b2c: 81 c7 e0 08 ret 2012b30: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 2012b34: 40 00 0f ec call 2016ae4 <_Thread_Dispatch> 2012b38: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012b3c: 81 c7 e0 08 ret 2012b40: 81 e8 00 00 restore case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) (void) _Watchdog_Remove( &the_timer->Ticker ); 2012b44: 40 00 16 e6 call 20186dc <_Watchdog_Remove> 2012b48: 90 02 20 10 add %o0, 0x10, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2012b4c: 03 00 80 ce sethi %hi(0x2033800), %g1 2012b50: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 2012b54: b0 10 20 00 clr %i0 2012b58: 84 00 bf ff add %g2, -1, %g2 2012b5c: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 2012b60: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 2012b64: 80 a0 e0 00 cmp %g3, 0 2012b68: 12 bf ff f5 bne 2012b3c 2012b6c: 01 00 00 00 nop 2012b70: 30 bf ff f1 b,a 2012b34 02012c60 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 2012c60: 9d e3 bf 90 save %sp, -112, %sp RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012c64: 21 00 80 d0 sethi %hi(0x2034000), %l0 2012c68: 92 10 00 18 mov %i0, %o1 2012c6c: 94 07 bf f4 add %fp, -12, %o2 2012c70: 40 00 0a 69 call 2015614 <_Objects_Get> 2012c74: 90 14 23 9c or %l0, 0x39c, %o0 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012c78: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012c7c: 80 a0 60 00 cmp %g1, 0 2012c80: 12 80 00 1f bne 2012cfc 2012c84: b0 10 00 08 mov %o0, %i0 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012c88: a0 14 23 9c or %l0, 0x39c, %l0 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 2012c8c: c2 02 20 08 ld [ %o0 + 8 ], %g1 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 2012c90: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 2012c94: 05 00 00 3f sethi %hi(0xfc00), %g2 2012c98: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff 2012c9c: 82 08 40 02 and %g1, %g2, %g1 2012ca0: 80 a0 40 03 cmp %g1, %g3 2012ca4: 38 80 00 06 bgu,a 2012cbc 2012ca8: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED information->local_table[ index ] = the_object; 2012cac: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2012cb0: 83 28 60 02 sll %g1, 2, %g1 2012cb4: 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; 2012cb8: 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 ); 2012cbc: 40 00 16 88 call 20186dc <_Watchdog_Remove> 2012cc0: 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 ); 2012cc4: 90 10 00 10 mov %l0, %o0 2012cc8: 40 00 09 fc call 20154b8 <_Objects_Free> 2012ccc: 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 ) 2012cd0: 03 00 80 ce sethi %hi(0x2033800), %g1 2012cd4: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 2012cd8: b0 10 20 00 clr %i0 2012cdc: 84 00 bf ff add %g2, -1, %g2 2012ce0: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 2012ce4: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 2012ce8: 80 a0 e0 00 cmp %g3, 0 2012cec: 02 80 00 0a be 2012d14 2012cf0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012cf4: 81 c7 e0 08 ret <== NOT EXECUTED 2012cf8: 81 e8 00 00 restore <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012cfc: 82 18 60 02 xor %g1, 2, %g1 2012d00: 80 a0 00 01 cmp %g0, %g1 2012d04: 84 60 20 00 subx %g0, 0, %g2 2012d08: b0 08 a0 15 and %g2, 0x15, %i0 2012d0c: 81 c7 e0 08 ret 2012d10: 91 ee 20 04 restore %i0, 4, %o0 _Thread_Dispatch(); 2012d14: 40 00 0f 74 call 2016ae4 <_Thread_Dispatch> 2012d18: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012d1c: 81 c7 e0 08 ret 2012d20: 81 e8 00 00 restore 02012d24 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 2012d24: 9d e3 bf 90 save %sp, -112, %sp 2012d28: a4 10 00 18 mov %i0, %l2 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 2012d2c: 80 a6 60 00 cmp %i1, 0 2012d30: 02 80 00 3e be 2012e28 2012d34: b0 10 20 0a mov 0xa, %i0 return RTEMS_INVALID_NUMBER; if ( !routine ) 2012d38: 80 a6 a0 00 cmp %i2, 0 2012d3c: 02 80 00 3b be 2012e28 2012d40: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2012d44: 11 00 80 d0 sethi %hi(0x2034000), %o0 2012d48: 92 10 00 12 mov %l2, %o1 2012d4c: 90 12 23 9c or %o0, 0x39c, %o0 2012d50: 40 00 0a 31 call 2015614 <_Objects_Get> 2012d54: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012d58: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012d5c: 80 a0 60 00 cmp %g1, 0 2012d60: 12 80 00 17 bne 2012dbc 2012d64: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2012d68: a2 02 20 10 add %o0, 0x10, %l1 2012d6c: 40 00 16 5c call 20186dc <_Watchdog_Remove> 2012d70: 90 10 00 11 mov %l1, %o0 _ISR_Disable( level ); 2012d74: 7f ff df 6a call 200ab1c 2012d78: 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 ) { 2012d7c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2012d80: 80 a0 60 00 cmp %g1, 0 2012d84: 22 80 00 14 be,a 2012dd4 2012d88: f4 24 20 2c st %i2, [ %l0 + 0x2c ] _ISR_Enable( level ); 2012d8c: 7f ff df 68 call 200ab2c <== NOT EXECUTED 2012d90: 01 00 00 00 nop <== 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 ) 2012d94: 03 00 80 ce sethi %hi(0x2033800), %g1 <== NOT EXECUTED 2012d98: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2012d9c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 2012da0: c4 20 61 60 st %g2, [ %g1 + 0x160 ] <== NOT EXECUTED 2012da4: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 <== NOT EXECUTED 2012da8: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2012dac: 02 80 00 1d be 2012e20 <== NOT EXECUTED 2012db0: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2012db4: 81 c7 e0 08 ret <== NOT EXECUTED 2012db8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012dbc: 82 18 60 02 xor %g1, 2, %g1 2012dc0: 80 a0 00 01 cmp %g0, %g1 2012dc4: 84 60 20 00 subx %g0, 0, %g2 2012dc8: b0 08 a0 15 and %g2, 0x15, %i0 2012dcc: 81 c7 e0 08 ret 2012dd0: 91 ee 20 04 restore %i0, 4, %o0 void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 2012dd4: e4 24 20 30 st %l2, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2012dd8: 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; 2012ddc: c0 24 20 38 clr [ %l0 + 0x38 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2012de0: c0 24 20 18 clr [ %l0 + 0x18 ] _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 2012de4: 7f ff df 52 call 200ab2c 2012de8: 01 00 00 00 nop ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012dec: 92 10 00 11 mov %l1, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2012df0: f2 24 20 1c st %i1, [ %l0 + 0x1c ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2012df4: 11 00 80 ce sethi %hi(0x2033800), %o0 2012df8: 40 00 15 cf call 2018534 <_Watchdog_Insert> 2012dfc: 90 12 22 60 or %o0, 0x260, %o0 ! 2033a60 <_Watchdog_Ticks_chain> 2012e00: 05 00 80 ce sethi %hi(0x2033800), %g2 2012e04: c2 00 a1 60 ld [ %g2 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 2012e08: 82 00 7f ff add %g1, -1, %g1 2012e0c: c2 20 a1 60 st %g1, [ %g2 + 0x160 ] 2012e10: c6 00 a1 60 ld [ %g2 + 0x160 ], %g3 2012e14: 80 a0 e0 00 cmp %g3, 0 2012e18: 32 80 00 04 bne,a 2012e28 2012e1c: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 2012e20: 40 00 0f 31 call 2016ae4 <_Thread_Dispatch> 2012e24: b0 10 20 00 clr %i0 2012e28: 81 c7 e0 08 ret 2012e2c: 81 e8 00 00 restore 0200866c : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 200866c: 9d e3 bf 90 save %sp, -112, %sp 2008670: 92 10 00 18 mov %i0, %o1 Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 2008674: 80 a6 60 00 cmp %i1, 0 2008678: 02 80 00 1b be 20086e4 200867c: b0 10 20 09 mov 9, %i0 RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) 2008680: 11 00 80 7e sethi %hi(0x201f800), %o0 2008684: 94 07 bf f4 add %fp, -12, %o2 2008688: 40 00 07 b6 call 200a560 <_Objects_Get> 200868c: 90 12 20 10 or %o0, 0x10, %o0 return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2008690: c2 07 bf f4 ld [ %fp + -12 ], %g1 2008694: 80 a0 60 00 cmp %g1, 0 2008698: 12 80 00 15 bne 20086ec 200869c: 82 18 60 02 xor %g1, 2, %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; the_info->initial = the_timer->Ticker.initial; 20086a0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 20086a4: c6 02 20 38 ld [ %o0 + 0x38 ], %g3 the_info->initial = the_timer->Ticker.initial; 20086a8: c2 26 60 04 st %g1, [ %i1 + 4 ] the_info->start_time = the_timer->Ticker.start_time; 20086ac: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 20086b0: c6 26 40 00 st %g3, [ %i1 ] the_info->initial = the_timer->Ticker.initial; the_info->start_time = the_timer->Ticker.start_time; 20086b4: c4 26 60 08 st %g2, [ %i1 + 8 ] the_info->stop_time = the_timer->Ticker.stop_time; 20086b8: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 20086bc: 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 ) 20086c0: 07 00 80 7e sethi %hi(0x201f800), %g3 20086c4: c2 00 e1 f0 ld [ %g3 + 0x1f0 ], %g1 ! 201f9f0 <_Thread_Dispatch_disable_level> 20086c8: b0 10 20 00 clr %i0 20086cc: 82 00 7f ff add %g1, -1, %g1 20086d0: c2 20 e1 f0 st %g1, [ %g3 + 0x1f0 ] 20086d4: c4 00 e1 f0 ld [ %g3 + 0x1f0 ], %g2 20086d8: 80 a0 a0 00 cmp %g2, 0 20086dc: 02 80 00 09 be 2008700 20086e0: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20086e4: 81 c7 e0 08 ret <== NOT EXECUTED 20086e8: 81 e8 00 00 restore <== NOT EXECUTED if ( !the_info ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20086ec: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 20086f0: 84 60 20 00 subx %g0, 0, %g2 <== NOT EXECUTED 20086f4: b0 08 a0 15 and %g2, 0x15, %i0 <== NOT EXECUTED 20086f8: 81 c7 e0 08 ret <== NOT EXECUTED 20086fc: 91 ee 20 04 restore %i0, 4, %o0 <== NOT EXECUTED _Thread_Dispatch(); 2008700: 40 00 0c cc call 200ba30 <_Thread_Dispatch> 2008704: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2008708: 81 c7 e0 08 ret 200870c: 81 e8 00 00 restore 02013588 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 2013588: 9d e3 bf 90 save %sp, -112, %sp /* * Make sure the requested priority is valid. */ _priority = priority; if ( priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 201358c: 92 10 20 00 clr %o1 2013590: 80 a6 3f ff cmp %i0, -1 2013594: 02 80 00 07 be 20135b0 2013598: 94 10 00 19 mov %i1, %o2 _priority = 0; else if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) 201359c: 82 06 3f ff add %i0, -1, %g1 20135a0: 80 a0 60 fe cmp %g1, 0xfe 20135a4: 18 80 00 16 bgu 20135fc 20135a8: a2 10 20 13 mov 0x13, %l1 20135ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20135b0: 21 00 80 ce sethi %hi(0x2033800), %l0 20135b4: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 ! 2033960 <_Thread_Dispatch_disable_level> 20135b8: 82 00 60 01 inc %g1 20135bc: c2 24 21 60 st %g1, [ %l0 + 0x160 ] * Just to make sure the test versus create/start operation are atomic. */ _Thread_Disable_dispatch(); if ( _Timer_Server ) { 20135c0: 33 00 80 d0 sethi %hi(0x2034000), %i1 20135c4: c2 06 63 e8 ld [ %i1 + 0x3e8 ], %g1 ! 20343e8 <_Timer_Server> 20135c8: 80 a0 60 00 cmp %g1, 0 20135cc: 02 80 00 0e be 2013604 20135d0: 19 00 00 20 sethi %hi(0x8000), %o4 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20135d4: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 <== NOT EXECUTED 20135d8: a2 10 20 0e mov 0xe, %l1 <== NOT EXECUTED _Thread_Dispatch(); 20135dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 20135e0: c2 24 21 60 st %g1, [ %l0 + 0x160 ] 20135e4: c4 04 21 60 ld [ %l0 + 0x160 ], %g2 20135e8: 80 a0 a0 00 cmp %g2, 0 20135ec: 12 80 00 04 bne 20135fc 20135f0: 01 00 00 00 nop 20135f4: 40 00 0d 3c call 2016ae4 <_Thread_Dispatch> 20135f8: 01 00 00 00 nop _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; } 20135fc: 81 c7 e0 08 ret 2013600: 91 e8 00 11 restore %g0, %l1, %o0 * 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( 2013604: 11 15 12 53 sethi %hi(0x54494c00), %o0 2013608: 98 16 80 0c or %i2, %o4, %o4 201360c: 90 12 21 45 or %o0, 0x145, %o0 2013610: 96 10 21 00 mov 0x100, %o3 2013614: 7f ff f9 fd call 2011e08 2013618: 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) { 201361c: a2 92 20 00 orcc %o0, 0, %l1 2013620: 02 80 00 05 be 2013634 2013624: d0 07 bf f4 ld [ %fp + -12 ], %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2013628: c2 04 21 60 ld [ %l0 + 0x160 ], %g1 201362c: 10 bf ff ed b 20135e0 2013630: 82 00 7f ff add %g1, -1, %g1 _Thread_Enable_dispatch(); return status; } status = rtems_task_start( 2013634: 13 00 80 4d sethi %hi(0x2013400), %o1 2013638: 94 10 20 00 clr %o2 201363c: 7f ff fc 3d call 2012730 2013640: 92 12 60 34 or %o1, 0x34, %o1 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 2013644: a2 92 20 00 orcc %o0, 0, %l1 2013648: 12 bf ff f8 bne 2013628 201364c: 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 ) 2013650: 03 00 80 ce sethi %hi(0x2033800), %g1 2013654: 9a 10 60 14 or %g1, 0x14, %o5 ! 2033814 <_RTEMS_tasks_Information> 2013658: c4 13 60 10 lduh [ %o5 + 0x10 ], %g2 201365c: 03 00 00 3f sethi %hi(0xfc00), %g1 2013660: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 2013664: 86 09 00 01 and %g4, %g1, %g3 2013668: 80 a0 c0 02 cmp %g3, %g2 201366c: 18 80 00 05 bgu 2013680 2013670: 82 10 20 00 clr %g1 2013674: c4 03 60 20 ld [ %o5 + 0x20 ], %g2 2013678: 83 28 e0 02 sll %g3, 2, %g1 201367c: c2 00 80 01 ld [ %g2 + %g1 ], %g1 ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; the_watchdog->user_data = user_data; 2013680: c0 20 60 6c clr [ %g1 + 0x6c ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2013684: c0 20 60 50 clr [ %g1 + 0x50 ] the_watchdog->routine = routine; the_watchdog->id = id; 2013688: c8 20 60 68 st %g4, [ %g1 + 0x68 ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 201368c: 07 00 80 5a sethi %hi(0x2016800), %g3 * * 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( 2013690: c2 26 63 e8 st %g1, [ %i1 + 0x3e8 ] 2013694: 86 10 e2 40 or %g3, 0x240, %g3 2013698: c6 20 60 64 st %g3, [ %g1 + 0x64 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 201369c: 03 00 80 ce sethi %hi(0x2033800), %g1 20136a0: 82 10 60 64 or %g1, 0x64, %g1 ! 2033864 <_Timer_Ticks_chain+0x4> */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20136a4: c2 20 7f fc st %g1, [ %g1 + -4 ] 20136a8: 82 00 7f fc add %g1, -4, %g1 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20136ac: 05 00 80 ce sethi %hi(0x2033800), %g2 Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20136b0: c2 20 60 08 st %g1, [ %g1 + 8 ] */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 20136b4: 84 10 a0 78 or %g2, 0x78, %g2 RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 20136b8: c0 20 60 04 clr [ %g1 + 4 ] */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 20136bc: c4 20 bf fc st %g2, [ %g2 + -4 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20136c0: 03 00 80 ce sethi %hi(0x2033800), %g1 20136c4: 84 00 bf fc add %g2, -4, %g2 20136c8: 82 10 60 80 or %g1, 0x80, %g1 the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain); 20136cc: c4 20 a0 08 st %g2, [ %g2 + 8 ] RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 20136d0: c0 20 a0 04 clr [ %g2 + 4 ] the_watchdog->routine = routine; 20136d4: c6 20 60 1c st %g3, [ %g1 + 0x1c ] the_watchdog->id = id; 20136d8: c8 20 60 20 st %g4, [ %g1 + 0x20 ] the_watchdog->user_data = user_data; 20136dc: c0 20 60 24 clr [ %g1 + 0x24 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 20136e0: 10 bf ff d2 b 2013628 20136e4: c0 20 60 08 clr [ %g1 + 8 ] 02012f7c : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 2012f7c: 9d e3 bf 90 save %sp, -112, %sp 2012f80: 11 00 80 d0 sethi %hi(0x2034000), %o0 2012f84: 92 10 00 18 mov %i0, %o1 2012f88: 90 12 23 9c or %o0, 0x39c, %o0 2012f8c: 40 00 09 a2 call 2015614 <_Objects_Get> 2012f90: 94 07 bf f4 add %fp, -12, %o2 Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012f94: c2 07 bf f4 ld [ %fp + -12 ], %g1 2012f98: 80 a0 60 00 cmp %g1, 0 2012f9c: 12 80 00 18 bne 2012ffc 2012fa0: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 2012fa4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 2012fa8: 80 a0 60 01 cmp %g1, 1 2012fac: 22 80 00 2f be,a 2013068 2012fb0: 31 00 80 d0 sethi %hi(0x2034000), %i0 2012fb4: 2a 80 00 18 bcs,a 2013014 2012fb8: a0 02 20 10 add %o0, 0x10, %l0 2012fbc: 80 a0 60 04 cmp %g1, 4 2012fc0: 18 80 00 1b bgu 201302c 2012fc4: 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 ) 2012fc8: 03 00 80 ce sethi %hi(0x2033800), %g1 2012fcc: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 2012fd0: b0 10 20 0b mov 0xb, %i0 2012fd4: 84 00 bf ff add %g2, -1, %g2 2012fd8: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 2012fdc: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 2012fe0: 80 a0 e0 00 cmp %g3, 0 2012fe4: 12 80 00 1f bne 2013060 2012fe8: 01 00 00 00 nop _Thread_Dispatch(); 2012fec: 40 00 0e be call 2016ae4 <_Thread_Dispatch> 2012ff0: 01 00 00 00 nop 2012ff4: 81 c7 e0 08 ret 2012ff8: 81 e8 00 00 restore { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2012ffc: 82 18 60 02 xor %g1, 2, %g1 2013000: 80 a0 00 01 cmp %g0, %g1 2013004: 84 60 20 00 subx %g0, 0, %g2 2013008: b0 08 a0 15 and %g2, 0x15, %i0 201300c: 81 c7 e0 08 ret 2013010: 91 ee 20 04 restore %i0, 4, %o0 return RTEMS_INVALID_ID; case OBJECTS_LOCAL: switch ( the_timer->the_class ) { case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 2013014: 40 00 15 b2 call 20186dc <_Watchdog_Remove> 2013018: 90 10 00 10 mov %l0, %o0 _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 201301c: 11 00 80 ce sethi %hi(0x2033800), %o0 2013020: 92 10 00 10 mov %l0, %o1 2013024: 40 00 15 44 call 2018534 <_Watchdog_Insert> 2013028: 90 12 22 60 or %o0, 0x260, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201302c: 03 00 80 ce sethi %hi(0x2033800), %g1 2013030: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> 2013034: b0 10 20 00 clr %i0 2013038: 84 00 bf ff add %g2, -1, %g2 201303c: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 2013040: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 2013044: 80 a0 e0 00 cmp %g3, 0 2013048: 02 80 00 04 be 2013058 201304c: 01 00 00 00 nop _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 2013050: 81 c7 e0 08 ret <== NOT EXECUTED 2013054: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2013058: 40 00 0e a3 call 2016ae4 <_Thread_Dispatch> 201305c: 01 00 00 00 nop 2013060: 81 c7 e0 08 ret 2013064: 81 e8 00 00 restore case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 2013068: d0 06 23 e8 ld [ %i0 + 0x3e8 ], %o0 _Watchdog_Remove( &the_timer->Ticker ); 201306c: a2 04 20 10 add %l0, 0x10, %l1 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: _Timer_Server_stop_ticks_timer(); 2013070: 40 00 15 9b call 20186dc <_Watchdog_Remove> 2013074: 90 02 20 48 add %o0, 0x48, %o0 _Watchdog_Remove( &the_timer->Ticker ); 2013078: 40 00 15 99 call 20186dc <_Watchdog_Remove> 201307c: 90 10 00 11 mov %l1, %o0 _Timer_Server_process_ticks_chain(); 2013080: 40 00 00 dc call 20133f0 <_Timer_Server_process_ticks_chain> 2013084: 21 00 80 ce sethi %hi(0x2033800), %l0 _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2013088: 92 10 00 11 mov %l1, %o1 201308c: 40 00 15 2a call 2018534 <_Watchdog_Insert> 2013090: 90 14 20 60 or %l0, 0x60, %o0 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2013094: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 2013098: a0 14 20 60 or %l0, 0x60, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 201309c: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 20130a0: 80 a0 80 10 cmp %g2, %l0 20130a4: 02 bf ff e2 be 201302c 20130a8: c2 06 23 e8 ld [ %i0 + 0x3e8 ], %g1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20130ac: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20130b0: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20130b4: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 20130b8: 11 00 80 ce sethi %hi(0x2033800), %o0 20130bc: 40 00 15 1e call 2018534 <_Watchdog_Insert> 20130c0: 90 12 22 60 or %o0, 0x260, %o0 ! 2033a60 <_Watchdog_Ticks_chain> 20130c4: 30 bf ff da b,a 201302c 020130c8 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20130c8: 9d e3 bf 90 save %sp, -112, %sp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20130cc: 23 00 80 d0 sethi %hi(0x2034000), %l1 20130d0: c2 04 63 e8 ld [ %l1 + 0x3e8 ], %g1 ! 20343e8 <_Timer_Server> Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 20130d4: a6 10 00 18 mov %i0, %l3 Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 20130d8: 80 a0 60 00 cmp %g1, 0 20130dc: 02 80 00 3b be 20131c8 20130e0: b0 10 20 0e mov 0xe, %i0 return RTEMS_INCORRECT_STATE; if ( !routine ) 20130e4: 80 a6 a0 00 cmp %i2, 0 20130e8: 02 80 00 38 be 20131c8 20130ec: b0 10 20 09 mov 9, %i0 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 20130f0: 80 a6 60 00 cmp %i1, 0 20130f4: 02 80 00 35 be 20131c8 20130f8: b0 10 20 0a mov 0xa, %i0 20130fc: 11 00 80 d0 sethi %hi(0x2034000), %o0 2013100: 92 10 00 13 mov %l3, %o1 2013104: 90 12 23 9c or %o0, 0x39c, %o0 2013108: 40 00 09 43 call 2015614 <_Objects_Get> 201310c: 94 07 bf f4 add %fp, -12, %o2 return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 2013110: c2 07 bf f4 ld [ %fp + -12 ], %g1 2013114: 80 a0 60 00 cmp %g1, 0 2013118: 12 80 00 30 bne 20131d8 201311c: a0 10 00 08 mov %o0, %l0 case OBJECTS_ERROR: return RTEMS_INVALID_ID; case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 2013120: a4 02 20 10 add %o0, 0x10, %l2 2013124: 40 00 15 6e call 20186dc <_Watchdog_Remove> 2013128: 90 10 00 12 mov %l2, %o0 _ISR_Disable( level ); 201312c: 7f ff de 7c call 200ab1c 2013130: 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 ) { 2013134: c2 04 20 18 ld [ %l0 + 0x18 ], %g1 2013138: 80 a0 60 00 cmp %g1, 0 201313c: 12 80 00 2d bne 20131f0 2013140: 82 10 20 01 mov 1, %g1 * 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; 2013144: f2 24 20 1c st %i1, [ %l0 + 0x1c ] Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 2013148: f4 24 20 2c st %i2, [ %l0 + 0x2c ] the_watchdog->id = id; 201314c: e6 24 20 30 st %l3, [ %l0 + 0x30 ] the_watchdog->user_data = user_data; 2013150: f6 24 20 34 st %i3, [ %l0 + 0x34 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 2013154: 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; 2013158: 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 ); 201315c: 7f ff de 74 call 200ab2c 2013160: 21 00 80 ce sethi %hi(0x2033800), %l0 _Timer_Server_stop_ticks_timer(); 2013164: d0 04 63 e8 ld [ %l1 + 0x3e8 ], %o0 2013168: 40 00 15 5d call 20186dc <_Watchdog_Remove> 201316c: 90 02 20 48 add %o0, 0x48, %o0 _Timer_Server_process_ticks_chain(); 2013170: 40 00 00 a0 call 20133f0 <_Timer_Server_process_ticks_chain> 2013174: 01 00 00 00 nop _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 2013178: 90 14 20 60 or %l0, 0x60, %o0 201317c: 40 00 14 ee call 2018534 <_Watchdog_Insert> 2013180: 92 10 00 12 mov %l2, %o1 */ RTEMS_INLINE_ROUTINE boolean _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 2013184: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 2013188: a0 14 20 60 or %l0, 0x60, %l0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 201318c: a0 04 20 04 add %l0, 4, %l0 _Timer_Server_reset_ticks_timer(); 2013190: 80 a0 80 10 cmp %g2, %l0 2013194: 12 80 00 1a bne 20131fc 2013198: c2 04 63 e8 ld [ %l1 + 0x3e8 ], %g1 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 201319c: 03 00 80 ce sethi %hi(0x2033800), %g1 20131a0: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 2033960 <_Thread_Dispatch_disable_level> _Thread_Dispatch(); 20131a4: b0 10 20 00 clr %i0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 20131a8: 84 00 bf ff add %g2, -1, %g2 20131ac: c4 20 61 60 st %g2, [ %g1 + 0x160 ] 20131b0: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 20131b4: 80 a0 e0 00 cmp %g3, 0 20131b8: 12 80 00 06 bne 20131d0 20131bc: 01 00 00 00 nop _Thread_Dispatch(); 20131c0: 40 00 0e 49 call 2016ae4 <_Thread_Dispatch> 20131c4: b0 10 20 00 clr %i0 ! 0 20131c8: 81 c7 e0 08 ret 20131cc: 81 e8 00 00 restore _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */ } 20131d0: 81 c7 e0 08 ret <== NOT EXECUTED 20131d4: 81 e8 00 00 restore <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 20131d8: 82 18 60 02 xor %g1, 2, %g1 20131dc: 80 a0 00 01 cmp %g0, %g1 20131e0: 84 60 20 00 subx %g0, 0, %g2 20131e4: b0 08 a0 15 and %g2, 0x15, %i0 20131e8: 81 c7 e0 08 ret 20131ec: 91 ee 20 04 restore %i0, 4, %o0 * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 20131f0: 7f ff de 4f call 200ab2c <== NOT EXECUTED 20131f4: 01 00 00 00 nop <== NOT EXECUTED 20131f8: 30 bf ff e9 b,a 201319c <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 20131fc: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013200: 92 00 60 48 add %g1, 0x48, %o1 Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 2013204: c4 20 60 54 st %g2, [ %g1 + 0x54 ] _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 2013208: 11 00 80 ce sethi %hi(0x2033800), %o0 201320c: 40 00 14 ca call 2018534 <_Watchdog_Insert> 2013210: 90 12 22 60 or %o0, 0x260, %o0 ! 2033a60 <_Watchdog_Ticks_chain> 2013214: 30 bf ff e2 b,a 201319c 02008a54 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 2008a54: 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) 2008a58: 03 08 00 00 sethi %hi(0x20000000), %g1 <== NOT EXECUTED 2008a5c: a8 8e 00 01 andcc %i0, %g1, %l4 <== NOT EXECUTED 2008a60: 02 80 00 10 be 2008aa0 <== NOT EXECUTED 2008a64: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED { if (rtems_panic_in_progress++) 2008a68: 07 00 80 ad sethi %hi(0x202b400), %g3 <== NOT EXECUTED 2008a6c: c2 00 e0 90 ld [ %g3 + 0x90 ], %g1 ! 202b490 <== NOT EXECUTED 2008a70: 82 00 60 01 inc %g1 <== NOT EXECUTED 2008a74: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2008a78: 02 80 00 0a be 2008aa0 <== NOT EXECUTED 2008a7c: c2 20 e0 90 st %g1, [ %g3 + 0x90 ] <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 2008a80: 03 00 80 ad sethi %hi(0x202b400), %g1 <== NOT EXECUTED 2008a84: c4 00 62 60 ld [ %g1 + 0x260 ], %g2 ! 202b660 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2008a88: 84 00 a0 01 inc %g2 <== NOT EXECUTED 2008a8c: c4 20 62 60 st %g2, [ %g1 + 0x260 ] <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 2008a90: c2 00 e0 90 ld [ %g3 + 0x90 ], %g1 <== NOT EXECUTED 2008a94: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 2008a98: 14 80 00 3c bg 2008b88 <== NOT EXECUTED 2008a9c: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 2008aa0: 25 00 80 a9 sethi %hi(0x202a400), %l2 <== NOT EXECUTED 2008aa4: c2 04 a1 50 ld [ %l2 + 0x150 ], %g1 ! 202a550 <_impure_ptr> <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 2008aa8: a2 10 20 00 clr %l1 <== NOT EXECUTED /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 2008aac: 40 00 47 1a call 201a714 <== NOT EXECUTED 2008ab0: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 2008ab4: 03 1c 00 00 sethi %hi(0x70000000), %g1 <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 2008ab8: 05 10 00 00 sethi %hi(0x40000000), %g2 <== NOT EXECUTED 2008abc: 80 8c c0 02 btst %l3, %g2 <== NOT EXECUTED 2008ac0: 12 80 00 3f bne 2008bbc <== NOT EXECUTED 2008ac4: a0 2c c0 01 andn %l3, %g1, %l0 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 2008ac8: c2 04 a1 50 ld [ %l2 + 0x150 ], %g1 <== NOT EXECUTED 2008acc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 2008ad0: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2008ad4: 40 00 5f c7 call 20209f0 <== NOT EXECUTED 2008ad8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED if (status) 2008adc: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 2008ae0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED if (status) 2008ae4: 12 80 00 2b bne 2008b90 <== NOT EXECUTED 2008ae8: 35 00 80 a9 sethi %hi(0x202a400), %i2 <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) 2008aec: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 2008af0: 02 80 00 12 be 2008b38 <== NOT EXECUTED 2008af4: c2 04 a1 50 ld [ %l2 + 0x150 ], %g1 <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 2008af8: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED 2008afc: 04 80 00 09 ble 2008b20 <== NOT EXECUTED 2008b00: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008b04: 40 00 54 d8 call 201de64 <== NOT EXECUTED 2008b08: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008b0c: c2 4a 00 00 ldsb [ %o0 ], %g1 <== NOT EXECUTED 2008b10: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2008b14: 12 80 00 2e bne 2008bcc <== NOT EXECUTED 2008b18: c2 04 a1 50 ld [ %l2 + 0x150 ], %g1 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 2008b1c: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008b20: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2008b24: 92 12 62 68 or %o1, 0x268, %o1 <== NOT EXECUTED 2008b28: 40 00 48 bc call 201ae18 <== NOT EXECUTED 2008b2c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 2008b30: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 2008b34: c2 04 a1 50 ld [ %l2 + 0x150 ], %g1 <== NOT EXECUTED 2008b38: 13 00 80 9b sethi %hi(0x2026c00), %o1 <== NOT EXECUTED 2008b3c: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2008b40: 40 00 48 b6 call 201ae18 <== NOT EXECUTED 2008b44: 92 12 60 e0 or %o1, 0xe0, %o1 <== NOT EXECUTED (void) fflush(stderr); 2008b48: c2 04 a1 50 ld [ %l2 + 0x150 ], %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"); 2008b4c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED (void) fflush(stderr); 2008b50: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED 2008b54: 40 00 46 f0 call 201a714 <== NOT EXECUTED 2008b58: b0 04 00 18 add %l0, %i0, %i0 <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 2008b5c: 03 0c 00 00 sethi %hi(0x30000000), %g1 <== NOT EXECUTED 2008b60: 80 8c c0 01 btst %l3, %g1 <== NOT EXECUTED 2008b64: 02 80 00 09 be 2008b88 <== NOT EXECUTED 2008b68: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 2008b6c: 02 80 00 23 be 2008bf8 <== NOT EXECUTED 2008b70: 90 10 20 00 clr %o0 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 2008b74: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008b78: 40 00 00 33 call 2008c44 <== NOT EXECUTED 2008b7c: 92 12 62 80 or %o1, 0x280, %o1 ! 2026680 <== NOT EXECUTED _exit(local_errno); 2008b80: 40 00 02 8e call 20095b8 <_exit> <== NOT EXECUTED 2008b84: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED rtems_error(0, "fatal error, aborting"); abort(); } } return chars_written; } 2008b88: 81 c7 e0 08 ret <== NOT EXECUTED 2008b8c: 81 e8 00 00 restore <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 2008b90: c2 06 a1 50 ld [ %i2 + 0x150 ], %g1 <== NOT EXECUTED 2008b94: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2008b98: 7f ff ff a8 call 2008a38 <== NOT EXECUTED 2008b9c: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED 2008ba0: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008ba4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2008ba8: 92 12 62 48 or %o1, 0x248, %o1 <== NOT EXECUTED 2008bac: 40 00 48 9b call 201ae18 <== NOT EXECUTED 2008bb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2008bb4: 10 bf ff ce b 2008aec <== NOT EXECUTED 2008bb8: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED (void) fflush(stdout); /* in case stdout/stderr same */ status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ local_errno = errno; 2008bbc: 40 00 46 79 call 201a5a0 <__errno> <== NOT EXECUTED 2008bc0: 01 00 00 00 nop <== NOT EXECUTED 2008bc4: 10 bf ff c1 b 2008ac8 <== NOT EXECUTED 2008bc8: e2 02 00 00 ld [ %o0 ], %l1 <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { if ((local_errno > 0) && *strerror(local_errno)) chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 2008bcc: c2 06 a1 50 ld [ %i2 + 0x150 ], %g1 <== NOT EXECUTED 2008bd0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED 2008bd4: 40 00 54 a4 call 201de64 <== NOT EXECUTED 2008bd8: e0 00 60 0c ld [ %g1 + 0xc ], %l0 <== NOT EXECUTED 2008bdc: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008be0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 2008be4: 92 12 62 58 or %o1, 0x258, %o1 <== NOT EXECUTED 2008be8: 40 00 48 8c call 201ae18 <== NOT EXECUTED 2008bec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2008bf0: 10 bf ff d1 b 2008b34 <== NOT EXECUTED 2008bf4: b0 06 00 08 add %i0, %o0, %i0 <== NOT EXECUTED rtems_error(0, "fatal error, exiting"); _exit(local_errno); } else { rtems_error(0, "fatal error, aborting"); 2008bf8: 13 00 80 99 sethi %hi(0x2026400), %o1 <== NOT EXECUTED 2008bfc: 40 00 00 12 call 2008c44 <== NOT EXECUTED 2008c00: 92 12 62 98 or %o1, 0x298, %o1 ! 2026698 <== NOT EXECUTED abort(); 2008c04: 40 00 46 59 call 201a568 <== NOT EXECUTED 2008c08: 01 00 00 00 nop 2008c0c: 01 00 00 00 nop 02017e6c : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 2017e6c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED 2017e70: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 <== NOT EXECUTED 2017e74: a2 10 20 00 clr %l1 <== NOT EXECUTED 2017e78: a6 10 63 ff or %g1, 0x3ff, %l3 <== NOT EXECUTED 2017e7c: a4 10 20 00 clr %l2 <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 2017e80: 2b 00 80 f0 sethi %hi(0x203c000), %l5 <== NOT EXECUTED limit++; continue; } sign = 1; } if (!isdigit(c)) 2017e84: 29 00 80 f0 sethi %hi(0x203c000), %l4 <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 2017e88: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2017e8c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2017e90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017e94: 06 80 00 23 bl 2017f20 <== NOT EXECUTED 2017e98: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED 2017e9c: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 2017ea0: e0 08 40 00 ldub [ %g1 ], %l0 <== NOT EXECUTED 2017ea4: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED if (c == ':') 2017ea8: 80 a4 20 3a cmp %l0, 0x3a <== NOT EXECUTED 2017eac: 02 80 00 24 be 2017f3c <== NOT EXECUTED 2017eb0: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED break; if (sign == 0) { 2017eb4: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 2017eb8: 12 80 00 06 bne 2017ed0 <== NOT EXECUTED 2017ebc: c2 05 22 a8 ld [ %l4 + 0x2a8 ], %g1 <== NOT EXECUTED if (c == '-') { 2017ec0: 80 a4 20 2d cmp %l0, 0x2d <== NOT EXECUTED 2017ec4: 02 80 00 2f be 2017f80 <== NOT EXECUTED 2017ec8: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED limit++; continue; } sign = 1; } if (!isdigit(c)) 2017ecc: c2 05 22 a8 ld [ %l4 + 0x2a8 ], %g1 <== NOT EXECUTED 2017ed0: c4 08 40 10 ldub [ %g1 + %l0 ], %g2 <== NOT EXECUTED 2017ed4: 80 88 a0 04 btst 4, %g2 <== NOT EXECUTED 2017ed8: 02 80 00 28 be 2017f78 <== NOT EXECUTED 2017edc: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 2017ee0: 40 00 72 ca call 2034a08 <.udiv> <== NOT EXECUTED 2017ee4: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 2017ee8: 80 a4 40 08 cmp %l1, %o0 <== NOT EXECUTED 2017eec: 18 80 00 23 bgu 2017f78 <== NOT EXECUTED 2017ef0: 01 00 00 00 nop <== NOT EXECUTED 2017ef4: 02 80 00 1b be 2017f60 <== NOT EXECUTED 2017ef8: a0 04 3f d0 add %l0, -48, %l0 <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 2017efc: 85 2c 60 03 sll %l1, 3, %g2 <== NOT EXECUTED 2017f00: 83 2c 60 01 sll %l1, 1, %g1 <== NOT EXECUTED 2017f04: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 2017f08: a2 04 00 01 add %l0, %g1, %l1 <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 2017f0c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2017f10: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2017f14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2017f18: 16 bf ff e1 bge 2017e9c <== NOT EXECUTED 2017f1c: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED 2017f20: d0 05 62 b0 ld [ %l5 + 0x2b0 ], %o0 <== NOT EXECUTED 2017f24: 40 00 43 89 call 2028d48 <__srget_r> <== NOT EXECUTED 2017f28: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 2017f2c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED if (c == ':') 2017f30: 80 a4 20 3a cmp %l0, 0x3a <== NOT EXECUTED 2017f34: 12 bf ff e1 bne 2017eb8 <== NOT EXECUTED 2017f38: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 2017f3c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 2017f40: 02 80 00 0e be 2017f78 <== NOT EXECUTED 2017f44: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED return 0; *val = i * sign; 2017f48: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2017f4c: 40 00 72 75 call 2034920 <.umul> <== NOT EXECUTED 2017f50: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED 2017f54: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED 2017f58: 81 c7 e0 08 ret <== NOT EXECUTED 2017f5c: 81 e8 00 00 restore <== NOT EXECUTED sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 2017f60: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 2017f64: 40 00 73 55 call 2034cb8 <.urem> <== NOT EXECUTED 2017f68: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED 2017f6c: 80 a4 00 08 cmp %l0, %o0 <== NOT EXECUTED 2017f70: 08 bf ff e4 bleu 2017f00 <== NOT EXECUTED 2017f74: 85 2c 60 03 sll %l1, 3, %g2 <== NOT EXECUTED } if (sign == 0) return 0; *val = i * sign; return 1; } 2017f78: 81 c7 e0 08 ret <== NOT EXECUTED 2017f7c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 2017f80: a6 04 e0 01 inc %l3 <== NOT EXECUTED 2017f84: 10 bf ff c1 b 2017e88 <== NOT EXECUTED 2017f88: a4 10 3f ff mov -1, %l2 <== NOT EXECUTED 02017f8c : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 2017f8c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED int c; *name = *bufp; 2017f90: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2017f94: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED for (;;) { c = getc(fp); 2017f98: 10 80 00 19 b 2017ffc <== NOT EXECUTED 2017f9c: 33 00 80 f0 sethi %hi(0x203c000), %i1 <== NOT EXECUTED 2017fa0: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED 2017fa4: d0 08 40 00 ldub [ %g1 ], %o0 <== NOT EXECUTED 2017fa8: 84 00 60 01 add %g1, 1, %g2 <== NOT EXECUTED if (c == ':') { 2017fac: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED 2017fb0: 02 80 00 1e be 2018028 <== NOT EXECUTED 2017fb4: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { 2017fb8: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED 2017fbc: 02 80 00 28 be 201805c <== NOT EXECUTED 2017fc0: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED if (!nlFlag) return 0; break; } if (c == EOF) 2017fc4: 02 80 00 29 be 2018068 <== NOT EXECUTED 2017fc8: 01 00 00 00 nop <== NOT EXECUTED return 0; if (*nleft < 2) 2017fcc: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED 2017fd0: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED 2017fd4: 08 80 00 25 bleu 2018068 <== NOT EXECUTED 2017fd8: 01 00 00 00 nop <== NOT EXECUTED return 0; **bufp = c; 2017fdc: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2017fe0: d0 28 40 00 stb %o0, [ %g1 ] <== NOT EXECUTED ++(*bufp); 2017fe4: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED --(*nleft); 2017fe8: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED if (c == EOF) return 0; if (*nleft < 2) return 0; **bufp = c; ++(*bufp); 2017fec: 84 00 a0 01 inc %g2 <== NOT EXECUTED --(*nleft); 2017ff0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED if (c == EOF) return 0; if (*nleft < 2) return 0; **bufp = c; ++(*bufp); 2017ff4: c4 26 80 00 st %g2, [ %i2 ] <== NOT EXECUTED --(*nleft); 2017ff8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED { int c; *name = *bufp; for (;;) { c = getc(fp); 2017ffc: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED 2018000: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 2018004: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018008: 16 bf ff e6 bge 2017fa0 <== NOT EXECUTED 201800c: c2 26 20 04 st %g1, [ %i0 + 4 ] <== NOT EXECUTED 2018010: d0 06 62 b0 ld [ %i1 + 0x2b0 ], %o0 <== NOT EXECUTED 2018014: 40 00 43 4d call 2028d48 <__srget_r> <== NOT EXECUTED 2018018: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED if (c == ':') { 201801c: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED 2018020: 12 bf ff e7 bne 2017fbc <== NOT EXECUTED 2018024: 80 a2 20 0a cmp %o0, 0xa <== NOT EXECUTED if (nlFlag) 2018028: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 201802c: 12 80 00 0f bne 2018068 <== NOT EXECUTED 2018030: 01 00 00 00 nop <== NOT EXECUTED return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 2018034: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 2018038: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED ++(*bufp); 201803c: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED --(*nleft); 2018040: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; ++(*bufp); 2018044: 84 00 a0 01 inc %g2 <== NOT EXECUTED --(*nleft); 2018048: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; ++(*bufp); 201804c: c4 26 80 00 st %g2, [ %i2 ] <== NOT EXECUTED --(*nleft); 2018050: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 2018054: 81 c7 e0 08 ret <== NOT EXECUTED 2018058: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 201805c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED 2018060: 32 bf ff f6 bne,a 2018038 <== NOT EXECUTED 2018064: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; } 2018068: 81 c7 e0 08 ret <== NOT EXECUTED 201806c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 020055ec : scandir(dirname, namelist, select, dcomp) const char *dirname; struct dirent ***namelist; int (*select)(struct dirent *); int (*dcomp)(const struct dirent **, const struct dirent **); { 20055ec: 9d e3 bf 48 save %sp, -184, %sp struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 20055f0: 7f ff fd 7c call 2004be0 20055f4: 90 10 00 18 mov %i0, %o0 20055f8: a4 92 20 00 orcc %o0, 0, %l2 20055fc: 02 80 00 61 be 2005780 2005600: 92 10 3f ff mov -1, %o1 return(-1); if (fstat(dirp->dd_fd, &stb) < 0) 2005604: d0 04 80 00 ld [ %l2 ], %o0 2005608: aa 07 bf a8 add %fp, -88, %l5 200560c: 40 00 24 47 call 200e728 2005610: 92 10 00 15 mov %l5, %o1 2005614: 80 a2 20 00 cmp %o0, 0 2005618: 06 80 00 6b bl 20057c4 200561c: 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); 2005620: 40 00 43 b3 call 20164ec <.div> 2005624: 92 10 20 18 mov 0x18, %o1 names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; 2005628: 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); 200562c: a8 10 00 08 mov %o0, %l4 names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 2005630: 7f ff fa a2 call 20040b8 2005634: 91 2a 20 02 sll %o0, 2, %o0 if (names == NULL) 2005638: a6 92 20 00 orcc %o0, 0, %l3 200563c: 22 80 00 4c be,a 200576c 2005640: b0 10 20 00 clr %i0 goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { 2005644: 7f ff ff 4e call 200537c 2005648: 90 10 00 12 mov %l2, %o0 200564c: a0 92 20 00 orcc %o0, 0, %l0 2005650: 02 80 00 29 be 20056f4 2005654: 80 a6 a0 00 cmp %i2, 0 if (select != NULL && !(*select)(d)) 2005658: 22 80 00 08 be,a 2005678 200565c: d0 14 20 0a lduh [ %l0 + 0xa ], %o0 <== NOT EXECUTED 2005660: 9f c6 80 00 call %i2 2005664: 01 00 00 00 nop 2005668: 80 a2 20 00 cmp %o0, 0 200566c: 02 bf ff f6 be 2005644 2005670: 01 00 00 00 nop continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 2005674: d0 14 20 0a lduh [ %l0 + 0xa ], %o0 2005678: 90 02 20 04 add %o0, 4, %o0 200567c: 90 0a 3f fc and %o0, -4, %o0 2005680: 7f ff fa 8e call 20040b8 2005684: 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); 2005688: 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)); 200568c: a2 10 00 08 mov %o0, %l1 if (p == NULL) 2005690: 80 a4 60 00 cmp %l1, 0 2005694: 02 80 00 36 be 200576c 2005698: 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; 200569c: 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; 20056a0: c2 04 00 00 ld [ %l0 ], %g1 p->d_reclen = d->d_reclen; 20056a4: 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); 20056a8: 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; 20056ac: c2 24 40 00 st %g1, [ %l1 ] p->d_reclen = d->d_reclen; 20056b0: c4 34 60 08 sth %g2, [ %l1 + 8 ] p->d_namlen = d->d_namlen; 20056b4: c6 34 60 0a sth %g3, [ %l1 + 0xa ] strncpy(p->d_name, d->d_name, p->d_namlen + 1); 20056b8: 95 32 a0 10 srl %o2, 0x10, %o2 20056bc: 40 00 39 ed call 2013e70 20056c0: 94 02 a0 01 inc %o2 /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { 20056c4: b0 06 20 01 inc %i0 20056c8: 80 a6 00 14 cmp %i0, %l4 20056cc: 3a 80 00 1a bcc,a 2005734 20056d0: d0 04 80 00 ld [ %l2 ], %o0 <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; 20056d4: 83 2e 20 02 sll %i0, 2, %g1 20056d8: 82 00 40 13 add %g1, %l3, %g1 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) { 20056dc: 90 10 00 12 mov %l2, %o0 20056e0: 7f ff ff 27 call 200537c 20056e4: e2 20 7f fc st %l1, [ %g1 + -4 ] 20056e8: a0 92 20 00 orcc %o0, 0, %l0 20056ec: 12 bf ff db bne 2005658 20056f0: 80 a6 a0 00 cmp %i2, 0 if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; } closedir(dirp); 20056f4: 7f ff f7 77 call 20034d0 20056f8: 90 10 00 12 mov %l2, %o0 if (nitems && dcomp != NULL){ 20056fc: 80 a6 20 00 cmp %i0, 0 2005700: 02 80 00 0a be 2005728 2005704: 92 10 00 18 mov %i0, %o1 2005708: 80 a6 e0 00 cmp %i3, 0 200570c: 02 80 00 07 be 2005728 2005710: 96 10 00 1b mov %i3, %o3 qsort(names, nitems, sizeof(struct dirent *), dcomp); 2005714: 90 10 00 13 mov %l3, %o0 2005718: 92 10 00 18 mov %i0, %o1 200571c: 40 00 36 a6 call 20131b4 2005720: 94 10 20 04 mov 4, %o2 } *namelist = names; return(nitems); 2005724: 92 10 00 18 mov %i0, %o1 } closedir(dirp); if (nitems && dcomp != NULL){ qsort(names, nitems, sizeof(struct dirent *), dcomp); } *namelist = names; 2005728: e6 26 40 00 st %l3, [ %i1 ] free( names[i] ); free( names ); } return(-1); } 200572c: 81 c7 e0 08 ret 2005730: 91 e8 00 09 restore %g0, %o1, %o0 /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { if (fstat(dirp->dd_fd, &stb) < 0) 2005734: 40 00 23 fd call 200e728 <== NOT EXECUTED 2005738: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED 200573c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2005740: 06 80 00 0b bl 200576c <== NOT EXECUTED 2005744: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED goto cleanup_and_bail; /* just might have grown */ arraysz = stb.st_size / 12; 2005748: 40 00 43 69 call 20164ec <.div> <== NOT EXECUTED 200574c: d0 07 bf c8 ld [ %fp + -56 ], %o0 <== NOT EXECUTED 2005750: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, 2005754: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 2005758: 7f ff fa a9 call 20041fc <== NOT EXECUTED 200575c: 93 2d 20 02 sll %l4, 2, %o1 <== NOT EXECUTED arraysz * sizeof(struct dirent *)); if (names == NULL) 2005760: a6 92 20 00 orcc %o0, 0, %l3 <== NOT EXECUTED 2005764: 12 bf ff dd bne 20056d8 <== NOT EXECUTED 2005768: 83 2e 20 02 sll %i0, 2, %g1 <== NOT EXECUTED return(nitems); cleanup_and_bail: if ( dirp ) closedir( dirp ); 200576c: 7f ff f7 59 call 20034d0 2005770: 90 10 00 12 mov %l2, %o0 if ( names ) { 2005774: 80 a4 e0 00 cmp %l3, 0 2005778: 12 80 00 04 bne 2005788 200577c: 92 10 3f ff mov -1, %o1 free( names[i] ); free( names ); } return(-1); } 2005780: 81 c7 e0 08 ret 2005784: 91 e8 00 09 restore %g0, %o1, %o0 if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 2005788: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 200578c: 02 80 00 0a be 20057b4 <== NOT EXECUTED 2005790: 82 10 20 00 clr %g1 <== NOT EXECUTED 2005794: a0 10 20 00 clr %l0 <== NOT EXECUTED free( names[i] ); 2005798: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200579c: d0 04 c0 01 ld [ %l3 + %g1 ], %o0 <== NOT EXECUTED 20057a0: 7f ff fa 1d call 2004014 <== NOT EXECUTED 20057a4: a0 04 20 01 inc %l0 <== NOT EXECUTED if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 20057a8: 80 a4 00 18 cmp %l0, %i0 <== NOT EXECUTED 20057ac: 12 bf ff fb bne 2005798 <== NOT EXECUTED 20057b0: 82 10 00 10 mov %l0, %g1 <== NOT EXECUTED free( names[i] ); free( names ); 20057b4: 7f ff fa 18 call 2004014 <== NOT EXECUTED 20057b8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 20057bc: 10 bf ff f1 b 2005780 <== NOT EXECUTED 20057c0: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED return(nitems); cleanup_and_bail: if ( dirp ) closedir( dirp ); 20057c4: 7f ff f7 43 call 20034d0 <== NOT EXECUTED 20057c8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 20057cc: 10 bf ff ed b 2005780 <== NOT EXECUTED 20057d0: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED 02018070 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 2018070: 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) 2018074: 98 10 20 00 clr %o4 <== NOT EXECUTED FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 2018078: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 201807c: 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) 2018080: b4 07 a0 50 add %fp, 0x50, %i2 <== NOT EXECUTED 2018084: b6 07 a0 4c add %fp, 0x4c, %i3 <== NOT EXECUTED 2018088: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 201808c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2018090: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018094: 7f ff ff be call 2017f8c <== NOT EXECUTED 2018098: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 201809c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20180a0: 12 80 00 04 bne 20180b0 <== NOT EXECUTED 20180a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; } 20180a8: 81 c7 e0 08 ret <== NOT EXECUTED 20180ac: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 20180b0: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED 20180b4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 20180b8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 20180bc: 7f ff ff b4 call 2017f8c <== NOT EXECUTED 20180c0: 98 10 20 00 clr %o4 <== NOT EXECUTED 20180c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20180c8: 02 bf ff f8 be 20180a8 <== NOT EXECUTED 20180cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20180d0: 7f ff ff 67 call 2017e6c <== NOT EXECUTED 20180d4: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 20180d8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20180dc: 02 bf ff f3 be 20180a8 <== NOT EXECUTED 20180e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20180e4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 20180e8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 20180ec: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED 20180f0: 7f ff ff a7 call 2017f8c <== NOT EXECUTED 20180f4: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED 20180f8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20180fc: 02 bf ff eb be 20180a8 <== NOT EXECUTED 2018100: da 07 bf f0 ld [ %fp + -16 ], %o5 <== NOT EXECUTED || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; grp->gr_gid = grgid; 2018104: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2018108: 86 10 00 0d mov %o5, %g3 <== 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; 201810c: c2 36 60 08 sth %g1, [ %i1 + 8 ] <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2018110: c4 0b 40 00 ldub [ %o5 ], %g2 <== NOT EXECUTED 2018114: 83 28 a0 18 sll %g2, 0x18, %g1 <== NOT EXECUTED 2018118: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 201811c: 02 80 00 0f be 2018158 <== NOT EXECUTED 2018120: 88 10 20 17 mov 0x17, %g4 <== NOT EXECUTED 2018124: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 2018128: 86 00 e0 01 inc %g3 <== NOT EXECUTED 201812c: c4 08 c0 00 ldub [ %g3 ], %g2 <== NOT EXECUTED if(*cp == ',') 2018130: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED memcount++; 2018134: 82 18 60 2c xor %g1, 0x2c, %g1 <== NOT EXECUTED 2018138: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 201813c: 83 28 a0 18 sll %g2, 0x18, %g1 <== NOT EXECUTED if(*cp == ',') memcount++; 2018140: 88 61 3f ff subx %g4, -1, %g4 <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2018144: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018148: 32 bf ff f9 bne,a 201812c <== NOT EXECUTED 201814c: 86 00 e0 01 inc %g3 <== NOT EXECUTED 2018150: 83 29 20 02 sll %g4, 2, %g1 <== NOT EXECUTED 2018154: 88 00 60 13 add %g1, 0x13, %g4 <== NOT EXECUTED } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 2018158: c2 07 a0 50 ld [ %fp + 0x50 ], %g1 <== NOT EXECUTED 201815c: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED 2018160: 0a bf ff d2 bcs 20180a8 <== NOT EXECUTED 2018164: c2 07 a0 4c ld [ %fp + 0x4c ], %g1 <== NOT EXECUTED return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 2018168: 82 00 60 0f add %g1, 0xf, %g1 <== NOT EXECUTED 201816c: 82 08 7f f0 and %g1, -16, %g1 <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 2018170: da 20 40 00 st %o5, [ %g1 ] <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 2018174: 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); 2018178: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 201817c: c2 08 80 00 ldub [ %g2 ], %g1 <== NOT EXECUTED 2018180: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED 2018184: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2018188: 02 80 00 15 be 20181dc <== NOT EXECUTED 201818c: 86 10 20 04 mov 4, %g3 <== NOT EXECUTED 2018190: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED 2018194: 10 80 00 07 b 20181b0 <== NOT EXECUTED 2018198: 88 10 20 01 mov 1, %g4 <== NOT EXECUTED 201819c: c2 08 c0 00 ldub [ %g3 ], %g1 <== NOT EXECUTED 20181a0: 83 28 60 18 sll %g1, 0x18, %g1 <== NOT EXECUTED 20181a4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20181a8: 02 80 00 0c be 20181d8 <== NOT EXECUTED 20181ac: 86 00 e0 01 inc %g3 <== NOT EXECUTED if(*cp == ',') { 20181b0: 83 38 60 18 sra %g1, 0x18, %g1 <== NOT EXECUTED 20181b4: 80 a0 60 2c cmp %g1, 0x2c <== NOT EXECUTED 20181b8: 32 bf ff fa bne,a 20181a0 <== NOT EXECUTED 20181bc: c2 08 c0 00 ldub [ %g3 ], %g1 <== NOT EXECUTED *cp = '\0'; 20181c0: c0 28 ff ff clrb [ %g3 + -1 ] <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 20181c4: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED 20181c8: 83 29 20 02 sll %g4, 2, %g1 <== NOT EXECUTED 20181cc: 88 01 20 01 inc %g4 <== NOT EXECUTED 20181d0: 10 bf ff f3 b 201819c <== NOT EXECUTED 20181d4: c6 20 80 01 st %g3, [ %g2 + %g1 ] <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 20181d8: 87 29 20 02 sll %g4, 2, %g3 <== NOT EXECUTED if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 20181dc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED 20181e0: c0 20 40 03 clr [ %g1 + %g3 ] <== NOT EXECUTED 20181e4: 81 c7 e0 08 ret <== NOT EXECUTED 20181e8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 02018238 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 2018238: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 201823c: 98 10 20 00 clr %o4 <== NOT EXECUTED FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 2018240: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED 2018244: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 2018248: b4 07 a0 50 add %fp, 0x50, %i2 <== NOT EXECUTED 201824c: b6 07 a0 4c add %fp, 0x4c, %i3 <== NOT EXECUTED 2018250: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018254: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 2018258: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 201825c: 7f ff ff 4c call 2017f8c <== NOT EXECUTED 2018260: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2018264: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018268: 12 80 00 04 bne 2018278 <== NOT EXECUTED 201826c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) return 0; pwd->pw_uid = pwuid; pwd->pw_gid = pwgid; return 1; } 2018270: 81 c7 e0 08 ret <== NOT EXECUTED 2018274: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 2018278: 92 06 60 04 add %i1, 4, %o1 <== NOT EXECUTED 201827c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018280: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2018284: 7f ff ff 42 call 2017f8c <== NOT EXECUTED 2018288: 98 10 20 00 clr %o4 <== NOT EXECUTED 201828c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018290: 02 bf ff f8 be 2018270 <== NOT EXECUTED 2018294: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018298: 7f ff fe f5 call 2017e6c <== NOT EXECUTED 201829c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED 20182a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20182a4: 02 bf ff f3 be 2018270 <== NOT EXECUTED 20182a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20182ac: 7f ff fe f0 call 2017e6c <== NOT EXECUTED 20182b0: 92 07 bf f0 add %fp, -16, %o1 <== NOT EXECUTED 20182b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20182b8: 02 bf ff ee be 2018270 <== NOT EXECUTED 20182bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20182c0: 92 06 60 0c add %i1, 0xc, %o1 <== NOT EXECUTED 20182c4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 20182c8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 20182cc: 7f ff ff 30 call 2017f8c <== NOT EXECUTED 20182d0: 98 10 20 00 clr %o4 <== NOT EXECUTED 20182d4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20182d8: 02 bf ff e6 be 2018270 <== NOT EXECUTED 20182dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 20182e0: 92 06 60 10 add %i1, 0x10, %o1 <== NOT EXECUTED 20182e4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 20182e8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 20182ec: 7f ff ff 28 call 2017f8c <== NOT EXECUTED 20182f0: 98 10 20 00 clr %o4 <== NOT EXECUTED 20182f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20182f8: 02 bf ff de be 2018270 <== NOT EXECUTED 20182fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018300: 92 06 60 14 add %i1, 0x14, %o1 <== NOT EXECUTED 2018304: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018308: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 201830c: 7f ff ff 20 call 2017f8c <== NOT EXECUTED 2018310: 98 10 20 00 clr %o4 <== NOT EXECUTED 2018314: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018318: 02 bf ff d6 be 2018270 <== NOT EXECUTED 201831c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018320: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 2018324: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 2018328: 92 06 60 18 add %i1, 0x18, %o1 <== NOT EXECUTED 201832c: 7f ff ff 18 call 2017f8c <== NOT EXECUTED 2018330: 98 10 20 01 mov 1, %o4 <== NOT EXECUTED 2018334: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018338: 02 bf ff ce be 2018270 <== NOT EXECUTED 201833c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED || !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; pwd->pw_gid = pwgid; 2018340: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== 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; 2018344: c2 36 60 08 sth %g1, [ %i1 + 8 ] <== NOT EXECUTED pwd->pw_gid = pwgid; 2018348: c4 36 60 0a sth %g2, [ %i1 + 0xa ] <== NOT EXECUTED 201834c: 81 c7 e0 08 ret <== NOT EXECUTED 2018350: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED 02006fcc : */ int sched_get_priority_max( int policy ) { 2006fcc: 9d e3 bf 98 save %sp, -104, %sp switch ( policy ) { 2006fd0: 80 a6 20 03 cmp %i0, 3 2006fd4: 08 80 00 06 bleu 2006fec 2006fd8: b0 10 20 fe mov 0xfe, %i0 case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 2006fdc: 40 00 27 2d call 2010c90 <__errno> <== NOT EXECUTED 2006fe0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2006fe4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 2006fe8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 2006fec: 81 c7 e0 08 ret 2006ff0: 81 e8 00 00 restore 0200702c : int sched_getparam( pid_t pid, const struct sched_param *param ) { 200702c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2007030: 40 00 27 18 call 2010c90 <__errno> <== NOT EXECUTED 2007034: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007038: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 200703c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2007040: 81 c7 e0 08 ret <== NOT EXECUTED 2007044: 81 e8 00 00 restore <== NOT EXECUTED 02006ff4 : */ int sched_getscheduler( pid_t pid ) { 2006ff4: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2006ff8: 40 00 27 26 call 2010c90 <__errno> <== NOT EXECUTED 2006ffc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007000: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2007004: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2007008: 81 c7 e0 08 ret <== NOT EXECUTED 200700c: 81 e8 00 00 restore <== NOT EXECUTED 02007064 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 2007064: 9d e3 bf 98 save %sp, -104, %sp /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 2007068: 80 a6 20 00 cmp %i0, 0 200706c: 12 80 00 0a bne 2007094 2007070: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 2007074: 02 80 00 13 be 20070c0 2007078: 03 00 80 75 sethi %hi(0x201d400), %g1 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 200707c: d0 00 62 98 ld [ %g1 + 0x298 ], %o0 ! 201d698 <_Thread_Ticks_per_timeslice> 2007080: 92 10 00 19 mov %i1, %o1 2007084: 40 00 14 fa call 200c46c <_Timespec_From_ticks> 2007088: b0 10 20 00 clr %i0 return 0; } 200708c: 81 c7 e0 08 ret 2007090: 81 e8 00 00 restore { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 2007094: 7f ff f0 2a call 200313c 2007098: 01 00 00 00 nop 200709c: 80 a2 00 18 cmp %o0, %i0 20070a0: 02 bf ff f5 be 2007074 20070a4: 80 a6 60 00 cmp %i1, 0 rtems_set_errno_and_return_minus_one( ESRCH ); 20070a8: 40 00 26 fa call 2010c90 <__errno> <== NOT EXECUTED 20070ac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20070b0: 82 10 20 03 mov 3, %g1 <== NOT EXECUTED 20070b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20070b8: 81 c7 e0 08 ret <== NOT EXECUTED 20070bc: 81 e8 00 00 restore <== NOT EXECUTED if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 20070c0: 40 00 26 f4 call 2010c90 <__errno> <== NOT EXECUTED 20070c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20070c8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 20070cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20070d0: 81 c7 e0 08 ret <== NOT EXECUTED 20070d4: 81 e8 00 00 restore <== NOT EXECUTED 02007048 : int sched_setparam( pid_t pid, const struct sched_param *param ) { 2007048: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 200704c: 40 00 27 11 call 2010c90 <__errno> <== NOT EXECUTED 2007050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007054: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2007058: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 200705c: 81 c7 e0 08 ret <== NOT EXECUTED 2007060: 81 e8 00 00 restore <== NOT EXECUTED 02007010 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 2007010: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 2007014: 40 00 27 1f call 2010c90 <__errno> <== NOT EXECUTED 2007018: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200701c: 82 10 20 58 mov 0x58, %g1 <== NOT EXECUTED 2007020: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED } 2007024: 81 c7 e0 08 ret <== NOT EXECUTED 2007028: 81 e8 00 00 restore <== NOT EXECUTED 02006eec : */ int sem_close( sem_t *sem ) { 2006eec: 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 *) 2006ef0: d2 06 00 00 ld [ %i0 ], %o1 2006ef4: 11 00 80 7d sethi %hi(0x201f400), %o0 2006ef8: 94 07 bf f4 add %fp, -12, %o2 2006efc: 40 00 0c 43 call 200a008 <_Objects_Get> 2006f00: 90 12 20 10 or %o0, 0x10, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006f04: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006f08: 80 a0 60 01 cmp %g1, 1 2006f0c: 02 80 00 1c be 2006f7c 2006f10: 01 00 00 00 nop 2006f14: 2a 80 00 09 bcs,a 2006f38 2006f18: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 2006f1c: 80 a0 60 02 cmp %g1, 2 2006f20: 02 80 00 1d be 2006f94 2006f24: 01 00 00 00 nop the_semaphore->open_count -= 1; _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006f28: 40 00 01 aa call 20075d0 <== NOT EXECUTED 2006f2c: 01 00 00 00 nop <== NOT EXECUTED } 2006f30: 81 c7 e0 08 ret <== NOT EXECUTED 2006f34: 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; 2006f38: 82 00 7f ff add %g1, -1, %g1 _POSIX_Semaphore_Delete( the_semaphore ); 2006f3c: 40 00 22 31 call 200f800 <_POSIX_Semaphore_Delete> 2006f40: 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 ) 2006f44: 07 00 80 7c sethi %hi(0x201f000), %g3 2006f48: c2 00 e0 90 ld [ %g3 + 0x90 ], %g1 ! 201f090 <_Thread_Dispatch_disable_level> 2006f4c: 90 10 20 00 clr %o0 2006f50: 82 00 7f ff add %g1, -1, %g1 2006f54: c2 20 e0 90 st %g1, [ %g3 + 0x90 ] 2006f58: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 2006f5c: 80 a0 a0 00 cmp %g2, 0 2006f60: 12 bf ff f4 bne 2006f30 2006f64: 01 00 00 00 nop _Thread_Dispatch(); 2006f68: 40 00 11 20 call 200b3e8 <_Thread_Dispatch> 2006f6c: 01 00 00 00 nop 2006f70: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006f74: 81 c7 e0 08 ret 2006f78: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2006f7c: 40 00 11 1b call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 2006f80: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2006f84: 40 00 01 9d call 20075f8 <== NOT EXECUTED 2006f88: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006f8c: 81 c7 e0 08 ret <== NOT EXECUTED 2006f90: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2006f94: 40 00 2b 16 call 2011bec <__errno> 2006f98: 01 00 00 00 nop 2006f9c: 82 10 20 16 mov 0x16, %g1 ! 16 2006fa0: c2 22 00 00 st %g1, [ %o0 ] 2006fa4: 90 10 3f ff mov -1, %o0 _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2006fa8: 81 c7 e0 08 ret 2006fac: 91 e8 00 08 restore %g0, %o0, %o0 02006fb0 : */ int sem_destroy( sem_t *sem ) { 2006fb0: 9d e3 bf 90 save %sp, -112, %sp 2006fb4: d2 06 00 00 ld [ %i0 ], %o1 2006fb8: 11 00 80 7d sethi %hi(0x201f400), %o0 2006fbc: 94 07 bf f4 add %fp, -12, %o2 2006fc0: 40 00 0c 12 call 200a008 <_Objects_Get> 2006fc4: 90 12 20 10 or %o0, 0x10, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 2006fc8: c2 07 bf f4 ld [ %fp + -12 ], %g1 2006fcc: 80 a0 60 01 cmp %g1, 1 2006fd0: 02 80 00 2f be 200708c 2006fd4: 01 00 00 00 nop 2006fd8: 2a 80 00 09 bcs,a 2006ffc 2006fdc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 2006fe0: 80 a0 60 02 cmp %g1, 2 2006fe4: 02 80 00 23 be 2007070 2006fe8: 01 00 00 00 nop _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 2006fec: 40 00 01 79 call 20075d0 <== NOT EXECUTED 2006ff0: 01 00 00 00 nop <== NOT EXECUTED } 2006ff4: 81 c7 e0 08 ret <== NOT EXECUTED 2006ff8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 2006ffc: 80 a0 60 01 cmp %g1, 1 2007000: 02 80 00 12 be 2007048 2007004: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 2007008: 40 00 21 fe call 200f800 <_POSIX_Semaphore_Delete> 200700c: 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 ) 2007010: 03 00 80 7c sethi %hi(0x201f000), %g1 2007014: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201f090 <_Thread_Dispatch_disable_level> 2007018: 90 10 20 00 clr %o0 200701c: 84 00 bf ff add %g2, -1, %g2 2007020: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2007024: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2007028: 80 a0 e0 00 cmp %g3, 0 200702c: 12 bf ff f2 bne 2006ff4 2007030: 01 00 00 00 nop _Thread_Dispatch(); 2007034: 40 00 10 ed call 200b3e8 <_Thread_Dispatch> 2007038: 01 00 00 00 nop 200703c: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007040: 81 c7 e0 08 ret 2007044: 91 e8 00 08 restore %g0, %o0, %o0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007048: 03 00 80 7c sethi %hi(0x201f000), %g1 <== NOT EXECUTED 200704c: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201f090 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 2007050: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 2007054: c4 20 60 90 st %g2, [ %g1 + 0x90 ] <== NOT EXECUTED 2007058: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 <== NOT EXECUTED 200705c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 2007060: 12 80 00 04 bne 2007070 <== NOT EXECUTED 2007064: 01 00 00 00 nop <== NOT EXECUTED _Thread_Dispatch(); 2007068: 40 00 10 e0 call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 200706c: 01 00 00 00 nop <== NOT EXECUTED * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 2007070: 40 00 2a df call 2011bec <__errno> 2007074: 01 00 00 00 nop 2007078: 82 10 20 16 mov 0x16, %g1 ! 16 200707c: c2 22 00 00 st %g1, [ %o0 ] 2007080: 90 10 3f ff mov -1, %o0 _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007084: 81 c7 e0 08 ret 2007088: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200708c: 40 00 10 d7 call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 2007090: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2007094: 40 00 01 59 call 20075f8 <== NOT EXECUTED 2007098: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200709c: 81 c7 e0 08 ret <== NOT EXECUTED 20070a0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED 020070a4 : int sem_getvalue( sem_t *sem, int *sval ) { 20070a4: 9d e3 bf 90 save %sp, -112, %sp 20070a8: d2 06 00 00 ld [ %i0 ], %o1 20070ac: 11 00 80 7d sethi %hi(0x201f400), %o0 20070b0: 94 07 bf f4 add %fp, -12, %o2 20070b4: 40 00 0b d5 call 200a008 <_Objects_Get> 20070b8: 90 12 20 10 or %o0, 0x10, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 20070bc: c2 07 bf f4 ld [ %fp + -12 ], %g1 20070c0: 80 a0 60 01 cmp %g1, 1 20070c4: 02 80 00 1a be 200712c 20070c8: 01 00 00 00 nop 20070cc: 2a 80 00 09 bcs,a 20070f0 20070d0: c2 02 20 68 ld [ %o0 + 0x68 ], %g1 20070d4: 80 a0 60 02 cmp %g1, 2 20070d8: 02 80 00 1b be 2007144 20070dc: 01 00 00 00 nop case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20070e0: 40 00 01 3c call 20075d0 <== NOT EXECUTED 20070e4: 01 00 00 00 nop <== NOT EXECUTED } 20070e8: 81 c7 e0 08 ret <== NOT EXECUTED 20070ec: 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 ); 20070f0: 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 ) 20070f4: 07 00 80 7c sethi %hi(0x201f000), %g3 20070f8: c2 00 e0 90 ld [ %g3 + 0x90 ], %g1 ! 201f090 <_Thread_Dispatch_disable_level> 20070fc: 90 10 20 00 clr %o0 2007100: 82 00 7f ff add %g1, -1, %g1 2007104: c2 20 e0 90 st %g1, [ %g3 + 0x90 ] 2007108: c4 00 e0 90 ld [ %g3 + 0x90 ], %g2 200710c: 80 a0 a0 00 cmp %g2, 0 2007110: 12 bf ff f6 bne 20070e8 2007114: 01 00 00 00 nop _Thread_Dispatch(); 2007118: 40 00 10 b4 call 200b3e8 <_Thread_Dispatch> 200711c: 01 00 00 00 nop 2007120: 90 10 20 00 clr %o0 ! 0 _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007124: 81 c7 e0 08 ret 2007128: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 200712c: 40 00 10 af call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 2007130: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 2007134: 40 00 01 31 call 20075f8 <== NOT EXECUTED 2007138: 01 00 00 00 nop <== NOT EXECUTED *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200713c: 81 c7 e0 08 ret <== NOT EXECUTED 2007140: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 2007144: 40 00 2a aa call 2011bec <__errno> 2007148: 01 00 00 00 nop 200714c: 82 10 20 16 mov 0x16, %g1 ! 16 2007150: c2 22 00 00 st %g1, [ %o0 ] 2007154: 90 10 3f ff mov -1, %o0 *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007158: 81 c7 e0 08 ret 200715c: 91 e8 00 08 restore %g0, %o0, %o0 02007160 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 2007160: 9d e3 bf 90 save %sp, -112, %sp 2007164: 92 10 00 19 mov %i1, %o1 int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 2007168: 80 a6 20 00 cmp %i0, 0 200716c: 02 80 00 0c be 200719c 2007170: 94 10 00 1a mov %i2, %o2 rtems_set_errno_and_return_minus_one( EINVAL ); status = _POSIX_Semaphore_Create_support( 2007174: 90 10 20 00 clr %o0 2007178: 40 00 21 31 call 200f63c <_POSIX_Semaphore_Create_support> 200717c: 96 07 bf f4 add %fp, -12, %o3 pshared, value, &the_semaphore ); if ( status != -1 ) 2007180: 80 a2 3f ff cmp %o0, -1 2007184: 02 80 00 04 be 2007194 2007188: c2 07 bf f4 ld [ %fp + -12 ], %g1 *sem = the_semaphore->Object.id; 200718c: c4 00 60 08 ld [ %g1 + 8 ], %g2 2007190: c4 26 00 00 st %g2, [ %i0 ] return status; } 2007194: 81 c7 e0 08 ret 2007198: 91 e8 00 08 restore %g0, %o0, %o0 { int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) rtems_set_errno_and_return_minus_one( EINVAL ); 200719c: 40 00 2a 94 call 2011bec <__errno> <== NOT EXECUTED 20071a0: 01 00 00 00 nop <== NOT EXECUTED 20071a4: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 20071a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20071ac: 10 bf ff fa b 2007194 <== NOT EXECUTED 20071b0: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED 020071b4 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 20071b4: 9d e3 bf 88 save %sp, -120, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20071b8: 21 00 80 7c sethi %hi(0x201f000), %l0 20071bc: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 ! 201f090 <_Thread_Dispatch_disable_level> 20071c0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] 20071c4: 82 00 60 01 inc %g1 20071c8: f6 27 a0 50 st %i3, [ %fp + 0x50 ] 20071cc: f8 27 a0 54 st %i4, [ %fp + 0x54 ] 20071d0: fa 27 a0 58 st %i5, [ %fp + 0x58 ] 20071d4: c2 24 20 90 st %g1, [ %l0 + 0x90 ] POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 20071d8: b8 8e 62 00 andcc %i1, 0x200, %i4 20071dc: 12 80 00 42 bne 20072e4 20071e0: f6 07 a0 50 ld [ %fp + 0x50 ], %i3 20071e4: b6 10 20 00 clr %i3 mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 20071e8: 90 10 00 18 mov %i0, %o0 20071ec: 40 00 21 a2 call 200f874 <_POSIX_Semaphore_Name_to_id> 20071f0: 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 "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 20071f4: ba 92 20 00 orcc %o0, 0, %i5 20071f8: 02 80 00 11 be 200723c 20071fc: 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) ) ) { 2007200: 80 a7 60 02 cmp %i5, 2 2007204: 02 80 00 3b be 20072f0 2007208: 80 a7 20 00 cmp %i4, 0 #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200720c: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 2007210: 82 00 7f ff add %g1, -1, %g1 2007214: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 2007218: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200721c: 80 a0 a0 00 cmp %g2, 0 2007220: 02 80 00 52 be 2007368 2007224: 01 00 00 00 nop _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 2007228: 40 00 2a 71 call 2011bec <__errno> <== NOT EXECUTED 200722c: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 2007230: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED 2007234: 81 c7 e0 08 ret <== NOT EXECUTED 2007238: 81 e8 00 00 restore <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 200723c: 80 a0 6a 00 cmp %g1, 0xa00 2007240: 02 80 00 1c be 20072b0 2007244: d2 07 bf f0 ld [ %fp + -16 ], %o1 2007248: 94 07 bf e8 add %fp, -24, %o2 200724c: 11 00 80 7d sethi %hi(0x201f400), %o0 2007250: 40 00 0b 6e call 200a008 <_Objects_Get> 2007254: 90 12 20 10 or %o0, 0x10, %o0 ! 201f410 <_POSIX_Semaphore_Information> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); the_semaphore->open_count += 1; 2007258: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 200725c: d0 27 bf ec st %o0, [ %fp + -20 ] the_semaphore->open_count += 1; 2007260: 82 00 60 01 inc %g1 2007264: c2 22 20 1c st %g1, [ %o0 + 0x1c ] 2007268: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 200726c: 3b 00 80 7c sethi %hi(0x201f000), %i5 2007270: 82 00 7f ff add %g1, -1, %g1 2007274: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 2007278: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200727c: 80 a0 a0 00 cmp %g2, 0 2007280: 02 80 00 34 be 2007350 2007284: 01 00 00 00 nop 2007288: c2 07 60 90 ld [ %i5 + 0x90 ], %g1 200728c: 82 00 7f ff add %g1, -1, %g1 2007290: c2 27 60 90 st %g1, [ %i5 + 0x90 ] 2007294: c4 07 60 90 ld [ %i5 + 0x90 ], %g2 2007298: 80 a0 a0 00 cmp %g2, 0 200729c: 02 80 00 29 be 2007340 20072a0: 01 00 00 00 nop _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); id = &the_semaphore->Object.id; return (sem_t *)id; 20072a4: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED 20072a8: 81 c7 e0 08 ret 20072ac: 91 e8 60 08 restore %g1, 8, %o0 20072b0: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 20072b4: 82 00 7f ff add %g1, -1, %g1 20072b8: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 20072bc: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 20072c0: 80 a0 a0 00 cmp %g2, 0 20072c4: 02 80 00 26 be 200735c 20072c8: 01 00 00 00 nop * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 20072cc: 40 00 2a 48 call 2011bec <__errno> 20072d0: b0 10 3f ff mov -1, %i0 ! ffffffff 20072d4: 82 10 20 11 mov 0x11, %g1 20072d8: c2 22 00 00 st %g1, [ %o0 ] 20072dc: 81 c7 e0 08 ret 20072e0: 81 e8 00 00 restore _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 20072e4: 82 07 a0 54 add %fp, 0x54, %g1 20072e8: 10 bf ff c0 b 20071e8 20072ec: c2 27 bf f4 st %g1, [ %fp + -12 ] /* * 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) ) ) { 20072f0: 02 bf ff c7 be 200720c 20072f4: 90 10 00 18 mov %i0, %o0 /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 20072f8: 94 10 00 1b mov %i3, %o2 20072fc: 92 10 20 00 clr %o1 2007300: 40 00 20 cf call 200f63c <_POSIX_Semaphore_Create_support> 2007304: 96 07 bf ec add %fp, -20, %o3 2007308: ba 10 00 08 mov %o0, %i5 200730c: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 2007310: 82 00 7f ff add %g1, -1, %g1 2007314: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 2007318: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 200731c: 80 a0 a0 00 cmp %g2, 0 2007320: 02 80 00 19 be 2007384 2007324: 01 00 00 00 nop * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 2007328: 80 a7 7f ff cmp %i5, -1 <== NOT EXECUTED 200732c: 02 bf ff c2 be 2007234 2007330: b0 10 3f ff mov -1, %i0 return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 2007334: c2 07 bf ec ld [ %fp + -20 ], %g1 } 2007338: 81 c7 e0 08 ret 200733c: 91 e8 60 08 restore %g1, 8, %o0 _Thread_Dispatch(); 2007340: 40 00 10 2a call 200b3e8 <_Thread_Dispatch> 2007344: 01 00 00 00 nop the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); the_semaphore->open_count += 1; _Thread_Enable_dispatch(); _Thread_Enable_dispatch(); id = &the_semaphore->Object.id; return (sem_t *)id; 2007348: 10 bf ff d8 b 20072a8 200734c: c2 07 bf ec ld [ %fp + -20 ], %g1 2007350: 40 00 10 26 call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 2007354: 01 00 00 00 nop <== NOT EXECUTED 2007358: 30 bf ff cc b,a 2007288 <== NOT EXECUTED 200735c: 40 00 10 23 call 200b3e8 <_Thread_Dispatch> 2007360: 01 00 00 00 nop 2007364: 30 bf ff da b,a 20072cc 2007368: 40 00 10 20 call 200b3e8 <_Thread_Dispatch> 200736c: b0 10 3f ff mov -1, %i0 * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 2007370: 40 00 2a 1f call 2011bec <__errno> 2007374: 01 00 00 00 nop 2007378: fa 22 00 00 st %i5, [ %o0 ] 200737c: 81 c7 e0 08 ret 2007380: 81 e8 00 00 restore 2007384: 40 00 10 19 call 200b3e8 <_Thread_Dispatch> 2007388: 01 00 00 00 nop * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 200738c: 10 bf ff e8 b 200732c 2007390: 80 a7 7f ff cmp %i5, -1 02007394 : */ int sem_post( sem_t *sem ) { 2007394: 9d e3 bf 90 save %sp, -112, %sp 2007398: d2 06 00 00 ld [ %i0 ], %o1 200739c: 11 00 80 7d sethi %hi(0x201f400), %o0 20073a0: 94 07 bf f4 add %fp, -12, %o2 20073a4: 40 00 0b 19 call 200a008 <_Objects_Get> 20073a8: 90 12 20 10 or %o0, 0x10, %o0 register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 20073ac: c2 07 bf f4 ld [ %fp + -12 ], %g1 20073b0: 80 a0 60 01 cmp %g1, 1 20073b4: 02 80 00 1c be 2007424 20073b8: 01 00 00 00 nop 20073bc: 2a 80 00 09 bcs,a 20073e0 20073c0: d2 02 20 08 ld [ %o0 + 8 ], %o1 20073c4: 80 a0 60 02 cmp %g1, 2 20073c8: 02 80 00 1d be 200743c 20073cc: 01 00 00 00 nop #endif ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); 20073d0: 40 00 00 80 call 20075d0 <== NOT EXECUTED 20073d4: 01 00 00 00 nop <== NOT EXECUTED } 20073d8: 81 c7 e0 08 ret <== NOT EXECUTED 20073dc: 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( 20073e0: 94 10 20 00 clr %o2 20073e4: 40 00 07 f7 call 20093c0 <_CORE_semaphore_Surrender> 20073e8: 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 ) 20073ec: 03 00 80 7c sethi %hi(0x201f000), %g1 20073f0: c4 00 60 90 ld [ %g1 + 0x90 ], %g2 ! 201f090 <_Thread_Dispatch_disable_level> 20073f4: 90 10 20 00 clr %o0 20073f8: 84 00 bf ff add %g2, -1, %g2 20073fc: c4 20 60 90 st %g2, [ %g1 + 0x90 ] 2007400: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 2007404: 80 a0 e0 00 cmp %g3, 0 2007408: 12 bf ff f4 bne 20073d8 200740c: 01 00 00 00 nop _Thread_Dispatch(); 2007410: 40 00 0f f6 call 200b3e8 <_Thread_Dispatch> 2007414: 01 00 00 00 nop 2007418: 90 10 20 00 clr %o0 ! 0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 200741c: 81 c7 e0 08 ret 2007420: 91 e8 00 08 restore %g0, %o0, %o0 the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_REMOTE: _Thread_Dispatch(); 2007424: 40 00 0f f1 call 200b3e8 <_Thread_Dispatch> <== NOT EXECUTED 2007428: 01 00 00 00 nop <== NOT EXECUTED return POSIX_MP_NOT_IMPLEMENTED(); 200742c: 40 00 00 73 call 20075f8 <== NOT EXECUTED 2007430: 01 00 00 00 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007434: 81 c7 e0 08 ret <== NOT EXECUTED 2007438: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); 200743c: 40 00 29 ec call 2011bec <__errno> 2007440: 01 00 00 00 nop 2007444: 82 10 20 16 mov 0x16, %g1 ! 16 2007448: c2 22 00 00 st %g1, [ %o0 ] 200744c: 90 10 3f ff mov -1, %o0 ); _Thread_Enable_dispatch(); return 0; } return POSIX_BOTTOM_REACHED(); } 2007450: 81 c7 e0 08 ret 2007454: 91 e8 00 08 restore %g0, %o0, %o0 02007458 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 2007458: 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 ); 200745c: 90 10 00 19 mov %i1, %o0 2007460: 40 00 1e 04 call 200ec70 <_POSIX_Absolute_timeout_to_ticks> 2007464: 92 07 bf f4 add %fp, -12, %o1 switch ( status ) { 2007468: 80 a2 20 02 cmp %o0, 2 200746c: 18 80 00 07 bgu 2007488 2007470: d4 07 bf f4 ld [ %fp + -12 ], %o2 case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 2007474: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2007478: 40 00 21 1e call 200f8f0 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 200747c: 92 10 20 00 clr %o1 <== NOT EXECUTED break; } } return lock_status; } 2007480: 81 c7 e0 08 ret <== NOT EXECUTED 2007484: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 2007488: 90 10 00 18 mov %i0, %o0 200748c: 40 00 21 19 call 200f8f0 <_POSIX_Semaphore_Wait_support> 2007490: 92 10 20 01 mov 1, %o1 break; } } return lock_status; } 2007494: 81 c7 e0 08 ret 2007498: 91 e8 00 08 restore %g0, %o0, %o0 020074b4 : */ int sem_unlink( const char *name ) { 20074b4: 9d e3 bf 90 save %sp, -112, %sp rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20074b8: 21 00 80 7c sethi %hi(0x201f000), %l0 20074bc: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 ! 201f090 <_Thread_Dispatch_disable_level> 20074c0: 90 10 00 18 mov %i0, %o0 20074c4: 82 00 60 01 inc %g1 20074c8: c2 24 20 90 st %g1, [ %l0 + 0x90 ] register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 20074cc: 40 00 20 ea call 200f874 <_POSIX_Semaphore_Name_to_id> 20074d0: 92 07 bf f4 add %fp, -12, %o1 if ( status != 0 ) { 20074d4: b0 92 20 00 orcc %o0, 0, %i0 20074d8: 12 80 00 1f bne 2007554 20074dc: 03 00 80 7d sethi %hi(0x201f400), %g1 RTEMS_INLINE_ROUTINE Objects_Control *_Objects_Get_local_object( Objects_Information *information, uint16_t index ) { if ( index > information->maximum ) 20074e0: c4 07 bf f4 ld [ %fp + -12 ], %g2 20074e4: 88 10 60 10 or %g1, 0x10, %g4 20074e8: c6 11 20 10 lduh [ %g4 + 0x10 ], %g3 20074ec: 03 00 00 3f sethi %hi(0xfc00), %g1 20074f0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 20074f4: 82 08 80 01 and %g2, %g1, %g1 20074f8: 80 a0 40 03 cmp %g1, %g3 20074fc: 18 80 00 05 bgu 2007510 2007500: 90 10 20 00 clr %o0 2007504: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 2007508: 83 28 60 02 sll %g1, 2, %g1 200750c: d0 00 80 01 ld [ %g2 + %g1 ], %o0 if ( the_semaphore->process_shared == PTHREAD_PROCESS_SHARED ) { _Objects_MP_Close( &_POSIX_Semaphore_Information, the_semaphore_id ); } #endif the_semaphore->linked = FALSE; 2007510: c0 22 20 18 clr [ %o0 + 0x18 ] _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 2007514: 40 00 20 bb call 200f800 <_POSIX_Semaphore_Delete> 2007518: c0 22 20 0c clr [ %o0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200751c: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 2007520: b0 10 20 00 clr %i0 2007524: 82 00 7f ff add %g1, -1, %g1 2007528: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 200752c: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 2007530: 80 a0 a0 00 cmp %g2, 0 2007534: 02 80 00 04 be 2007544 2007538: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 200753c: 81 c7 e0 08 ret <== NOT EXECUTED 2007540: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 2007544: 40 00 0f a9 call 200b3e8 <_Thread_Dispatch> 2007548: 01 00 00 00 nop 200754c: 81 c7 e0 08 ret 2007550: 81 e8 00 00 restore #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 2007554: c2 04 20 90 ld [ %l0 + 0x90 ], %g1 2007558: 82 00 7f ff add %g1, -1, %g1 200755c: c2 24 20 90 st %g1, [ %l0 + 0x90 ] 2007560: c4 04 20 90 ld [ %l0 + 0x90 ], %g2 2007564: 80 a0 a0 00 cmp %g2, 0 2007568: 02 80 00 07 be 2007584 200756c: 01 00 00 00 nop _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); 2007570: 40 00 29 9f call 2011bec <__errno> 2007574: 01 00 00 00 nop 2007578: f0 22 00 00 st %i0, [ %o0 ] 200757c: 81 c7 e0 08 ret 2007580: 91 e8 3f ff restore %g0, -1, %o0 _Thread_Dispatch(); 2007584: 40 00 0f 99 call 200b3e8 <_Thread_Dispatch> 2007588: 01 00 00 00 nop 200758c: 30 bf ff f9 b,a 2007570 02017e08 : int setgid( gid_t gid ) { _POSIX_types_Gid = gid; 2017e08: 03 00 80 ec sethi %hi(0x203b000), %g1 <== NOT EXECUTED 2017e0c: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 203b200 <== NOT EXECUTED 2017e10: d0 30 a0 2a sth %o0, [ %g2 + 0x2a ] <== NOT EXECUTED return 0; } 2017e14: 81 c3 e0 08 retl <== NOT EXECUTED 2017e18: 90 10 20 00 clr %o0 <== NOT EXECUTED 0201848c : return NULL; return &grent; } void setgrent(void) { 201848c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED init_etc_passwd_group(); 2018490: 7f ff ff c4 call 20183a0 <== NOT EXECUTED 2018494: 21 00 80 f2 sethi %hi(0x203c800), %l0 <== NOT EXECUTED if (group_fp != NULL) 2018498: d0 04 22 ac ld [ %l0 + 0x2ac ], %o0 ! 203caac <== NOT EXECUTED 201849c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20184a0: 22 80 00 05 be,a 20184b4 <== NOT EXECUTED 20184a4: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED fclose(group_fp); 20184a8: 40 00 35 32 call 2025970 <== NOT EXECUTED 20184ac: 01 00 00 00 nop <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 20184b0: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 20184b4: 13 00 80 e8 sethi %hi(0x203a000), %o1 <== NOT EXECUTED 20184b8: 90 12 23 d8 or %o0, 0x3d8, %o0 <== NOT EXECUTED 20184bc: 40 00 37 2b call 2026168 <== NOT EXECUTED 20184c0: 92 12 63 80 or %o1, 0x380, %o1 <== NOT EXECUTED 20184c4: d0 24 22 ac st %o0, [ %l0 + 0x2ac ] <== NOT EXECUTED } 20184c8: 81 c7 e0 08 ret <== NOT EXECUTED 20184cc: 81 e8 00 00 restore <== NOT EXECUTED 02018690 : return NULL; return &pwent; } void setpwent(void) { 2018690: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED init_etc_passwd_group(); 2018694: 7f ff ff 43 call 20183a0 <== NOT EXECUTED 2018698: 21 00 80 f2 sethi %hi(0x203c800), %l0 <== NOT EXECUTED if (passwd_fp != NULL) 201869c: d0 04 21 c4 ld [ %l0 + 0x1c4 ], %o0 ! 203c9c4 <== NOT EXECUTED 20186a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 20186a4: 22 80 00 05 be,a 20186b8 <== NOT EXECUTED 20186a8: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED fclose(passwd_fp); 20186ac: 40 00 34 b1 call 2025970 <== NOT EXECUTED 20186b0: 01 00 00 00 nop <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 20186b4: 11 00 80 df sethi %hi(0x2037c00), %o0 <== NOT EXECUTED 20186b8: 13 00 80 e8 sethi %hi(0x203a000), %o1 <== NOT EXECUTED 20186bc: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED 20186c0: 40 00 36 aa call 2026168 <== NOT EXECUTED 20186c4: 92 12 63 80 or %o1, 0x380, %o1 <== NOT EXECUTED 20186c8: d0 24 21 c4 st %o0, [ %l0 + 0x1c4 ] <== NOT EXECUTED } 20186cc: 81 c7 e0 08 ret <== NOT EXECUTED 20186d0: 81 e8 00 00 restore <== NOT EXECUTED 020188a4 : int setuid( uid_t uid ) { _POSIX_types_Uid = uid; 20188a4: 03 00 80 ec sethi %hi(0x203b000), %g1 <== NOT EXECUTED 20188a8: c4 00 62 00 ld [ %g1 + 0x200 ], %g2 ! 203b200 <== NOT EXECUTED 20188ac: d0 30 a0 28 sth %o0, [ %g2 + 0x28 ] <== NOT EXECUTED return 0; } 20188b0: 81 c3 e0 08 retl <== NOT EXECUTED 20188b4: 90 10 20 00 clr %o0 <== NOT EXECUTED 020064cc : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 20064cc: 9d e3 bf 98 save %sp, -104, %sp ISR_Level level; if ( oact ) 20064d0: 80 a6 a0 00 cmp %i2, 0 20064d4: 02 80 00 0d be 2006508 20064d8: 87 2e 20 02 sll %i0, 2, %g3 *oact = _POSIX_signals_Vectors[ sig ]; 20064dc: 05 00 80 73 sethi %hi(0x201cc00), %g2 <== NOT EXECUTED 20064e0: 83 2e 20 04 sll %i0, 4, %g1 <== NOT EXECUTED 20064e4: 84 10 a3 c4 or %g2, 0x3c4, %g2 <== NOT EXECUTED 20064e8: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 20064ec: c8 00 80 01 ld [ %g2 + %g1 ], %g4 <== NOT EXECUTED 20064f0: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 20064f4: c8 26 80 00 st %g4, [ %i2 ] <== NOT EXECUTED 20064f8: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED 20064fc: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED 2006500: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED 2006504: c6 26 a0 08 st %g3, [ %i2 + 8 ] <== NOT EXECUTED if ( !sig ) 2006508: 80 a6 20 00 cmp %i0, 0 200650c: 02 80 00 33 be 20065d8 2006510: b4 06 3f ff add %i0, -1, %i2 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 2006514: 80 a6 a0 1f cmp %i2, 0x1f 2006518: 18 80 00 30 bgu 20065d8 200651c: 80 a6 20 09 cmp %i0, 9 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 2006520: 02 80 00 2e be 20065d8 2006524: 80 a6 60 00 cmp %i1, 0 /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 2006528: 02 80 00 1a be 2006590 200652c: 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 ); 2006530: 7f ff ef b5 call 2002404 2006534: 01 00 00 00 nop 2006538: a0 10 00 08 mov %o0, %l0 if ( act->sa_handler == SIG_DFL ) { 200653c: c2 06 60 08 ld [ %i1 + 8 ], %g1 2006540: 80 a0 60 00 cmp %g1, 0 2006544: 02 80 00 15 be 2006598 2006548: 90 10 20 01 mov 1, %o0 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 200654c: 40 00 1f 26 call 200e1e4 <_POSIX_signals_Clear_process_signals> 2006550: 91 2a 00 1a sll %o0, %i2, %o0 _POSIX_signals_Vectors[ sig ] = *act; 2006554: da 06 40 00 ld [ %i1 ], %o5 2006558: 85 2e 20 02 sll %i0, 2, %g2 200655c: 83 2e 20 04 sll %i0, 4, %g1 2006560: 07 00 80 73 sethi %hi(0x201cc00), %g3 2006564: 82 20 40 02 sub %g1, %g2, %g1 2006568: 86 10 e3 c4 or %g3, 0x3c4, %g3 200656c: da 20 c0 01 st %o5, [ %g3 + %g1 ] 2006570: c8 06 60 04 ld [ %i1 + 4 ], %g4 2006574: 82 00 40 03 add %g1, %g3, %g1 2006578: c8 20 60 04 st %g4, [ %g1 + 4 ] 200657c: c4 06 60 08 ld [ %i1 + 8 ], %g2 2006580: c4 20 60 08 st %g2, [ %g1 + 8 ] } _ISR_Enable( level ); 2006584: 7f ff ef a4 call 2002414 2006588: 90 10 00 10 mov %l0, %o0 200658c: 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; } 2006590: 81 c7 e0 08 ret 2006594: 91 e8 00 01 restore %g0, %g1, %o0 * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); if ( act->sa_handler == SIG_DFL ) { _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 2006598: 85 2e 20 02 sll %i0, 2, %g2 <== NOT EXECUTED 200659c: 87 2e 20 04 sll %i0, 4, %g3 <== NOT EXECUTED 20065a0: 03 00 80 6f sethi %hi(0x201bc00), %g1 <== NOT EXECUTED 20065a4: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED 20065a8: 82 10 60 c4 or %g1, 0xc4, %g1 <== NOT EXECUTED 20065ac: c8 00 40 03 ld [ %g1 + %g3 ], %g4 <== NOT EXECUTED 20065b0: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED 20065b4: da 00 60 08 ld [ %g1 + 8 ], %o5 <== NOT EXECUTED 20065b8: d8 00 60 04 ld [ %g1 + 4 ], %o4 <== NOT EXECUTED 20065bc: 05 00 80 73 sethi %hi(0x201cc00), %g2 <== NOT EXECUTED 20065c0: 84 10 a3 c4 or %g2, 0x3c4, %g2 ! 201cfc4 <_POSIX_signals_Vectors> <== NOT EXECUTED 20065c4: c8 20 80 03 st %g4, [ %g2 + %g3 ] <== NOT EXECUTED 20065c8: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED 20065cc: da 20 e0 08 st %o5, [ %g3 + 8 ] <== NOT EXECUTED 20065d0: 10 bf ff ed b 2006584 <== NOT EXECUTED 20065d4: d8 20 e0 04 st %o4, [ %g3 + 4 ] <== NOT EXECUTED * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) rtems_set_errno_and_return_minus_one( EINVAL ); 20065d8: 40 00 27 b5 call 20104ac <__errno> 20065dc: 01 00 00 00 nop 20065e0: 82 10 20 16 mov 0x16, %g1 ! 16 20065e4: c2 22 00 00 st %g1, [ %o0 ] 20065e8: 10 bf ff ea b 2006590 20065ec: 82 10 3f ff mov -1, %g1 02006974 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 2006974: 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 ) { 2006978: 80 a6 a0 00 cmp %i2, 0 200697c: 02 80 00 0c be 20069ac 2006980: a6 10 20 00 clr %l3 if ( !_Timespec_Is_valid( timeout ) ) 2006984: 40 00 14 dc call 200bcf4 <_Timespec_Is_valid> 2006988: 90 10 00 1a mov %i2, %o0 200698c: 80 a2 20 00 cmp %o0, 0 2006990: 02 80 00 76 be 2006b68 2006994: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 2006998: 40 00 14 fe call 200bd90 <_Timespec_To_ticks> 200699c: 90 10 00 1a mov %i2, %o0 if ( !interval ) 20069a0: a6 92 20 00 orcc %o0, 0, %l3 20069a4: 02 80 00 71 be 2006b68 20069a8: 01 00 00 00 nop /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 20069ac: 80 a6 60 00 cmp %i1, 0 20069b0: 02 80 00 03 be 20069bc 20069b4: a4 07 bf ec add %fp, -20, %l2 20069b8: a4 10 00 19 mov %i1, %l2 the_thread = _Thread_Executing; 20069bc: 29 00 80 74 sethi %hi(0x201d000), %l4 20069c0: f4 05 22 f0 ld [ %l4 + 0x2f0 ], %i2 ! 201d2f0 <_Thread_Executing> * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 20069c4: 7f ff ef 57 call 2002720 20069c8: f2 06 a1 74 ld [ %i2 + 0x174 ], %i1 20069cc: a0 10 00 08 mov %o0, %l0 if ( *set & api->signals_pending ) { 20069d0: c4 06 00 00 ld [ %i0 ], %g2 20069d4: c2 06 60 c8 ld [ %i1 + 0xc8 ], %g1 20069d8: 80 88 80 01 btst %g2, %g1 20069dc: 12 80 00 42 bne 2006ae4 20069e0: 01 00 00 00 nop return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 20069e4: 03 00 80 76 sethi %hi(0x201d800), %g1 20069e8: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 201da70 <_POSIX_signals_Pending> 20069ec: 80 88 80 01 btst %g2, %g1 20069f0: 12 80 00 2c bne 2006aa0 20069f4: 23 00 80 74 sethi %hi(0x201d000), %l1 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 20069f8: c2 04 62 10 ld [ %l1 + 0x210 ], %g1 ! 201d210 <_Thread_Dispatch_disable_level> the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 20069fc: 84 10 3f ff mov -1, %g2 2006a00: 82 00 60 01 inc %g1 2006a04: c4 24 80 00 st %g2, [ %l2 ] 2006a08: c2 24 62 10 st %g1, [ %l1 + 0x210 ] _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; the_thread->Wait.return_code = EINTR; 2006a0c: 82 10 20 04 mov 4, %g1 2006a10: c2 26 a0 34 st %g1, [ %i2 + 0x34 ] the_thread->Wait.option = *set; 2006a14: c4 06 00 00 ld [ %i0 ], %g2 RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section ( Thread_queue_Control *the_thread_queue ) { the_thread_queue->sync_state = THREAD_QUEUE_NOTHING_HAPPENED; 2006a18: 82 10 20 01 mov 1, %g1 the_thread->Wait.return_argument = the_info; 2006a1c: 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; 2006a20: c4 26 a0 30 st %g2, [ %i2 + 0x30 ] } the_info->si_signo = -1; _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 2006a24: 21 00 80 76 sethi %hi(0x201d800), %l0 2006a28: a0 14 22 30 or %l0, 0x230, %l0 ! 201da30 <_POSIX_signals_Wait_queue> 2006a2c: e0 26 a0 44 st %l0, [ %i2 + 0x44 ] 2006a30: 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 ); 2006a34: 7f ff ef 3f call 2002730 2006a38: 01 00 00 00 nop _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 2006a3c: 90 10 00 10 mov %l0, %o0 2006a40: 92 10 00 13 mov %l3, %o1 2006a44: 15 00 80 2d sethi %hi(0x200b400), %o2 2006a48: 40 00 11 ba call 200b130 <_Thread_queue_Enqueue_with_handler> 2006a4c: 94 12 a2 70 or %o2, 0x270, %o2 ! 200b670 <_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 ) 2006a50: c2 04 62 10 ld [ %l1 + 0x210 ], %g1 2006a54: 82 00 7f ff add %g1, -1, %g1 2006a58: c2 24 62 10 st %g1, [ %l1 + 0x210 ] 2006a5c: c4 04 62 10 ld [ %l1 + 0x210 ], %g2 2006a60: 80 a0 a0 00 cmp %g2, 0 2006a64: 02 80 00 31 be 2006b28 2006a68: 94 10 00 12 mov %l2, %o2 /* * 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 ); 2006a6c: d2 04 80 00 ld [ %l2 ], %o1 <== NOT EXECUTED 2006a70: 96 10 20 00 clr %o3 <== NOT EXECUTED 2006a74: 98 10 20 00 clr %o4 <== NOT EXECUTED 2006a78: 40 00 1f df call 200e9f4 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 2006a7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED errno = _Thread_Executing->Wait.return_code; 2006a80: 40 00 28 62 call 2010c08 <__errno> <== NOT EXECUTED 2006a84: 01 00 00 00 nop <== NOT EXECUTED 2006a88: c2 05 22 f0 ld [ %l4 + 0x2f0 ], %g1 <== NOT EXECUTED 2006a8c: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 <== NOT EXECUTED 2006a90: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED return the_info->si_signo; 2006a94: f0 04 80 00 ld [ %l2 ], %i0 <== NOT EXECUTED } 2006a98: 81 c7 e0 08 ret <== NOT EXECUTED 2006a9c: 81 e8 00 00 restore <== NOT EXECUTED } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 2006aa0: 7f ff ff 9a call 2006908 <_POSIX_signals_Get_highest> 2006aa4: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 2006aa8: 94 10 00 12 mov %l2, %o2 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 2006aac: b0 10 00 08 mov %o0, %i0 _POSIX_signals_Clear_signals( api, signo, the_info, TRUE, FALSE ); 2006ab0: 96 10 20 01 mov 1, %o3 2006ab4: 90 10 00 19 mov %i1, %o0 2006ab8: 92 10 00 18 mov %i0, %o1 2006abc: 40 00 1f ce call 200e9f4 <_POSIX_signals_Clear_signals> 2006ac0: 98 10 20 00 clr %o4 _ISR_Enable( level ); 2006ac4: 7f ff ef 1b call 2002730 2006ac8: 90 10 00 10 mov %l0, %o0 the_info->si_signo = signo; the_info->si_code = SI_USER; 2006acc: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 2006ad0: 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; 2006ad4: f0 24 80 00 st %i0, [ %l2 ] the_info->si_code = SI_USER; 2006ad8: c2 24 a0 04 st %g1, [ %l2 + 4 ] 2006adc: 81 c7 e0 08 ret 2006ae0: 81 e8 00 00 restore /* 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 ); 2006ae4: 7f ff ff 89 call 2006908 <_POSIX_signals_Get_highest> 2006ae8: 90 10 00 01 mov %g1, %o0 _POSIX_signals_Clear_signals( 2006aec: 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 ); 2006af0: 92 10 00 08 mov %o0, %o1 _POSIX_signals_Clear_signals( 2006af4: 96 10 20 00 clr %o3 2006af8: 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 ); 2006afc: d2 24 80 00 st %o1, [ %l2 ] _POSIX_signals_Clear_signals( 2006b00: 40 00 1f bd call 200e9f4 <_POSIX_signals_Clear_signals> 2006b04: 98 10 20 00 clr %o4 the_info->si_signo, the_info, FALSE, FALSE ); _ISR_Enable( level ); 2006b08: 7f ff ef 0a call 2002730 2006b0c: 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; 2006b10: f0 04 80 00 ld [ %l2 ], %i0 FALSE, FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; 2006b14: 82 10 20 01 mov 1, %g1 the_info->si_value.sival_int = 0; 2006b18: c0 24 a0 08 clr [ %l2 + 8 ] FALSE, FALSE ); _ISR_Enable( level ); the_info->si_code = SI_USER; 2006b1c: c2 24 a0 04 st %g1, [ %l2 + 4 ] 2006b20: 81 c7 e0 08 ret 2006b24: 81 e8 00 00 restore _Thread_Dispatch(); 2006b28: 40 00 0f e9 call 200aacc <_Thread_Dispatch> 2006b2c: 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 ); 2006b30: d2 04 80 00 ld [ %l2 ], %o1 2006b34: 94 10 00 12 mov %l2, %o2 2006b38: 96 10 20 00 clr %o3 2006b3c: 98 10 20 00 clr %o4 2006b40: 40 00 1f ad call 200e9f4 <_POSIX_signals_Clear_signals> 2006b44: 90 10 00 19 mov %i1, %o0 errno = _Thread_Executing->Wait.return_code; 2006b48: 40 00 28 30 call 2010c08 <__errno> 2006b4c: 01 00 00 00 nop 2006b50: c2 05 22 f0 ld [ %l4 + 0x2f0 ], %g1 2006b54: c4 00 60 34 ld [ %g1 + 0x34 ], %g2 2006b58: c4 22 00 00 st %g2, [ %o0 ] return the_info->si_signo; 2006b5c: f0 04 80 00 ld [ %l2 ], %i0 } 2006b60: 81 c7 e0 08 ret 2006b64: 81 e8 00 00 restore rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 2006b68: 40 00 28 28 call 2010c08 <__errno> 2006b6c: b0 10 3f ff mov -1, %i0 2006b70: 82 10 20 16 mov 0x16, %g1 2006b74: c2 22 00 00 st %g1, [ %o0 ] 2006b78: 81 c7 e0 08 ret 2006b7c: 81 e8 00 00 restore 020088b8 : int sigwait( const sigset_t *set, int *sig ) { 20088b8: 9d e3 bf 98 save %sp, -104, %sp int status; status = sigtimedwait( set, NULL, NULL ); 20088bc: 92 10 20 00 clr %o1 20088c0: 90 10 00 18 mov %i0, %o0 20088c4: 7f ff ff 75 call 2008698 20088c8: 94 10 20 00 clr %o2 if ( status != -1 ) { 20088cc: 80 a2 3f ff cmp %o0, -1 20088d0: 02 80 00 07 be 20088ec 20088d4: 80 a6 60 00 cmp %i1, 0 if ( sig ) 20088d8: 02 80 00 03 be 20088e4 20088dc: b0 10 20 00 clr %i0 *sig = status; 20088e0: d0 26 40 00 st %o0, [ %i1 ] 20088e4: 81 c7 e0 08 ret 20088e8: 81 e8 00 00 restore return 0; } return errno; 20088ec: 40 00 28 63 call 2012a78 <__errno> <== NOT EXECUTED 20088f0: 01 00 00 00 nop <== NOT EXECUTED 20088f4: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 20088f8: 81 c7 e0 08 ret <== NOT EXECUTED 20088fc: 81 e8 00 00 restore <== NOT EXECUTED 020040c4 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 20040c4: 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)) { 20040c8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED 20040cc: 80 88 6e 78 btst 0xe78, %g1 <== NOT EXECUTED 20040d0: 32 80 00 05 bne,a 20040e4 <== NOT EXECUTED 20040d4: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 20040d8: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED 20040dc: 7f ff ff 77 call 2003eb8 <== NOT EXECUTED 20040e0: 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); 20040e4: 94 10 20 00 clr %o2 <== NOT EXECUTED 20040e8: 40 00 07 46 call 2005e00 <== NOT EXECUTED 20040ec: 92 10 20 00 clr %o1 <== NOT EXECUTED i = iproc (c, tty); 20040f0: 90 0e 20 ff and %i0, 0xff, %o0 <== NOT EXECUTED 20040f4: 7f ff ff 71 call 2003eb8 <== NOT EXECUTED 20040f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 20040fc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED rtems_semaphore_release (tty->osem); 2004100: 40 00 08 0f call 200613c <== NOT EXECUTED 2004104: d0 06 60 18 ld [ %i1 + 0x18 ], %o0 <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 2004108: 81 c7 e0 08 ret <== NOT EXECUTED 200410c: 81 e8 00 00 restore <== NOT EXECUTED 0200591c : int _STAT_NAME( const char *path, struct stat *buf ) { 200591c: 9d e3 bf 88 save %sp, -120, %sp /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 2005920: 80 a6 60 00 cmp %i1, 0 2005924: 02 80 00 32 be 20059ec 2005928: 90 10 00 18 mov %i0, %o0 rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 200592c: a0 07 bf e8 add %fp, -24, %l0 2005930: 92 10 20 00 clr %o1 2005934: 94 10 00 10 mov %l0, %o2 2005938: 96 10 20 01 mov 1, %o3 200593c: 7f ff f9 8d call 2003f70 2005940: b0 10 3f ff mov -1, %i0 if ( status != 0 ) 2005944: 80 a2 20 00 cmp %o0, 0 2005948: 12 80 00 27 bne 20059e4 200594c: c4 07 bf ec ld [ %fp + -20 ], %g2 return -1; if ( !loc.handlers->fstat_h ){ 2005950: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 2005954: 80 a0 60 00 cmp %g1, 0 2005958: 02 80 00 2b be 2005a04 200595c: 92 10 00 19 mov %i1, %o1 /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 2005960: c0 26 40 00 clr [ %i1 ] 2005964: c0 26 60 04 clr [ %i1 + 4 ] 2005968: c0 26 60 08 clr [ %i1 + 8 ] 200596c: c0 26 60 0c clr [ %i1 + 0xc ] 2005970: c0 26 60 10 clr [ %i1 + 0x10 ] 2005974: c0 26 60 14 clr [ %i1 + 0x14 ] 2005978: c0 26 60 18 clr [ %i1 + 0x18 ] 200597c: c0 26 60 1c clr [ %i1 + 0x1c ] 2005980: c0 26 60 20 clr [ %i1 + 0x20 ] 2005984: c0 26 60 24 clr [ %i1 + 0x24 ] 2005988: c0 26 60 28 clr [ %i1 + 0x28 ] 200598c: c0 26 60 2c clr [ %i1 + 0x2c ] 2005990: c0 26 60 30 clr [ %i1 + 0x30 ] 2005994: c0 26 60 34 clr [ %i1 + 0x34 ] 2005998: c0 26 60 38 clr [ %i1 + 0x38 ] 200599c: c0 26 60 3c clr [ %i1 + 0x3c ] 20059a0: c0 26 60 40 clr [ %i1 + 0x40 ] 20059a4: c0 26 60 44 clr [ %i1 + 0x44 ] 20059a8: c0 26 60 48 clr [ %i1 + 0x48 ] 20059ac: c0 26 60 4c clr [ %i1 + 0x4c ] status = (*loc.handlers->fstat_h)( &loc, buf ); 20059b0: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1 20059b4: 9f c0 40 00 call %g1 20059b8: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 20059bc: c2 07 bf f0 ld [ %fp + -16 ], %g1 20059c0: 80 a0 60 00 cmp %g1, 0 20059c4: 02 80 00 08 be 20059e4 20059c8: b0 10 00 08 mov %o0, %i0 20059cc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20059d0: 80 a0 60 00 cmp %g1, 0 20059d4: 02 80 00 1a be 2005a3c 20059d8: 01 00 00 00 nop 20059dc: 9f c0 40 00 call %g1 20059e0: 90 10 00 10 mov %l0, %o0 return status; } 20059e4: 81 c7 e0 08 ret 20059e8: 81 e8 00 00 restore /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 20059ec: 40 00 7f 8b call 2025818 <__errno> 20059f0: b0 10 3f ff mov -1, %i0 20059f4: 82 10 20 0e mov 0xe, %g1 20059f8: c2 22 00 00 st %g1, [ %o0 ] 20059fc: 81 c7 e0 08 ret 2005a00: 81 e8 00 00 restore status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) return -1; if ( !loc.handlers->fstat_h ){ rtems_filesystem_freenode( &loc ); 2005a04: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2005a08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005a0c: 02 80 00 08 be 2005a2c <== NOT EXECUTED 2005a10: 01 00 00 00 nop <== NOT EXECUTED 2005a14: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2005a18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2005a1c: 02 80 00 04 be 2005a2c <== NOT EXECUTED 2005a20: 01 00 00 00 nop <== NOT EXECUTED 2005a24: 9f c0 40 00 call %g1 <== NOT EXECUTED 2005a28: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2005a2c: 40 00 7f 7b call 2025818 <__errno> <== NOT EXECUTED 2005a30: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2005a34: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2005a38: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2005a3c: 81 c7 e0 08 ret <== NOT EXECUTED 2005a40: 81 e8 00 00 restore <== NOT EXECUTED 020051dc : int symlink( const char *actualpath, const char *sympath ) { 20051dc: 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 ); 20051e0: c2 4e 40 00 ldsb [ %i1 ], %g1 20051e4: 80 a0 60 2f cmp %g1, 0x2f 20051e8: 02 80 00 07 be 2005204 20051ec: a0 10 00 18 mov %i0, %l0 20051f0: 80 a0 60 5c cmp %g1, 0x5c 20051f4: 02 80 00 04 be 2005204 20051f8: 80 a0 60 00 cmp %g1, 0 20051fc: 12 80 00 2b bne 20052a8 2005200: 03 00 80 68 sethi %hi(0x201a000), %g1 2005204: 03 00 80 68 sethi %hi(0x201a000), %g1 2005208: c6 00 62 30 ld [ %g1 + 0x230 ], %g3 ! 201a230 200520c: 88 10 20 01 mov 1, %g4 2005210: c2 00 e0 14 ld [ %g3 + 0x14 ], %g1 2005214: c2 27 bf e4 st %g1, [ %fp + -28 ] 2005218: c4 00 e0 18 ld [ %g3 + 0x18 ], %g2 200521c: c4 27 bf e8 st %g2, [ %fp + -24 ] 2005220: c2 00 e0 1c ld [ %g3 + 0x1c ], %g1 2005224: c2 27 bf ec st %g1, [ %fp + -20 ] 2005228: c4 00 e0 20 ld [ %g3 + 0x20 ], %g2 200522c: c4 27 bf f0 st %g2, [ %fp + -16 ] result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 2005230: c2 07 bf ec ld [ %fp + -20 ], %g1 2005234: 90 06 40 04 add %i1, %g4, %o0 2005238: c4 00 60 04 ld [ %g1 + 4 ], %g2 200523c: b2 07 bf e4 add %fp, -28, %i1 2005240: 94 07 bf f4 add %fp, -12, %o2 2005244: 92 10 00 19 mov %i1, %o1 2005248: 9f c0 80 00 call %g2 200524c: b0 10 3f ff mov -1, %i0 if ( result != 0 ) 2005250: 80 a2 20 00 cmp %o0, 0 2005254: 12 80 00 13 bne 20052a0 2005258: c4 07 bf ec ld [ %fp + -20 ], %g2 return -1; if ( !loc.ops->symlink_h ) { 200525c: c2 00 a0 38 ld [ %g2 + 0x38 ], %g1 2005260: 80 a0 60 00 cmp %g1, 0 2005264: 02 80 00 1c be 20052d4 2005268: d4 07 bf f4 ld [ %fp + -12 ], %o2 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 200526c: 92 10 00 10 mov %l0, %o1 2005270: 9f c0 40 00 call %g1 2005274: 90 10 00 19 mov %i1, %o0 rtems_filesystem_freenode( &loc ); 2005278: c2 07 bf ec ld [ %fp + -20 ], %g1 200527c: 80 a0 60 00 cmp %g1, 0 2005280: 02 80 00 08 be 20052a0 2005284: b0 10 00 08 mov %o0, %i0 2005288: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200528c: 80 a0 60 00 cmp %g1, 0 2005290: 02 80 00 1b be 20052fc 2005294: 01 00 00 00 nop 2005298: 9f c0 40 00 call %g1 200529c: 90 10 00 19 mov %i1, %o0 return result; } 20052a0: 81 c7 e0 08 ret 20052a4: 81 e8 00 00 restore rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 20052a8: c6 00 62 30 ld [ %g1 + 0x230 ], %g3 20052ac: 88 10 20 00 clr %g4 20052b0: c2 00 e0 04 ld [ %g3 + 4 ], %g1 20052b4: c2 27 bf e4 st %g1, [ %fp + -28 ] 20052b8: c4 00 e0 08 ld [ %g3 + 8 ], %g2 20052bc: c4 27 bf e8 st %g2, [ %fp + -24 ] 20052c0: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 20052c4: c2 27 bf ec st %g1, [ %fp + -20 ] 20052c8: c4 00 e0 10 ld [ %g3 + 0x10 ], %g2 20052cc: 10 bf ff d9 b 2005230 20052d0: c4 27 bf f0 st %g2, [ %fp + -16 ] result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); if ( result != 0 ) return -1; if ( !loc.ops->symlink_h ) { rtems_filesystem_freenode( &loc ); 20052d4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED 20052d8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 20052dc: 02 80 00 04 be 20052ec <== NOT EXECUTED 20052e0: 01 00 00 00 nop <== NOT EXECUTED 20052e4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20052e8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 20052ec: 40 00 32 9d call 2011d60 <__errno> <== NOT EXECUTED 20052f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20052f4: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 20052f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20052fc: 81 c7 e0 08 ret <== NOT EXECUTED 2005300: 81 e8 00 00 restore <== NOT EXECUTED 02015b7c : int tcgetattr( int fd, struct termios *tp ) { 2015b7c: 94 10 00 09 mov %o1, %o2 <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 2015b80: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED 2015b84: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED 2015b88: 40 00 0f c3 call 2019a94 <== NOT EXECUTED 2015b8c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED 2015b90: 01 00 00 00 nop 02015b94 : int tcsetattr( int fd, int opt, struct termios *tp ) { 2015b94: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED switch (opt) { 2015b98: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 2015b9c: 02 80 00 10 be 2015bdc <== NOT EXECUTED 2015ba0: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED 2015ba4: 02 80 00 08 be 2015bc4 <== NOT EXECUTED 2015ba8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 2015bac: 40 00 12 7d call 201a5a0 <__errno> <== NOT EXECUTED 2015bb0: 01 00 00 00 nop <== NOT EXECUTED 2015bb4: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 2015bb8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 2015bbc: 81 c7 e0 08 ret <== NOT EXECUTED 2015bc0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED switch (opt) { default: rtems_set_errno_and_return_minus_one( ENOTSUP ); case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 2015bc4: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED 2015bc8: 40 00 0f b3 call 2019a94 <== NOT EXECUTED 2015bcc: 94 10 20 00 clr %o2 <== NOT EXECUTED 2015bd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2015bd4: 06 bf ff fa bl 2015bbc <== NOT EXECUTED 2015bd8: 01 00 00 00 nop <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 2015bdc: 40 00 0f ae call 2019a94 <== NOT EXECUTED 2015be0: 93 e8 20 02 restore %g0, 2, %o1 <== NOT EXECUTED 2015be4: 01 00 00 00 nop 02005944 : #include long telldir( DIR *dirp ) { 2005944: 9d e3 bf 98 save %sp, -104, %sp rtems_libio_t *iop; if ( !dirp ) 2005948: 80 a6 20 00 cmp %i0, 0 200594c: 02 80 00 1d be 20059c0 2005950: 03 00 80 65 sethi %hi(0x2019400), %g1 /* * Get the file control block structure associated with the * file descriptor */ iop = rtems_libio_iop( dirp->dd_fd ); 2005954: f0 06 00 00 ld [ %i0 ], %i0 2005958: c4 00 61 0c ld [ %g1 + 0x10c ], %g2 200595c: 80 a6 00 02 cmp %i0, %g2 2005960: 1a 80 00 0e bcc 2005998 2005964: 03 00 80 69 sethi %hi(0x201a400), %g1 2005968: c6 00 63 90 ld [ %g1 + 0x390 ], %g3 ! 201a790 200596c: 85 2e 20 02 sll %i0, 2, %g2 2005970: 83 2e 20 04 sll %i0, 4, %g1 2005974: 82 20 40 02 sub %g1, %g2, %g1 2005978: 82 00 40 18 add %g1, %i0, %g1 200597c: 83 28 60 02 sll %g1, 2, %g1 if (iop == NULL) 2005980: 82 80 40 03 addcc %g1, %g3, %g1 2005984: 02 80 00 06 be 200599c 2005988: 92 10 20 2c mov 0x2c, %o1 assert(0); return (long)( iop->offset ); 200598c: f0 00 60 08 ld [ %g1 + 8 ], %i0 } 2005990: 81 c7 e0 08 ret 2005994: 81 e8 00 00 restore */ iop = rtems_libio_iop( dirp->dd_fd ); if (iop == NULL) assert(0); 2005998: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED 200599c: 11 00 80 62 sethi %hi(0x2018800), %o0 <== NOT EXECUTED 20059a0: 15 00 80 62 sethi %hi(0x2018800), %o2 <== NOT EXECUTED 20059a4: 90 12 22 50 or %o0, 0x250, %o0 <== NOT EXECUTED 20059a8: 7f ff f6 7a call 2003390 <__assert> <== NOT EXECUTED 20059ac: 94 12 a2 a0 or %o2, 0x2a0, %o2 <== NOT EXECUTED 20059b0: 82 10 20 00 clr %g1 <== NOT EXECUTED return (long)( iop->offset ); 20059b4: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED } 20059b8: 81 c7 e0 08 ret <== NOT EXECUTED 20059bc: 81 e8 00 00 restore <== NOT EXECUTED ) { rtems_libio_t *iop; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 20059c0: 40 00 31 e8 call 2012160 <__errno> <== NOT EXECUTED 20059c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 20059c8: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 20059cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20059d0: 81 c7 e0 08 ret <== NOT EXECUTED 20059d4: 81 e8 00 00 restore <== NOT EXECUTED 0200b98c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 200b98c: 9d e3 bf 98 save %sp, -104, %sp POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 200b990: 80 a6 20 01 cmp %i0, 1 200b994: 12 80 00 4a bne 200babc 200b998: 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) { 200b99c: 02 80 00 0e be 200b9d4 200b9a0: 21 00 80 93 sethi %hi(0x2024c00), %l0 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 200b9a4: c2 06 40 00 ld [ %i1 ], %g1 200b9a8: 82 00 7f ff add %g1, -1, %g1 200b9ac: 80 a0 60 01 cmp %g1, 1 200b9b0: 18 80 00 43 bgu 200babc 200b9b4: 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 ) 200b9b8: c2 06 60 04 ld [ %i1 + 4 ], %g1 200b9bc: 80 a0 60 00 cmp %g1, 0 200b9c0: 02 80 00 3f be 200babc 200b9c4: 82 00 7f ff add %g1, -1, %g1 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 200b9c8: 80 a0 60 1f cmp %g1, 0x1f 200b9cc: 18 80 00 3c bgu 200babc 200b9d0: 01 00 00 00 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 200b9d4: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200b9d8: 82 00 60 01 inc %g1 200b9dc: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] * 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 ); 200b9e0: 31 00 80 94 sethi %hi(0x2025000), %i0 200b9e4: 40 00 0b bc call 200e8d4 <_Objects_Allocate> 200b9e8: 90 16 20 9c or %i0, 0x9c, %o0 ! 202509c <_POSIX_Timer_Information> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 200b9ec: 80 a2 20 00 cmp %o0, 0 200b9f0: 02 80 00 39 be 200bad4 200b9f4: 82 10 20 02 mov 2, %g1 } /* 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; 200b9f8: 05 00 80 93 sethi %hi(0x2024c00), %g2 rtems_set_errno_and_return_minus_one( EAGAIN ); } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 200b9fc: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ] ptimer->thread_id = _Thread_Executing->Object.id; 200ba00: c6 00 a1 b0 ld [ %g2 + 0x1b0 ], %g3 if ( evp != NULL ) { 200ba04: 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; 200ba08: c2 00 e0 08 ld [ %g3 + 8 ], %g1 if ( evp != NULL ) { 200ba0c: 02 80 00 08 be 200ba2c 200ba10: c2 22 20 38 st %g1, [ %o0 + 0x38 ] ptimer->inf.sigev_notify = evp->sigev_notify; ptimer->inf.sigev_signo = evp->sigev_signo; ptimer->inf.sigev_value = evp->sigev_value; 200ba14: 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; 200ba18: c4 06 40 00 ld [ %i1 ], %g2 ptimer->inf.sigev_signo = evp->sigev_signo; 200ba1c: 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; 200ba20: c4 22 20 40 st %g2, [ %o0 + 0x40 ] ptimer->inf.sigev_signo = evp->sigev_signo; 200ba24: c6 22 20 44 st %g3, [ %o0 + 0x44 ] ptimer->inf.sigev_value = evp->sigev_value; 200ba28: c2 22 20 48 st %g1, [ %o0 + 0x48 ] Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ba2c: 88 16 20 9c or %i0, 0x9c, %g4 ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, the_object ); 200ba30: c6 02 20 08 ld [ %o0 + 8 ], %g3 Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200ba34: c4 11 20 10 lduh [ %g4 + 0x10 ], %g2 } ptimer->overrun = 0; 200ba38: c0 22 20 68 clr [ %o0 + 0x68 ] ptimer->timer_data.it_value.tv_sec = 0; 200ba3c: c0 22 20 5c clr [ %o0 + 0x5c ] ptimer->timer_data.it_value.tv_nsec = 0; 200ba40: c0 22 20 60 clr [ %o0 + 0x60 ] ptimer->timer_data.it_interval.tv_sec = 0; 200ba44: c0 22 20 54 clr [ %o0 + 0x54 ] ptimer->timer_data.it_interval.tv_nsec = 0; 200ba48: c0 22 20 58 clr [ %o0 + 0x58 ] Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200ba4c: c0 22 20 18 clr [ %o0 + 0x18 ] the_watchdog->routine = routine; 200ba50: c0 22 20 2c clr [ %o0 + 0x2c ] the_watchdog->id = id; 200ba54: c0 22 20 30 clr [ %o0 + 0x30 ] 200ba58: 03 00 00 3f sethi %hi(0xfc00), %g1 200ba5c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff 200ba60: 82 08 c0 01 and %g3, %g1, %g1 200ba64: 80 a0 40 02 cmp %g1, %g2 200ba68: 18 80 00 05 bgu 200ba7c 200ba6c: c0 22 20 34 clr [ %o0 + 0x34 ] information->local_table[ index ] = the_object; 200ba70: c4 01 20 20 ld [ %g4 + 0x20 ], %g2 200ba74: 83 28 60 02 sll %g1, 2, %g1 200ba78: d0 20 80 01 st %o0, [ %g2 + %g1 ] _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open(&_POSIX_Timer_Information, &ptimer->Object, (Objects_Name) 0); *timerid = ptimer->Object.id; 200ba7c: c6 26 80 00 st %g3, [ %i2 ] 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; 200ba80: c0 22 20 0c clr [ %o0 + 0xc ] #if ( CPU_INLINE_ENABLE_DISPATCH == TRUE ) RTEMS_INLINE_ROUTINE void _Thread_Enable_dispatch() { RTEMS_COMPILER_MEMORY_BARRIER(); if ( (--_Thread_Dispatch_disable_level) == 0 ) 200ba84: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 200ba88: b0 10 20 00 clr %i0 200ba8c: 82 00 7f ff add %g1, -1, %g1 200ba90: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] 200ba94: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 200ba98: 80 a0 a0 00 cmp %g2, 0 200ba9c: 02 80 00 04 be 200baac 200baa0: 01 00 00 00 nop _Thread_Enable_dispatch(); return 0; } 200baa4: 81 c7 e0 08 ret <== NOT EXECUTED 200baa8: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200baac: 40 00 11 d3 call 20101f8 <_Thread_Dispatch> 200bab0: 01 00 00 00 nop 200bab4: 81 c7 e0 08 ret 200bab8: 81 e8 00 00 restore if ( !evp->sigev_signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 200babc: 40 00 2b 80 call 20168bc <__errno> <== NOT EXECUTED 200bac0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 200bac4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200bac8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200bacc: 81 c7 e0 08 ret <== NOT EXECUTED 200bad0: 81 e8 00 00 restore <== 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 ) 200bad4: c2 04 20 d0 ld [ %l0 + 0xd0 ], %g1 <== NOT EXECUTED 200bad8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200badc: c2 24 20 d0 st %g1, [ %l0 + 0xd0 ] <== NOT EXECUTED 200bae0: c4 04 20 d0 ld [ %l0 + 0xd0 ], %g2 <== NOT EXECUTED 200bae4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200bae8: 02 80 00 08 be 200bb08 <== NOT EXECUTED 200baec: 01 00 00 00 nop <== NOT EXECUTED * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EAGAIN ); 200baf0: 40 00 2b 73 call 20168bc <__errno> <== NOT EXECUTED 200baf4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200baf8: 82 10 20 0b mov 0xb, %g1 <== NOT EXECUTED 200bafc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200bb00: 81 c7 e0 08 ret <== NOT EXECUTED 200bb04: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200bb08: 40 00 11 bc call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200bb0c: 01 00 00 00 nop <== NOT EXECUTED 200bb10: 30 bf ff f8 b,a 200baf0 <== NOT EXECUTED 0200b8b4 : */ int timer_delete( timer_t timerid ) { 200b8b4: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 200b8b8: 21 00 80 94 sethi %hi(0x2025000), %l0 <== NOT EXECUTED 200b8bc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200b8c0: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200b8c4: 40 00 0d 55 call 200ee18 <_Objects_Get> <== NOT EXECUTED 200b8c8: 90 14 20 9c or %l0, 0x9c, %o0 <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b8cc: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200b8d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b8d4: 12 80 00 21 bne 200b958 <== NOT EXECUTED 200b8d8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200b8dc: a0 14 20 9c or %l0, 0x9c, %l0 <== NOT EXECUTED ) { uint32_t index; index = _Objects_Get_index( the_object->id ); _Objects_Set_local_object( information, index, NULL ); 200b8e0: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED Objects_Information *information, uint16_t index, Objects_Control *the_object ) { if ( index <= information->maximum ) 200b8e4: c6 14 20 10 lduh [ %l0 + 0x10 ], %g3 <== NOT EXECUTED 200b8e8: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED 200b8ec: 84 10 a3 ff or %g2, 0x3ff, %g2 ! ffff <== NOT EXECUTED 200b8f0: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 200b8f4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 200b8f8: 38 80 00 06 bgu,a 200b910 <== NOT EXECUTED 200b8fc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED information->local_table[ index ] = the_object; 200b900: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED 200b904: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 200b908: c0 20 80 01 clr [ %g2 + %g1 ] <== NOT EXECUTED case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); ptimer->state = POSIX_TIMER_STATE_FREE; 200b90c: 82 10 20 01 mov 1, %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; 200b910: c0 26 20 0c clr [ %i0 + 0xc ] <== NOT EXECUTED 200b914: c2 2e 20 3c stb %g1, [ %i0 + 0x3c ] <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 200b918: 40 00 18 46 call 2011a30 <_Watchdog_Remove> <== NOT EXECUTED 200b91c: 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 ); 200b920: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 200b924: 40 00 0c fa call 200ed0c <_Objects_Free> <== NOT EXECUTED 200b928: 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 ) 200b92c: 07 00 80 93 sethi %hi(0x2024c00), %g3 <== NOT EXECUTED 200b930: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200b934: b0 10 20 00 clr %i0 <== NOT EXECUTED 200b938: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b93c: c2 20 e0 d0 st %g1, [ %g3 + 0xd0 ] <== NOT EXECUTED 200b940: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2 <== NOT EXECUTED 200b944: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b948: 02 80 00 0d be 200b97c <== NOT EXECUTED 200b94c: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 200b950: 81 c7 e0 08 ret <== NOT EXECUTED 200b954: 81 e8 00 00 restore <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b958: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200b95c: 18 bf ff fd bgu 200b950 <== NOT EXECUTED 200b960: 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 ); 200b964: 40 00 2b d6 call 20168bc <__errno> <== NOT EXECUTED 200b968: 01 00 00 00 nop <== NOT EXECUTED 200b96c: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200b970: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b974: 81 c7 e0 08 ret <== NOT EXECUTED 200b978: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200b97c: 40 00 12 1f call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200b980: 01 00 00 00 nop <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 200b984: 81 c7 e0 08 ret <== NOT EXECUTED 200b988: 81 e8 00 00 restore <== NOT EXECUTED 0200b82c : */ int timer_getoverrun( timer_t timerid ) { 200b82c: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED 200b830: 11 00 80 94 sethi %hi(0x2025000), %o0 <== NOT EXECUTED 200b834: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 200b838: 90 12 20 9c or %o0, 0x9c, %o0 <== NOT EXECUTED 200b83c: 40 00 0d 77 call 200ee18 <_Objects_Get> <== NOT EXECUTED 200b840: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b844: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200b848: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b84c: 12 80 00 0e bne 200b884 <== NOT EXECUTED 200b850: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED case OBJECTS_ERROR: rtems_set_errno_and_return_minus_one( EINVAL ); case OBJECTS_LOCAL: overrun = ptimer->overrun; 200b854: f0 02 20 68 ld [ %o0 + 0x68 ], %i0 <== NOT EXECUTED ptimer->overrun = 0; 200b858: c0 22 20 68 clr [ %o0 + 0x68 ] <== 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 ) 200b85c: 03 00 80 93 sethi %hi(0x2024c00), %g1 <== NOT EXECUTED 200b860: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200b864: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200b868: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] <== NOT EXECUTED 200b86c: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 <== NOT EXECUTED 200b870: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200b874: 02 80 00 0c be 200b8a4 <== NOT EXECUTED 200b878: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return overrun; } return -1; /* unreached - only to remove warnings */ } 200b87c: 81 c7 e0 08 ret <== NOT EXECUTED 200b880: 81 e8 00 00 restore <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b884: 18 bf ff fe bgu 200b87c <== NOT EXECUTED 200b888: 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 ); 200b88c: 40 00 2c 0c call 20168bc <__errno> <== NOT EXECUTED 200b890: 01 00 00 00 nop <== NOT EXECUTED 200b894: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200b898: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b89c: 81 c7 e0 08 ret <== NOT EXECUTED 200b8a0: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200b8a4: 40 00 12 55 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200b8a8: 01 00 00 00 nop <== NOT EXECUTED ptimer->overrun = 0; _Thread_Enable_dispatch(); return overrun; } return -1; /* unreached - only to remove warnings */ } 200b8ac: 81 c7 e0 08 ret <== NOT EXECUTED 200b8b0: 81 e8 00 00 restore <== NOT EXECUTED 0200b778 : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 200b778: 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 ); 200b77c: a0 07 bf ec add %fp, -20, %l0 <== NOT EXECUTED 200b780: 40 00 0a 93 call 200e1cc <_TOD_Get> <== NOT EXECUTED 200b784: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED int timer_gettime( timer_t timerid, struct itimerspec *value ) { 200b788: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 200b78c: 11 00 80 94 sethi %hi(0x2025000), %o0 <== NOT EXECUTED 200b790: 94 07 bf f4 add %fp, -12, %o2 <== NOT EXECUTED 200b794: 40 00 0d a1 call 200ee18 <_Objects_Get> <== NOT EXECUTED 200b798: 90 12 20 9c or %o0, 0x9c, %o0 <== NOT EXECUTED /* Reads the current time */ _TOD_Get( ¤t_time ); ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b79c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED 200b7a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200b7a4: 12 80 00 15 bne 200b7f8 <== NOT EXECUTED 200b7a8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ _Timespec_Subtract( 200b7ac: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 200b7b0: 90 02 20 5c add %o0, 0x5c, %o0 <== NOT EXECUTED 200b7b4: 40 00 17 3d call 20114a8 <_Timespec_Subtract> <== NOT EXECUTED 200b7b8: 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; 200b7bc: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED 200b7c0: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED 200b7c4: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 <== NOT EXECUTED 200b7c8: c4 26 60 04 st %g2, [ %i1 + 4 ] <== 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 ) 200b7cc: 07 00 80 93 sethi %hi(0x2024c00), %g3 <== NOT EXECUTED 200b7d0: c2 00 e0 d0 ld [ %g3 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200b7d4: b0 10 20 00 clr %i0 <== NOT EXECUTED 200b7d8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 200b7dc: c2 20 e0 d0 st %g1, [ %g3 + 0xd0 ] <== NOT EXECUTED 200b7e0: c4 00 e0 d0 ld [ %g3 + 0xd0 ], %g2 <== NOT EXECUTED 200b7e4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 200b7e8: 02 80 00 0d be 200b81c <== NOT EXECUTED 200b7ec: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 200b7f0: 81 c7 e0 08 ret <== NOT EXECUTED 200b7f4: 81 e8 00 00 restore <== NOT EXECUTED /* Reads the current time */ _TOD_Get( ¤t_time ); ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200b7f8: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED 200b7fc: 18 bf ff fd bgu 200b7f0 <== NOT EXECUTED 200b800: 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 ); 200b804: 40 00 2c 2e call 20168bc <__errno> <== NOT EXECUTED 200b808: 01 00 00 00 nop <== NOT EXECUTED 200b80c: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 200b810: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200b814: 81 c7 e0 08 ret <== NOT EXECUTED 200b818: 81 e8 00 00 restore <== NOT EXECUTED _Thread_Dispatch(); 200b81c: 40 00 12 77 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200b820: 01 00 00 00 nop <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } return -1; /* unreached - only to remove warnings */ } 200b824: 81 c7 e0 08 ret <== NOT EXECUTED 200b828: 81 e8 00 00 restore <== NOT EXECUTED 0200bb14 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 200bb14: 9d e3 bf 90 save %sp, -112, %sp POSIX_Timer_Control *ptimer; Objects_Locations location; boolean activated; if ( value == NULL ) { 200bb18: 80 a6 a0 00 cmp %i2, 0 200bb1c: 02 80 00 29 be 200bbc0 200bb20: 92 10 00 18 mov %i0, %o1 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 ) || 200bb24: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 200bb28: 03 0e e6 b2 sethi %hi(0x3b9ac800), %g1 200bb2c: 82 10 62 00 or %g1, 0x200, %g1 ! 3b9aca00 200bb30: 80 a0 80 01 cmp %g2, %g1 200bb34: 18 80 00 23 bgu 200bbc0 200bb38: 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 ) { 200bb3c: 02 80 00 04 be 200bb4c 200bb40: 80 a6 60 00 cmp %i1, 0 200bb44: 12 80 00 1f bne 200bbc0 200bb48: 01 00 00 00 nop RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get ( Objects_Id id, Objects_Locations *location ) { return (POSIX_Timer_Control *) 200bb4c: 11 00 80 94 sethi %hi(0x2025000), %o0 200bb50: 94 07 bf f4 add %fp, -12, %o2 200bb54: 40 00 0c b1 call 200ee18 <_Objects_Get> 200bb58: 90 12 20 9c or %o0, 0x9c, %o0 * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 200bb5c: c2 07 bf f4 ld [ %fp + -12 ], %g1 200bb60: a0 10 00 08 mov %o0, %l0 200bb64: 80 a0 60 00 cmp %g1, 0 200bb68: 12 80 00 1a bne 200bbd0 200bb6c: 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 ) { 200bb70: c2 06 a0 08 ld [ %i2 + 8 ], %g1 200bb74: 80 a0 60 00 cmp %g1, 0 200bb78: 12 80 00 06 bne 200bb90 200bb7c: 80 a6 60 00 cmp %i1, 0 200bb80: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED 200bb84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200bb88: 02 80 00 5d be 200bcfc <== NOT EXECUTED 200bb8c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* absolute or relative? */ switch (flags) { 200bb90: 02 80 00 42 be 200bc98 200bb94: 80 a6 60 04 cmp %i1, 4 200bb98: 22 80 00 10 be,a 200bbd8 <== NOT EXECUTED 200bb9c: c2 04 20 08 ld [ %l0 + 8 ], %g1 <== 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 ) 200bba0: 03 00 80 93 sethi %hi(0x2024c00), %g1 <== NOT EXECUTED 200bba4: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200bba8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200bbac: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] <== NOT EXECUTED 200bbb0: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 <== NOT EXECUTED 200bbb4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200bbb8: 02 80 00 6d be 200bd6c <== NOT EXECUTED 200bbbc: 01 00 00 00 nop <== NOT EXECUTED _TOD_Get( &ptimer->time ); _Thread_Enable_dispatch(); return 0; } _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); 200bbc0: 40 00 2b 3f call 20168bc <__errno> <== NOT EXECUTED 200bbc4: b0 10 3f ff mov -1, %i0 ! ffffffff <== NOT EXECUTED 200bbc8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 200bbcc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200bbd0: 81 c7 e0 08 ret <== NOT EXECUTED 200bbd4: 81 e8 00 00 restore <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200bbd8: 05 00 80 93 sethi %hi(0x2024c00), %g2 <== NOT EXECUTED void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; the_watchdog->id = id; 200bbdc: c2 24 20 30 st %g1, [ %l0 + 0x30 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200bbe0: c6 00 a1 8c ld [ %g2 + 0x18c ], %g3 <== NOT EXECUTED 200bbe4: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 200bbe8: c0 24 20 18 clr [ %l0 + 0x18 ] <== NOT EXECUTED Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 200bbec: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 200bbf0: 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; 200bbf4: 03 00 80 2d sethi %hi(0x200b400), %g1 <== NOT EXECUTED 200bbf8: 82 10 62 f0 or %g1, 0x2f0, %g1 ! 200b6f0 <_POSIX_Timer_TSR> <== NOT EXECUTED the_watchdog->id = id; the_watchdog->user_data = user_data; 200bbfc: e0 24 20 34 st %l0, [ %l0 + 0x34 ] <== NOT EXECUTED Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; the_watchdog->routine = routine; 200bc00: c2 24 20 2c st %g1, [ %l0 + 0x2c ] <== NOT EXECUTED ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 200bc04: 11 00 80 93 sethi %hi(0x2024c00), %o0 <== NOT EXECUTED 200bc08: 92 04 20 10 add %l0, 0x10, %o1 <== NOT EXECUTED 200bc0c: 40 00 17 1f call 2011888 <_Watchdog_Insert> <== NOT EXECUTED 200bc10: 90 12 21 c4 or %o0, 0x1c4, %o0 <== NOT EXECUTED &ptimer->Timer, value->it_value.tv_sec - _TOD_Seconds_since_epoch ); /* Returns the old ones in "ovalue" */ if ( ovalue ) 200bc14: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 200bc18: 22 80 00 0b be,a 200bc44 <== NOT EXECUTED 200bc1c: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; 200bc20: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 200bc24: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 200bc28: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 <== NOT EXECUTED 200bc2c: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED 200bc30: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED 200bc34: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED 200bc38: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED 200bc3c: c4 26 e0 0c st %g2, [ %i3 + 0xc ] <== NOT EXECUTED ptimer->timer_data = *value; 200bc40: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; _TOD_Get( &ptimer->time ); 200bc44: 90 04 20 6c add %l0, 0x6c, %o0 /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 200bc48: c4 24 20 54 st %g2, [ %l0 + 0x54 ] 200bc4c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 200bc50: c2 24 20 58 st %g1, [ %l0 + 0x58 ] 200bc54: c4 06 a0 08 ld [ %i2 + 8 ], %g2 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 200bc58: 82 10 20 03 mov 3, %g1 /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 200bc5c: c4 24 20 5c st %g2, [ %l0 + 0x5c ] 200bc60: c6 06 a0 0c ld [ %i2 + 0xc ], %g3 /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 200bc64: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] _TOD_Get( &ptimer->time ); 200bc68: 40 00 09 59 call 200e1cc <_TOD_Get> 200bc6c: c6 24 20 60 st %g3, [ %l0 + 0x60 ] 200bc70: 05 00 80 93 sethi %hi(0x2024c00), %g2 200bc74: c2 00 a0 d0 ld [ %g2 + 0xd0 ], %g1 ! 2024cd0 <_Thread_Dispatch_disable_level> 200bc78: 82 00 7f ff add %g1, -1, %g1 200bc7c: c2 20 a0 d0 st %g1, [ %g2 + 0xd0 ] 200bc80: c6 00 a0 d0 ld [ %g2 + 0xd0 ], %g3 200bc84: 80 a0 e0 00 cmp %g3, 0 200bc88: 02 80 00 19 be 200bcec 200bc8c: 01 00 00 00 nop } _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } return -1; /* unreached - only to remove warnings */ } 200bc90: 81 c7 e0 08 ret <== NOT EXECUTED 200bc94: 91 e8 20 00 restore %g0, 0, %o0 <== 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 ); 200bc98: 40 00 16 1a call 2011500 <_Timespec_To_ticks> 200bc9c: 90 06 a0 08 add %i2, 8, %o0 activated = _Watchdog_Insert_ticks_helper( 200bca0: 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 ); 200bca4: 92 10 00 08 mov %o0, %o1 200bca8: d0 24 20 64 st %o0, [ %l0 + 0x64 ] activated = _Watchdog_Insert_ticks_helper( 200bcac: 17 00 80 2d sethi %hi(0x200b400), %o3 200bcb0: 90 04 20 10 add %l0, 0x10, %o0 200bcb4: 96 12 e2 f0 or %o3, 0x2f0, %o3 200bcb8: 7f ff fe 73 call 200b684 <_Watchdog_Insert_ticks_helper> 200bcbc: 98 10 00 10 mov %l0, %o4 ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 200bcc0: 80 a2 20 00 cmp %o0, 0 200bcc4: 12 80 00 26 bne 200bd5c 200bcc8: 80 a6 e0 00 cmp %i3, 0 200bccc: 03 00 80 93 sethi %hi(0x2024c00), %g1 <== NOT EXECUTED 200bcd0: c4 00 60 d0 ld [ %g1 + 0xd0 ], %g2 ! 2024cd0 <_Thread_Dispatch_disable_level> <== NOT EXECUTED 200bcd4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED 200bcd8: c4 20 60 d0 st %g2, [ %g1 + 0xd0 ] <== NOT EXECUTED 200bcdc: c6 00 60 d0 ld [ %g1 + 0xd0 ], %g3 <== NOT EXECUTED 200bce0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 200bce4: 32 bf ff bb bne,a 200bbd0 <== NOT EXECUTED 200bce8: b0 10 20 00 clr %i0 <== NOT EXECUTED _Thread_Dispatch(); 200bcec: 40 00 11 43 call 20101f8 <_Thread_Dispatch> 200bcf0: b0 10 20 00 clr %i0 200bcf4: 81 c7 e0 08 ret 200bcf8: 81 e8 00 00 restore 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 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 200bcfc: 40 00 17 4d call 2011a30 <_Watchdog_Remove> <== NOT EXECUTED 200bd00: 90 02 20 10 add %o0, 0x10, %o0 <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 200bd04: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 200bd08: 22 80 00 0b be,a 200bd34 <== NOT EXECUTED 200bd0c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED *ovalue = ptimer->timer_data; 200bd10: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED 200bd14: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED 200bd18: c4 04 20 58 ld [ %l0 + 0x58 ], %g2 <== NOT EXECUTED 200bd1c: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED 200bd20: c2 04 20 5c ld [ %l0 + 0x5c ], %g1 <== NOT EXECUTED 200bd24: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED 200bd28: c4 04 20 60 ld [ %l0 + 0x60 ], %g2 <== NOT EXECUTED 200bd2c: c4 26 e0 0c st %g2, [ %i3 + 0xc ] <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = *value; 200bd30: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED 200bd34: c2 24 20 54 st %g1, [ %l0 + 0x54 ] <== NOT EXECUTED 200bd38: c4 06 a0 04 ld [ %i2 + 4 ], %g2 <== NOT EXECUTED 200bd3c: c4 24 20 58 st %g2, [ %l0 + 0x58 ] <== NOT EXECUTED 200bd40: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED 200bd44: c2 24 20 5c st %g1, [ %l0 + 0x5c ] <== NOT EXECUTED 200bd48: c4 06 a0 0c ld [ %i2 + 0xc ], %g2 <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 200bd4c: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); /* The old data of the timer are returned */ if ( ovalue ) *ovalue = ptimer->timer_data; /* The new data are set */ ptimer->timer_data = *value; 200bd50: c4 24 20 60 st %g2, [ %l0 + 0x60 ] <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 200bd54: 10 bf ff c7 b 200bc70 <== NOT EXECUTED 200bd58: c2 2c 20 3c stb %g1, [ %l0 + 0x3c ] <== NOT EXECUTED return 0; } /* The timer has been started and is running */ /* return the old ones in "ovalue" */ if ( ovalue ) 200bd5c: 32 bf ff b2 bne,a 200bc24 200bd60: c2 04 20 54 ld [ %l0 + 0x54 ], %g1 <== NOT EXECUTED *ovalue = ptimer->timer_data; ptimer->timer_data = *value; 200bd64: 10 bf ff b8 b 200bc44 200bd68: c4 06 80 00 ld [ %i2 ], %g2 200bd6c: 40 00 11 23 call 20101f8 <_Thread_Dispatch> <== NOT EXECUTED 200bd70: 01 00 00 00 nop <== NOT EXECUTED 200bd74: 30 bf ff 93 b,a 200bbc0 <== NOT EXECUTED 02019014 : */ char *ttyname( int fd ) { 2019014: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 2019018: 21 00 80 ec sethi %hi(0x203b000), %l0 <== NOT EXECUTED 201901c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2019020: 94 10 24 06 mov 0x406, %o2 <== NOT EXECUTED 2019024: 92 14 23 70 or %l0, 0x370, %o1 <== NOT EXECUTED 2019028: 7f ff ff ba call 2018f10 <== NOT EXECUTED 201902c: b0 14 23 70 or %l0, 0x370, %i0 <== NOT EXECUTED 2019030: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2019034: 12 80 00 04 bne 2019044 <== NOT EXECUTED 2019038: 01 00 00 00 nop <== NOT EXECUTED return ttyname_buf; return NULL; } 201903c: 81 c7 e0 08 ret <== NOT EXECUTED 2019040: 81 e8 00 00 restore <== NOT EXECUTED 2019044: 81 c7 e0 08 ret <== NOT EXECUTED 2019048: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED 02018f10 : int ttyname_r( int fd, char *name, int namesize ) { 2018f10: 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) 2018f14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018f18: 7f ff ff e3 call 2018ea4 <== NOT EXECUTED 2018f1c: 92 07 bf d4 add %fp, -44, %o1 <== NOT EXECUTED 2018f20: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018f24: 06 80 00 0d bl 2018f58 <== NOT EXECUTED 2018f28: 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)) 2018f2c: 40 00 28 82 call 2023134 <== NOT EXECUTED 2018f30: 92 07 bf 80 add %fp, -128, %o1 <== NOT EXECUTED 2018f34: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018f38: 12 80 00 08 bne 2018f58 <== NOT EXECUTED 2018f3c: c2 17 bf 8c lduh [ %fp + -116 ], %g1 <== NOT EXECUTED 2018f40: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED 2018f44: 07 00 00 08 sethi %hi(0x2000), %g3 <== NOT EXECUTED 2018f48: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED 2018f4c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 2018f50: 02 80 00 08 be 2018f70 <== NOT EXECUTED 2018f54: 11 00 80 e0 sethi %hi(0x2038000), %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); 2018f58: 40 00 32 30 call 2025818 <__errno> <== NOT EXECUTED 2018f5c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2018f60: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED 2018f64: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2018f68: 81 c7 e0 08 ret <== NOT EXECUTED 2018f6c: 81 e8 00 00 restore <== 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); 2018f70: 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) 2018f74: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED 2018f78: 7f ff fe 7b call 2018964 <== NOT EXECUTED 2018f7c: a2 07 bf 30 add %fp, -208, %l1 <== NOT EXECUTED 2018f80: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED 2018f84: 02 bf ff f5 be 2018f58 <== NOT EXECUTED 2018f88: 01 00 00 00 nop <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); for (rval = NULL; (dirp = readdir (dp)) != NULL ;) 2018f8c: 7f ff ff 38 call 2018c6c <== NOT EXECUTED 2018f90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2018f94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018f98: 02 80 00 1a be 2019000 <== NOT EXECUTED 2018f9c: c2 07 bf 88 ld [ %fp + -120 ], %g1 <== NOT EXECUTED { if (dirp->d_ino != sb.st_ino) 2018fa0: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED 2018fa4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2018fa8: 12 bf ff f9 bne 2018f8c <== NOT EXECUTED 2018fac: 92 02 20 0c add %o0, 0xc, %o1 <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 2018fb0: 40 00 41 20 call 2029430 <== NOT EXECUTED 2018fb4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 2018fb8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 2018fbc: 7f ff b2 58 call 200591c <== NOT EXECUTED 2018fc0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 2018fc4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2018fc8: 12 bf ff f1 bne 2018f8c <== NOT EXECUTED 2018fcc: c4 07 bf 80 ld [ %fp + -128 ], %g2 <== NOT EXECUTED 2018fd0: c2 07 bf 30 ld [ %fp + -208 ], %g1 <== NOT EXECUTED 2018fd4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2018fd8: 12 bf ff ed bne 2018f8c <== NOT EXECUTED 2018fdc: c4 07 bf 84 ld [ %fp + -124 ], %g2 <== NOT EXECUTED 2018fe0: c2 07 bf 34 ld [ %fp + -204 ], %g1 <== NOT EXECUTED 2018fe4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2018fe8: 12 bf ff e9 bne 2018f8c <== NOT EXECUTED 2018fec: c4 07 bf 88 ld [ %fp + -120 ], %g2 <== NOT EXECUTED 2018ff0: c2 07 bf 38 ld [ %fp + -200 ], %g1 <== NOT EXECUTED 2018ff4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 2018ff8: 12 bf ff e5 bne 2018f8c <== NOT EXECUTED 2018ffc: 01 00 00 00 nop <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 2019000: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 2019004: 7f ff f9 83 call 2017610 <== NOT EXECUTED 2019008: b0 10 20 00 clr %i0 <== NOT EXECUTED return 0; } 201900c: 81 c7 e0 08 ret <== NOT EXECUTED 2019010: 81 e8 00 00 restore <== NOT EXECUTED 02019068 : #include int unlink( const char *path ) { 2019068: 9d e3 bf 88 save %sp, -120, %sp /* * Get the node to be unlinked. */ result = rtems_filesystem_evaluate_path( path, 0, &loc, FALSE ); 201906c: 92 10 20 00 clr %o1 2019070: 90 10 00 18 mov %i0, %o0 2019074: a0 07 bf e8 add %fp, -24, %l0 2019078: 96 10 20 00 clr %o3 201907c: 7f ff ab bd call 2003f70 2019080: 94 10 00 10 mov %l0, %o2 if ( result != 0 ) 2019084: 80 a2 20 00 cmp %o0, 0 2019088: 02 80 00 04 be 2019098 201908c: 90 10 20 02 mov 2, %o0 result = (*loc.ops->unlink_h)( &loc ); rtems_filesystem_freenode( &loc ); return result; } 2019090: 81 c7 e0 08 ret 2019094: 91 e8 3f ff restore %g0, -1, %o0 result = rtems_filesystem_evaluate_path( path, 0, &loc, FALSE ); if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 2019098: 7f ff ab 86 call 2003eb0 201909c: 92 10 00 10 mov %l0, %o1 if (result != 0 && errno != ENOTSUP) { 20190a0: 80 a2 20 00 cmp %o0, 0 20190a4: 12 80 00 1d bne 2019118 20190a8: c4 07 bf f0 ld [ %fp + -16 ], %g2 rtems_filesystem_freenode( &loc ); return -1; } if ( !loc.ops->node_type_h ) { 20190ac: c2 00 a0 10 ld [ %g2 + 0x10 ], %g1 20190b0: 80 a0 60 00 cmp %g1, 0 20190b4: 22 80 00 2b be,a 2019160 20190b8: c2 00 a0 1c ld [ %g2 + 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 ) { 20190bc: 9f c0 40 00 call %g1 20190c0: 90 10 00 10 mov %l0, %o0 20190c4: 80 a2 20 01 cmp %o0, 1 20190c8: 02 80 00 31 be 201918c 20190cc: c4 07 bf f0 ld [ %fp + -16 ], %g2 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EISDIR ); } if ( !loc.ops->unlink_h ) { 20190d0: c2 00 a0 0c ld [ %g2 + 0xc ], %g1 20190d4: 80 a0 60 00 cmp %g1, 0 20190d8: 22 80 00 22 be,a 2019160 20190dc: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->unlink_h)( &loc ); 20190e0: 9f c0 40 00 call %g1 20190e4: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &loc ); 20190e8: c2 07 bf f0 ld [ %fp + -16 ], %g1 20190ec: 80 a0 60 00 cmp %g1, 0 20190f0: 02 80 00 08 be 2019110 20190f4: b0 10 00 08 mov %o0, %i0 20190f8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20190fc: 80 a0 60 00 cmp %g1, 0 2019100: 02 80 00 31 be 20191c4 2019104: 01 00 00 00 nop 2019108: 9f c0 40 00 call %g1 201910c: 90 10 00 10 mov %l0, %o0 2019110: 81 c7 e0 08 ret 2019114: 81 e8 00 00 restore result = rtems_filesystem_evaluate_path( path, 0, &loc, FALSE ); if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); if (result != 0 && errno != ENOTSUP) { 2019118: 40 00 31 c0 call 2025818 <__errno> <== NOT EXECUTED 201911c: 01 00 00 00 nop <== NOT EXECUTED 2019120: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED 2019124: 80 a0 60 86 cmp %g1, 0x86 <== NOT EXECUTED 2019128: 02 bf ff e1 be 20190ac <== NOT EXECUTED 201912c: c4 07 bf f0 ld [ %fp + -16 ], %g2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 2019130: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED 2019134: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019138: 02 bf ff f6 be 2019110 <== NOT EXECUTED 201913c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2019140: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 2019144: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019148: 02 bf ff f2 be 2019110 <== NOT EXECUTED 201914c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2019150: 9f c0 40 00 call %g1 <== NOT EXECUTED 2019154: 01 00 00 00 nop <== NOT EXECUTED 2019158: 81 c7 e0 08 ret <== NOT EXECUTED 201915c: 81 e8 00 00 restore <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EISDIR ); } if ( !loc.ops->unlink_h ) { rtems_filesystem_freenode( &loc ); 2019160: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 2019164: 02 80 00 04 be 2019174 <== NOT EXECUTED 2019168: 01 00 00 00 nop <== NOT EXECUTED 201916c: 9f c0 40 00 call %g1 <== NOT EXECUTED 2019170: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 2019174: 40 00 31 a9 call 2025818 <__errno> <== NOT EXECUTED 2019178: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 201917c: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2019180: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2019184: 81 c7 e0 08 ret <== NOT EXECUTED 2019188: 81 e8 00 00 restore <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 201918c: c2 07 bf f0 ld [ %fp + -16 ], %g1 2019190: 80 a0 60 00 cmp %g1, 0 2019194: 02 80 00 08 be 20191b4 2019198: 01 00 00 00 nop 201919c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20191a0: 80 a0 60 00 cmp %g1, 0 20191a4: 02 80 00 04 be 20191b4 20191a8: 01 00 00 00 nop 20191ac: 9f c0 40 00 call %g1 20191b0: 90 10 00 10 mov %l0, %o0 rtems_set_errno_and_return_minus_one( EISDIR ); 20191b4: 40 00 31 99 call 2025818 <__errno> 20191b8: b0 10 3f ff mov -1, %i0 20191bc: 82 10 20 15 mov 0x15, %g1 20191c0: c2 22 00 00 st %g1, [ %o0 ] 20191c4: 81 c7 e0 08 ret 20191c8: 81 e8 00 00 restore 0200735c : */ int unmount( const char *path ) { 200735c: 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 ) ) 2007360: 92 10 20 00 clr %o1 2007364: a2 07 bf e8 add %fp, -24, %l1 2007368: 90 10 00 18 mov %i0, %o0 200736c: 94 10 00 11 mov %l1, %o2 2007370: 7f ff f0 51 call 20034b4 2007374: 96 10 20 01 mov 1, %o3 2007378: 80 a2 20 00 cmp %o0, 0 200737c: 02 80 00 04 be 200738c 2007380: e0 07 bf f4 ld [ %fp + -12 ], %l0 rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 2007384: 81 c7 e0 08 ret 2007388: 91 e8 3f ff restore %g0, -1, %o0 /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 200738c: 92 10 00 11 mov %l1, %o1 if ( rtems_filesystem_evaluate_path( path, 0x0, &loc, TRUE ) ) return -1; mt_entry = loc.mt_entry; fs_mount_loc = &mt_entry->mt_point_node; fs_root_loc = &mt_entry->mt_fs_root; 2007390: a4 04 20 18 add %l0, 0x18, %l2 /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 2007394: 7f ff ff d3 call 20072e0 2007398: 90 10 00 12 mov %l2, %o0 200739c: 80 a2 20 00 cmp %o0, 0 20073a0: 02 80 00 4a be 20074c8 20073a4: c2 07 bf f0 ld [ %fp + -16 ], %g1 /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 20073a8: 80 a0 60 00 cmp %g1, 0 20073ac: 22 80 00 09 be,a 20073d0 20073b0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 20073b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20073b8: 80 a0 60 00 cmp %g1, 0 20073bc: 22 80 00 05 be,a 20073d0 20073c0: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 <== NOT EXECUTED 20073c4: 9f c0 40 00 call %g1 20073c8: 90 10 00 11 mov %l1, %o0 /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 20073cc: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 20073d0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2 20073d4: 80 a0 a0 00 cmp %g2, 0 20073d8: 02 80 00 55 be 200752c 20073dc: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 20073e0: c2 04 20 20 ld [ %l0 + 0x20 ], %g1 20073e4: c4 00 60 2c ld [ %g1 + 0x2c ], %g2 20073e8: 80 a0 a0 00 cmp %g2, 0 20073ec: 02 80 00 50 be 200752c 20073f0: 03 00 80 68 sethi %hi(0x201a000), %g1 * 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 ) 20073f4: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 201a230 20073f8: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3 20073fc: 80 a0 c0 10 cmp %g3, %l0 2007400: 02 80 00 2c be 20074b0 2007404: 90 10 00 18 mov %i0, %o0 /* * Verify there are no file systems below the path specified */ if ( file_systems_below_this_mountpoint( path, fs_root_loc, mt_entry ) != 0 ) 2007408: 92 10 00 12 mov %l2, %o1 200740c: 7f ff ff bb call 20072f8 2007410: 94 10 00 10 mov %l0, %o2 2007414: 80 a2 20 00 cmp %o0, 0 2007418: 12 80 00 26 bne 20074b0 200741c: 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 ) 2007420: 7f ff f1 14 call 2003870 2007424: 90 10 00 10 mov %l0, %o0 2007428: 80 a2 20 01 cmp %o0, 1 200742c: 02 80 00 21 be 20074b0 2007430: 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 ) 2007434: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 2007438: c2 00 a0 28 ld [ %g2 + 0x28 ], %g1 200743c: 9f c0 40 00 call %g1 2007440: 90 10 00 10 mov %l0, %o0 2007444: 80 a2 20 00 cmp %o0, 0 2007448: 12 bf ff cf bne 2007384 200744c: 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){ 2007450: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 2007454: c2 00 a0 2c ld [ %g2 + 0x2c ], %g1 2007458: 9f c0 40 00 call %g1 200745c: 90 10 00 10 mov %l0, %o0 2007460: 80 a2 20 00 cmp %o0, 0 2007464: 32 80 00 28 bne,a 2007504 2007468: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED /* * Extract the mount table entry from the chain */ Chain_Extract( ( Chain_Node * ) mt_entry ); 200746c: 40 00 06 d3 call 2008fb8 <_Chain_Extract> 2007470: 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 ); 2007474: c2 04 20 10 ld [ %l0 + 0x10 ], %g1 2007478: 80 a0 60 00 cmp %g1, 0 200747c: 02 80 00 09 be 20074a0 2007480: 90 10 00 10 mov %l0, %o0 2007484: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 2007488: 80 a0 60 00 cmp %g1, 0 200748c: 02 80 00 05 be 20074a0 2007490: 01 00 00 00 nop 2007494: 9f c0 40 00 call %g1 2007498: 90 04 20 08 add %l0, 8, %o0 free( mt_entry ); 200749c: 90 10 00 10 mov %l0, %o0 20074a0: 7f ff f2 25 call 2003d34 20074a4: b0 10 20 00 clr %i0 20074a8: 81 c7 e0 08 ret 20074ac: 81 e8 00 00 restore * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) rtems_set_errno_and_return_minus_one( EBUSY ); 20074b0: 40 00 2a 2c call 2011d60 <__errno> 20074b4: b0 10 3f ff mov -1, %i0 20074b8: 82 10 20 10 mov 0x10, %g1 20074bc: c2 22 00 00 st %g1, [ %o0 ] 20074c0: 81 c7 e0 08 ret 20074c4: 81 e8 00 00 restore /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ rtems_filesystem_freenode( &loc ); 20074c8: 80 a0 60 00 cmp %g1, 0 20074cc: 02 80 00 08 be 20074ec 20074d0: 01 00 00 00 nop 20074d4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 20074d8: 80 a0 60 00 cmp %g1, 0 20074dc: 02 80 00 04 be 20074ec 20074e0: 01 00 00 00 nop 20074e4: 9f c0 40 00 call %g1 20074e8: 90 10 00 11 mov %l1, %o0 rtems_set_errno_and_return_minus_one( EACCES ); 20074ec: 40 00 2a 1d call 2011d60 <__errno> 20074f0: b0 10 3f ff mov -1, %i0 20074f4: 82 10 20 0d mov 0xd, %g1 20074f8: c2 22 00 00 st %g1, [ %o0 ] 20074fc: 81 c7 e0 08 ret 2007500: 81 e8 00 00 restore * This was response was questionable but the best we could * come up with. */ if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){ if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 2007504: c2 00 a0 20 ld [ %g2 + 0x20 ], %g1 <== NOT EXECUTED 2007508: 9f c0 40 00 call %g1 <== NOT EXECUTED 200750c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 2007510: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 2007514: 02 bf ff 9c be 2007384 <== NOT EXECUTED 2007518: 90 10 20 00 clr %o0 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 200751c: 40 00 05 c5 call 2008c30 <== NOT EXECUTED 2007520: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007524: 81 c7 e0 08 ret <== NOT EXECUTED 2007528: 81 e8 00 00 restore <== NOT EXECUTED if ( !fs_mount_loc->ops->unmount_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 200752c: 40 00 2a 0d call 2011d60 <__errno> <== NOT EXECUTED 2007530: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007534: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2007538: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200753c: 81 c7 e0 08 ret <== NOT EXECUTED 2007540: 81 e8 00 00 restore <== NOT EXECUTED 0200bfc8 : int usleep( useconds_t useconds ) { 200bfc8: 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; 200bfcc: 21 00 03 d0 sethi %hi(0xf4000), %l0 <== NOT EXECUTED 200bfd0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200bfd4: 7f ff d6 08 call 20017f4 <.udiv> <== NOT EXECUTED 200bfd8: 92 14 22 40 or %l0, 0x240, %o1 <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 200bfdc: 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; 200bfe0: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 200bfe4: 40 00 5e c2 call 2023aec <.urem> <== NOT EXECUTED 200bfe8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 200bfec: 85 2a 20 02 sll %o0, 2, %g2 <== NOT EXECUTED 200bff0: 83 2a 20 07 sll %o0, 7, %g1 <== NOT EXECUTED 200bff4: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED 200bff8: 82 00 40 08 add %g1, %o0, %g1 <== NOT EXECUTED 200bffc: 83 28 60 03 sll %g1, 3, %g1 <== NOT EXECUTED nanosleep( &tp, &tm ); 200c000: 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; 200c004: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED nanosleep( &tp, &tm ); 200c008: 40 00 27 32 call 2015cd0 <== NOT EXECUTED 200c00c: 90 07 bf f0 add %fp, -16, %o0 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 200c010: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED 200c014: d0 07 bf ec ld [ %fp + -20 ], %o0 <== NOT EXECUTED 200c018: 87 28 a0 03 sll %g2, 3, %g3 <== NOT EXECUTED 200c01c: 83 28 a0 08 sll %g2, 8, %g1 <== NOT EXECUTED 200c020: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED 200c024: 92 10 23 e8 mov 0x3e8, %o1 <== NOT EXECUTED 200c028: b1 28 60 06 sll %g1, 6, %i0 <== NOT EXECUTED 200c02c: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED 200c030: 7f ff d5 f3 call 20017fc <.div> <== NOT EXECUTED 200c034: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED 200c038: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 200c03c: 81 c7 e0 08 ret <== NOT EXECUTED 200c040: 91 ea 00 18 restore %o0, %i0, %o0 <== NOT EXECUTED 02006fbc : int utime( const char *path, const struct utimbuf *times ) { 2006fbc: 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 ) ) 2006fc0: 92 10 20 00 clr %o1 2006fc4: 90 10 00 18 mov %i0, %o0 2006fc8: a0 07 bf e8 add %fp, -24, %l0 2006fcc: 96 10 20 01 mov 1, %o3 2006fd0: 94 10 00 10 mov %l0, %o2 2006fd4: 7f ff f0 18 call 2003034 2006fd8: b0 10 3f ff mov -1, %i0 2006fdc: 80 a2 20 00 cmp %o0, 0 2006fe0: 12 80 00 14 bne 2007030 2006fe4: c4 07 bf f0 ld [ %fp + -16 ], %g2 return -1; if ( !temp_loc.ops->utime_h ){ 2006fe8: c2 00 a0 30 ld [ %g2 + 0x30 ], %g1 2006fec: 80 a0 60 00 cmp %g1, 0 2006ff0: 22 80 00 12 be,a 2007038 2006ff4: c2 00 a0 1c ld [ %g2 + 0x1c ], %g1 <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 2006ff8: d4 06 60 04 ld [ %i1 + 4 ], %o2 2006ffc: d2 06 40 00 ld [ %i1 ], %o1 2007000: 9f c0 40 00 call %g1 2007004: 90 10 00 10 mov %l0, %o0 rtems_filesystem_freenode( &temp_loc ); 2007008: c2 07 bf f0 ld [ %fp + -16 ], %g1 200700c: 80 a0 60 00 cmp %g1, 0 2007010: 02 80 00 08 be 2007030 2007014: b0 10 00 08 mov %o0, %i0 2007018: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 200701c: 80 a0 60 00 cmp %g1, 0 2007020: 02 80 00 0f be 200705c 2007024: 01 00 00 00 nop 2007028: 9f c0 40 00 call %g1 200702c: 90 10 00 10 mov %l0, %o0 return result; } 2007030: 81 c7 e0 08 ret 2007034: 81 e8 00 00 restore if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, TRUE ) ) return -1; if ( !temp_loc.ops->utime_h ){ rtems_filesystem_freenode( &temp_loc ); 2007038: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 200703c: 02 80 00 04 be 200704c <== NOT EXECUTED 2007040: 01 00 00 00 nop <== NOT EXECUTED 2007044: 9f c0 40 00 call %g1 <== NOT EXECUTED 2007048: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 200704c: 40 00 2b 1c call 2011cbc <__errno> <== NOT EXECUTED 2007050: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 2007054: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED 2007058: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 200705c: 81 c7 e0 08 ret <== NOT EXECUTED 2007060: 81 e8 00 00 restore <== NOT EXECUTED 02002fcc : | Arguments: as in printf: fmt - format string, ... - unnamed arguments. | Returns: Nothing. +--------------------------------------------------------------------------*/ void vprintk(const char *fmt, va_list ap) { 2002fcc: 9d e3 bf 80 save %sp, -128, %sp char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 2002fd0: d0 0e 00 00 ldub [ %i0 ], %o0 2002fd4: 91 2a 20 18 sll %o0, 0x18, %o0 2002fd8: 80 a2 20 00 cmp %o0, 0 2002fdc: 02 80 00 3a be 20030c4 2002fe0: 03 00 80 0b sethi %hi(0x2002c00), %g1 2002fe4: 05 00 80 5e sethi %hi(0x2017800), %g2 if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) 2002fe8: b4 10 62 f8 or %g1, 0x2f8, %i2 2002fec: b8 10 a1 60 or %g2, 0x160, %i4 break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 2002ff0: 3b 00 80 61 sethi %hi(0x2018400), %i5 2002ff4: ac 07 bf e4 add %fp, -28, %l6 lflag = 0; base = 0; sign = 0; width = 0; lead = ' '; if (*fmt == '%') 2002ff8: 91 3a 20 18 sra %o0, 0x18, %o0 2002ffc: 80 a2 20 25 cmp %o0, 0x25 2003000: 12 80 00 33 bne 20030cc 2003004: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 { fmt++; 2003008: b0 06 20 01 inc %i0 if (*fmt == '0' ) { 200300c: d0 0e 00 00 ldub [ %i0 ], %o0 2003010: 87 2a 20 18 sll %o0, 0x18, %g3 2003014: 83 38 e0 18 sra %g3, 0x18, %g1 2003018: 80 a0 60 30 cmp %g1, 0x30 200301c: 02 80 00 97 be 2003278 2003020: b6 10 20 20 mov 0x20, %i3 lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 2003024: 82 02 3f d0 add %o0, -48, %g1 2003028: 82 08 60 ff and %g1, 0xff, %g1 200302c: 80 a0 60 09 cmp %g1, 9 2003030: 08 80 00 05 bleu 2003044 2003034: aa 10 20 00 clr %l5 width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') 2003038: 10 80 00 11 b 200307c 200303c: 83 38 e0 18 sra %g3, 0x18, %g1 2003040: 87 2a 20 18 sll %o0, 0x18, %g3 <== NOT EXECUTED fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; width += (*fmt - '0'); fmt++; 2003044: b0 06 20 01 inc %i0 fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 2003048: d0 0e 00 00 ldub [ %i0 ], %o0 width *= 10; width += (*fmt - '0'); 200304c: 85 2d 60 03 sll %l5, 3, %g2 2003050: 83 2d 60 01 sll %l5, 1, %g1 2003054: 87 38 e0 18 sra %g3, 0x18, %g3 2003058: 82 00 40 02 add %g1, %g2, %g1 fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 200305c: 84 02 3f d0 add %o0, -48, %g2 width *= 10; width += (*fmt - '0'); 2003060: 82 00 40 03 add %g1, %g3, %g1 fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 2003064: 84 08 a0 ff and %g2, 0xff, %g2 2003068: 80 a0 a0 09 cmp %g2, 9 200306c: 08 bf ff f5 bleu 2003040 2003070: aa 00 7f d0 add %g1, -48, %l5 2003074: 87 2a 20 18 sll %o0, 0x18, %g3 width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') 2003078: 83 38 e0 18 sra %g3, 0x18, %g1 200307c: 80 a0 60 6c cmp %g1, 0x6c 2003080: 22 80 00 83 be,a 200328c 2003084: b0 06 20 01 inc %i0 { lflag = 1; c = *++fmt; } switch (c) 2003088: 82 02 3f bc add %o0, -68, %g1 200308c: 82 08 60 ff and %g1, 0xff, %g1 2003090: 80 a0 60 34 cmp %g1, 0x34 2003094: 08 80 00 12 bleu 20030dc 2003098: 83 28 60 02 sll %g1, 2, %g1 break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 200309c: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 <== NOT EXECUTED 20030a0: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED 20030a4: 9f c0 40 00 call %g1 <== NOT EXECUTED 20030a8: 91 3a 20 18 sra %o0, 0x18, %o0 <== NOT EXECUTED vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 20030ac: b0 06 20 01 inc %i0 <== NOT EXECUTED 20030b0: d0 0e 00 00 ldub [ %i0 ], %o0 20030b4: 91 2a 20 18 sll %o0, 0x18, %o0 20030b8: 80 a2 20 00 cmp %o0, 0 20030bc: 12 bf ff d0 bne 2002ffc 20030c0: 91 3a 20 18 sra %o0, 0x18, %o0 20030c4: 81 c7 e0 08 ret 20030c8: 81 e8 00 00 restore printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 20030cc: 9f c0 40 00 call %g1 20030d0: 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++) 20030d4: 10 bf ff f8 b 20030b4 20030d8: d0 0e 00 00 ldub [ %i0 ], %o0 if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) 20030dc: c4 06 80 01 ld [ %i2 + %g1 ], %g2 20030e0: 81 c0 80 00 jmp %g2 20030e4: 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++) 20030e8: e0 06 40 00 ld [ %i1 ], %l0 20030ec: d0 0c 00 00 ldub [ %l0 ], %o0 20030f0: 91 2a 20 18 sll %o0, 0x18, %o0 20030f4: 80 a2 20 00 cmp %o0, 0 20030f8: 02 bf ff ed be 20030ac 20030fc: b2 06 60 04 add %i1, 4, %i1 BSP_output_char(*str); 2003100: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 2003104: 9f c0 40 00 call %g1 2003108: 91 3a 20 18 sra %o0, 0x18, %o0 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++) 200310c: a0 04 20 01 inc %l0 2003110: d0 0c 00 00 ldub [ %l0 ], %o0 2003114: 91 2a 20 18 sll %o0, 0x18, %o0 2003118: 80 a2 20 00 cmp %o0, 0 200311c: 12 bf ff fa bne 2003104 2003120: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 2003124: 10 bf ff e3 b 20030b0 2003128: b0 06 20 01 inc %i0 break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 200312c: 82 10 20 00 clr %g1 2003130: a4 10 20 10 mov 0x10, %l2 break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 2003134: e2 06 40 00 ld [ %i1 ], %l1 { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 2003138: 80 88 60 ff btst 0xff, %g1 BSP_output_char(c); break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 200313c: b2 06 60 04 add %i1, 4, %i1 { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 2003140: 02 80 00 0d be 2003174 2003144: a6 10 00 1d mov %i5, %l3 2003148: 80 a4 60 00 cmp %l1, 0 200314c: 16 80 00 0b bge 2003178 2003150: 90 10 00 11 mov %l1, %o0 BSP_output_char('-'); 2003154: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 <== NOT EXECUTED 2003158: 9f c0 40 00 call %g1 <== NOT EXECUTED 200315c: 90 10 20 2d mov 0x2d, %o0 <== NOT EXECUTED num = -num; if (maxwidth) maxwidth--; 2003160: 82 1d 60 00 xor %l5, 0, %g1 <== NOT EXECUTED int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { BSP_output_char('-'); num = -num; 2003164: a2 20 00 11 neg %l1 <== NOT EXECUTED if (maxwidth) maxwidth--; 2003168: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED 200316c: 84 40 20 00 addx %g0, 0, %g2 <== NOT EXECUTED 2003170: aa 25 40 02 sub %l5, %g2, %l5 <== NOT EXECUTED } count = 0; while ((n = num / base) > 0) { 2003174: 90 10 00 11 mov %l1, %o0 2003178: 92 10 00 12 mov %l2, %o1 200317c: 40 00 4b 6e call 2015f34 <.udiv> 2003180: a8 10 20 00 clr %l4 2003184: a0 92 20 00 orcc %o0, 0, %l0 2003188: 12 80 00 05 bne 200319c 200318c: ae 10 00 16 mov %l6, %l7 2003190: 10 80 00 41 b 2003294 2003194: a4 10 20 01 mov 1, %l2 2003198: a0 10 00 08 mov %o0, %l0 toPrint[count++] = (num - (n*base)); 200319c: 92 10 00 12 mov %l2, %o1 20031a0: 40 00 4b 2b call 2015e4c <.umul> 20031a4: 90 10 00 10 mov %l0, %o0 20031a8: 90 24 40 08 sub %l1, %o0, %o0 num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 20031ac: 92 10 00 12 mov %l2, %o1 toPrint[count++] = (num - (n*base)); 20031b0: d0 2d 00 16 stb %o0, [ %l4 + %l6 ] num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 20031b4: 90 10 00 10 mov %l0, %o0 20031b8: 40 00 4b 5f call 2015f34 <.udiv> 20031bc: a8 05 20 01 inc %l4 20031c0: 80 a2 20 00 cmp %o0, 0 20031c4: 12 bf ff f5 bne 2003198 20031c8: a2 10 00 10 mov %l0, %l1 20031cc: a4 05 20 01 add %l4, 1, %l2 toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; 20031d0: 84 07 bf f8 add %fp, -8, %g2 20031d4: 82 00 80 14 add %g2, %l4, %g1 20031d8: e2 28 7f ec stb %l1, [ %g1 + -20 ] for (n=maxwidth ; n > count; n-- ) 20031dc: 80 a5 40 12 cmp %l5, %l2 20031e0: 08 80 00 0a bleu 2003208 20031e4: a0 10 00 15 mov %l5, %l0 20031e8: a2 10 00 1b mov %i3, %l1 BSP_output_char(lead); 20031ec: c2 04 e1 e4 ld [ %l3 + 0x1e4 ], %g1 20031f0: 9f c0 40 00 call %g1 20031f4: 90 10 00 11 mov %l1, %o0 toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 20031f8: a0 04 3f ff add %l0, -1, %l0 20031fc: 80 a4 00 12 cmp %l0, %l2 2003200: 18 bf ff fc bgu 20031f0 2003204: c2 04 e1 e4 ld [ %l3 + 0x1e4 ], %g1 2003208: 82 04 bf ff add %l2, -1, %g1 200320c: a2 10 20 00 clr %l1 2003210: a0 05 c0 01 add %l7, %g1, %l0 BSP_output_char(lead); for (n = 0; n < count; n++){ BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 2003214: c2 4c 00 00 ldsb [ %l0 ], %g1 2003218: c4 04 e1 e4 ld [ %l3 + 0x1e4 ], %g2 200321c: d0 4f 00 01 ldsb [ %i4 + %g1 ], %o0 2003220: 9f c0 80 00 call %g2 2003224: a2 04 60 01 inc %l1 toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++){ 2003228: 80 a4 40 12 cmp %l1, %l2 200322c: 0a bf ff fa bcs 2003214 2003230: a0 04 3f ff add %l0, -1, %l0 vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 2003234: 10 bf ff 9f b 20030b0 2003238: b0 06 20 01 inc %i0 case 's': for (str = va_arg(ap, char *); *str; str++) BSP_output_char(*str); break; case 'c': BSP_output_char(va_arg(ap, int)); 200323c: d0 4e 60 03 ldsb [ %i1 + 3 ], %o0 <== NOT EXECUTED 2003240: c2 07 61 e4 ld [ %i5 + 0x1e4 ], %g1 <== NOT EXECUTED 2003244: 9f c0 40 00 call %g1 <== NOT EXECUTED 2003248: b2 06 60 04 add %i1, 4, %i1 <== NOT EXECUTED vprintk(const char *fmt, va_list ap) { char c, *str; int lflag, base, sign, width, lead; for (; *fmt != '\0'; fmt++) 200324c: 10 bf ff 99 b 20030b0 <== NOT EXECUTED 2003250: b0 06 20 01 inc %i0 <== NOT EXECUTED } switch (c) { case 'o': case 'O': base = 8; sign = 0; break; case 'i': case 'I': case 'd': case 'D': base = 10; sign = 1; break; 2003254: 82 10 20 00 clr %g1 <== NOT EXECUTED 2003258: 10 bf ff b7 b 2003134 <== NOT EXECUTED 200325c: a4 10 20 0a mov 0xa, %l2 <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) 2003260: 82 10 20 00 clr %g1 <== NOT EXECUTED 2003264: 10 bf ff b4 b 2003134 <== NOT EXECUTED 2003268: a4 10 20 08 mov 8, %l2 <== NOT EXECUTED { case 'o': case 'O': base = 8; sign = 0; break; 200326c: 82 10 20 01 mov 1, %g1 2003270: 10 bf ff b1 b 2003134 2003274: a4 10 20 0a mov 0xa, %l2 if (*fmt == '%') { fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; 2003278: b0 06 20 01 inc %i0 200327c: d0 0e 00 00 ldub [ %i0 ], %o0 2003280: b6 10 20 30 mov 0x30, %i3 2003284: 10 bf ff 68 b 2003024 2003288: 87 2a 20 18 sll %o0, 0x18, %g3 } if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; 200328c: 10 bf ff 7f b 2003088 2003290: d0 0e 00 00 ldub [ %i0 ], %o0 count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); num = n ; } toPrint[count++] = num; 2003294: 10 bf ff d0 b 20031d4 2003298: 84 07 bf f8 add %fp, -8, %g2 020170cc : ssize_t write( int fd, const void *buffer, size_t count ) { 20170cc: 9d e3 bf 98 save %sp, -104, %sp ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 20170d0: 03 00 80 61 sethi %hi(0x2018400), %g1 20170d4: c4 00 60 ec ld [ %g1 + 0xec ], %g2 ! 20184ec ssize_t write( int fd, const void *buffer, size_t count ) { 20170d8: 92 10 00 19 mov %i1, %o1 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 20170dc: 80 a6 00 02 cmp %i0, %g2 20170e0: 1a 80 00 24 bcc 2017170 20170e4: 94 10 00 1a mov %i2, %o2 iop = rtems_libio_iop( fd ); 20170e8: 03 00 80 65 sethi %hi(0x2019400), %g1 20170ec: c6 00 62 70 ld [ %g1 + 0x270 ], %g3 ! 2019670 20170f0: 85 2e 20 02 sll %i0, 2, %g2 20170f4: 83 2e 20 04 sll %i0, 4, %g1 20170f8: 82 20 40 02 sub %g1, %g2, %g1 20170fc: 82 00 40 18 add %g1, %i0, %g1 2017100: 83 28 60 02 sll %g1, 2, %g1 2017104: b0 00 40 03 add %g1, %g3, %i0 rtems_libio_check_is_open(iop); 2017108: c2 06 20 0c ld [ %i0 + 0xc ], %g1 201710c: 80 88 61 00 btst 0x100, %g1 2017110: 02 80 00 18 be 2017170 2017114: 80 a6 60 00 cmp %i1, 0 rtems_libio_check_buffer( buffer ); 2017118: 02 80 00 1c be 2017188 201711c: 80 a6 a0 00 cmp %i2, 0 rtems_libio_check_count( count ); 2017120: 02 80 00 12 be 2017168 2017124: 90 10 20 00 clr %o0 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 2017128: 80 88 60 04 btst 4, %g1 201712c: 02 80 00 17 be 2017188 2017130: 01 00 00 00 nop /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 2017134: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 2017138: c2 00 60 0c ld [ %g1 + 0xc ], %g1 201713c: 80 a0 60 00 cmp %g1, 0 2017140: 02 80 00 18 be 20171a0 2017144: 01 00 00 00 nop rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->write_h)( iop, buffer, count ); 2017148: 9f c0 40 00 call %g1 201714c: 90 10 00 18 mov %i0, %o0 if ( rc > 0 ) 2017150: 80 a2 20 00 cmp %o0, 0 2017154: 04 80 00 05 ble 2017168 2017158: 01 00 00 00 nop iop->offset += rc; 201715c: c2 06 20 08 ld [ %i0 + 8 ], %g1 2017160: 82 00 40 08 add %g1, %o0, %g1 2017164: c2 26 20 08 st %g1, [ %i0 + 8 ] return rc; } 2017168: 81 c7 e0 08 ret 201716c: 91 e8 00 08 restore %g0, %o0, %o0 ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 2017170: 7f ff df d4 call 200f0c0 <__errno> <== NOT EXECUTED 2017174: 01 00 00 00 nop <== NOT EXECUTED 2017178: 82 10 20 09 mov 9, %g1 ! 9 <== NOT EXECUTED 201717c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017180: 10 bf ff fa b 2017168 <== NOT EXECUTED 2017184: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 2017188: 7f ff df ce call 200f0c0 <__errno> <== NOT EXECUTED 201718c: 01 00 00 00 nop <== NOT EXECUTED 2017190: 82 10 20 16 mov 0x16, %g1 ! 16 <== NOT EXECUTED 2017194: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 2017198: 10 bf ff f4 b 2017168 <== NOT EXECUTED 201719c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 20171a0: 7f ff df c8 call 200f0c0 <__errno> <== NOT EXECUTED 20171a4: 01 00 00 00 nop <== NOT EXECUTED 20171a8: 82 10 20 86 mov 0x86, %g1 ! 86 <== NOT EXECUTED 20171ac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 20171b0: 10 bf ff ee b 2017168 <== NOT EXECUTED 20171b4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED